Ошибки: Неуместная рекурсия при вычислении миноров

double det(dpuble *a, int n)
{
 double ***minors;
 double result;
 int m;
 int i;
 int j;
 if (n==2)
 {
   return (a[0][0]*a[1][1]-a[1][0]*a[0][1];
 }
 minors=new double**[n];
 for (result=0.0, m=0; m<n; ++m)
 {
  minors[m]=new double*[n-1];
  for (i=0, i<(n-1); i++)
  {
   minors[m][i]=new double[n-1];
   for (j=0, j<(n-1); j++)
   {
    if (i<m)
    {
     minors[m][i][j]=a[i][j+1];
    }
    else
    {
     minors[m][i][j]=a[i-1][j+1];
    }
   }
   if (i%2==0)
   {
    result+=det(minors[m], n-1);
   }
   else
   {
    result-=det(minors[m], n-1);
   }
   delete [] minors[m][i];
  }
  delete [] minors[m];
 }
 delete [] minors;
 return result;
}
void kramer(double **a, int n, double *b, double *x)
{
 double **ax;
 double d;
 double dx;
 int i;
 int j;
 int k;
 d=det(a, n);
 ax=new double*[n];
 for (i=0; i<n; ++i)
 {
  ax=new double [n];  
  for (j=0; j<n; ++j)
  {
   ax[j]=new double [n];  
   for (k=0; k<n; ++k)
   {
    if (i==j)
    {
     ax[j][k]=b[k];
    }
    else
    {
     ax[j][k]=a[j][k];
    }
   }
   dx=det(ax,n);
   x[i]=dx/d;
  }
  for (j=0; j<n; ++j)
  {  
   delete [] ax[j];
  }
 }
 delete [] ax;
}

double det(double **a, int n)
{
 int i;
 int j;
 int k;
 double r;
 for (i=0; i<n; ++i)
 {
   for (j=i+1; j<n; ++j)
   {
    for (k=i+1; k<n; ++k)
    {
     a[j][k]-=a[i][k]*a[j][i]/a[i][i];
    }
    a[j][i]=0.0;  
   }
 }
 for (r=1.0, i=0; i<n; ++i)
 {
  r*=a[i][i];
 }
 return r;
}

for(int i = 0; //blabla)
{
if(IndexSet.find(i) != IndexSet.end())
{
continue;
}
for(int j = 0; //blabla)
{
if(IndexSet.find(j) != IndexSet.end())
{
continue;
}
}
}

TDir *Search(TDir *Dir, std::string &Name)
{
 TDir *p;
 TDir *t;
 if (Dir->Name==Name)
 {
  return Dir;
 }
 if (Dir->ChildrenCount>0)
 {
  for (p=Dir->Children+Dir->ChildrenCount-1; p>=Dir->Children; --p)
  {
   t=Search(p, Name);
   if (t!=NULL)
   {
    return t;
   }
  }
 }
 return NULL;
}

unsigned long int f(unsigned short int n)
{
 if (x==0)
 {
  return 1;
 }
 return f(n-1)*n;
}

int *minor (int *A, int n, int k)
{
    int sz,i,j,jj,ii,pf,pt;
    int *m;
    sz=n-1;
    m=new int[sz*sz];
    ii=-1;
    for (i=0; i<n; i++)
        if (i != k) 
        {
            ii++;
            for (j=1; j<n; j++)
            {
                jj=j-1;
                pf=index(n,j,i);
                pt=index(n-1,jj,ii);
                m[pt]=A[pf];
            }
        }
    return m;
}
        
int Det (int *A,int n)
{
    int i,s,p,z;
    int *mi;
 
    if (n == 2)
        return A[0]*A[3]-A[1]*A[2];
    else
    {
        s=0;
        p=1;
        for (i=0; i<n; i++)
        {
            z=A[index(n,0,i)];
            mi=minor(A,n,i);           // строим минор
            s+=p*z*Det(mi,(n-1)); // учитываем
            p=-p;                        // удаляем
            delete mi;
        }
        return s;
    }
}

int index(int n, int i, int j)
{
    return n*i+j;
}