double *b, *fvec, *a, x*;
		MKL_INT* ja;
		MKL_INT* ia;
		x  = (double*) malloc (sizeof (double) * n  )
		a = (double*) malloc (sizeof (double)*c);
		ja = (MKL_INT*) malloc (sizeof (MKL_INT)*c);
		ia = (MKL_INT*) malloc (sizeof (MKL_INT)*(dOF + 1));
		b = (double*) malloc (sizeof (double)*n);
		fvec = (double*) malloc (sizeof (double)*n);

		vector<vector<double>> matJacbn(3*ndTotal, vector<double>(3*ndTotal, 0));

		for (j = 0; j < dOF + 1; j++)
		{
			ia[j] = 0.0;
		}
		for (i = 0; i < n; i++)
		{
			x[i] = 0.0;
		}
		for (i = 0; i < c; i++)
		{
			ja[i] = 0.0;
			a[i] = 0.0;
		}

		/*	Building input parameters for pardiso()	*/
		/*	a - array
		/*	ja - array
		/*	ia - array	*/
		c = 0;
		k = 0;
		i = 0;
		bool bob;
		int f;
		for (rows=0; rows<dOF; rows++) 
		{
			f = c;
			j = 0;
			bob = true;
			for (cols=0; cols<dOF; cols++) 
			{
				if(matJacbn[rows][cols] == 0)
				{
					j++;
				}
				if(matJacbn[rows][cols] != 0)
				{
					a[c] = matJacbn[rows][cols];
					ja[k] = cols;
					k++;
					if(bob)
					{
						ia[i] = c;
						i++;
						bob = false;
					}
					c++;
				}
				if(j == dOF)
				{
					ia[i] = f;
					i++;
				}
			}
		}
		ia[dOF] = c + 1;


		/* Pardiso control parameters. */
		MKL_INT maxfct, mnum, mtype, phase, nrhs, msglvl, error;
		/* Auxiliary variables. */
		double *ddum; /* Double dummy */
		MKL_INT *idum; /* Integer dummy. */

		/* Internal solver memory pointer pt, */
		/* 32-bit: int pt[64]; 64-bit: long int pt[64] */
		/* or void *pt[64] should be OK on both architectures */
		void *pt[64];
		MKL_INT *perm, *iparm;
		perm = (MKL_INT*) malloc (sizeof (MKL_INT*)*n);
		iparm = (MKL_INT*) malloc (sizeof (MKL_INT*)*64);
		/* -------------------------------------------------------------------- */
		/* .. Initialize the internal solver memory pointer. This is only */
		/* necessary for the FIRST call of the PARDISO solver. */
		/* -------------------------------------------------------------------- */
		for (i = 0; i < 64; i++) 
		{
			pt[i] = 0;
			iparm[i] = 0;
		}
		/* -------------------------------------------------------------------- */
		/* .. Initialize the internal solver memory pointer. This is only */
		/* necessary for the FIRST call of the PARDISO solver. */
		/* -------------------------------------------------------------------- */
		for (i = 0; i < n; i++) 
		{
			perm[i] = 0;
		}
		/* -------------------------------------------------------------------- */
		/* .. Setup Pardiso control parameters. */
		/* -------------------------------------------------------------------- */
		//iparm[0] = 0;	/*	Default Values	*/
		iparm[26] = 1; /* matrix checker */
		//iparm[27] = 0; /* mtype 11 double precision */
		iparm[34] = 1; /* = 1 for zero-based indexing; = 0 for one-based indexing */
		maxfct = 1; /* Maximum number of numerical factorizations. */
		mnum = 1; /* Which factorization to use. */
		msglvl = 1; /* Print statistical information in file */
		mtype = 11; /* Matrix Type */
		error = 0; /* Initialize error flag */
		/*
		out << "i Parameters" << endl;
		for (i=0; i<64; i++) 
		{
		out << iparm[i] << endl;
		}
		out.close();*/

		/* -------------------------------------------------------------------- */
		/* .. Reordering and Symbolic Factorization. This step also allocates */
		/* all memory that is necessary for the factorization. */
		/* -------------------------------------------------------------------- */
		phase = 11;
		pardiso (pt, &maxfct, &mnum, &mtype, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
		if (error != 0) {
			printf("\nERROR during symbolic factorization: %d", error);
			exit(1);
		}
		printf("\nReordering completed ... ");
		printf("\nNumber of nonzeros in factors = %d", iparm[17]);
		printf("\nNumber of factorization MFLOPS = %d", iparm[18]);

		/* free allocated memory */
		free (x);
		free (a);
		free (ja);
		free (ia);
		free (b);
		free (perm);
		free (iparm);
		free (fvec);
		/* Release internal MKL memory that might be used for computations         */
		/* NOTE: It is important to call the routine below to avoid memory leaks   */
		/* unless you disable MKL Memory Manager                                   */
		MKL_FreeBuffers();