decompiled_code:
__int64 __fastcall umfdi_report_vector(int a1, __int64 a2, __int64 a3, int a4, int a5, int a6)
{
unsigned int i; // ebx
__int64 result; // rax
int v12; // er15
signed int v13; // ebx
bool v14; // [rsp+Fh] [rbp-39h]

v14 = a4 > 3 || a5 != 0;
if ( !v14 )
goto LABEL_10;
if ( amd_printf )
amd_printf("dense vector, n = %d. ", (unsigned int)a1);
if ( !a5 )
{
LABEL_8:
if ( amd_printf )
amd_printf("\n");
LABEL_10:
if ( a4 == 4 )
{
v12 = 10;
if ( a1 <= 10 )
v12 = a1;
if ( a1 > 0 )
{
v13 = 0;
do
print_value(v13++, a2, a3, a6);
while ( v12 > v13 );
}
if ( a1 > v12 )
{
if ( amd_printf )
amd_printf(" ...\n");
print_value(a1 - 1, a2, a3, a6);
}
}
else
{
if ( a4 > 4 && a1 > 0 )
{
for ( i = 0; i != a1; ++i )
print_value(i, a2, a3, a6);
}
if ( a4 <= 3 )
{
if ( !v14 )
return 0LL;
LABEL_34:
if ( amd_printf )
amd_printf("OK\n\n");
return 0LL;
}
}
result = 0LL;
if ( !amd_printf )
return result;
amd_printf(" dense vector ");
goto LABEL_34;
}
if ( a2 )
{
if ( a1 >= 0 )
{
if ( a4 <= 3 )
goto LABEL_10;
goto LABEL_8;
}
result = 4294967290LL;
if ( amd_printf )
{
amd_printf("ERROR: length of vector is < 0\n\n");
result = 4294967290LL;
}
}
else
{
result = 4294967291LL;
if ( amd_printf )
{
amd_printf("ERROR: vector not present\n\n");
result = 4294967291LL;
}
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(int a1, __int64 a2, __int64 a3, int a4, int a5, int a6)
{
unsigned int i; // ebx
__int64 result; // rax
int v12; // er15
signed int v13; // ebx
bool v14; // [rsp+Fh] [rbp-39h]

v14 = a4 > 3 || a5 != 0;
if ( !v14 )
goto LABEL_10;
if ( amd_printf )
amd_printf("dense vector, n = %d. ", (unsigned int)a1);
if ( !a5 )
{
LABEL_8:
if ( amd_printf )
amd_printf("\n");
LABEL_10:
if ( a4 == 4 )
{
v12 = 10;
if ( a1 <= 10 )
v12 = a1;
if ( a1 > 0 )
{
v13 = 0;
do
print_value(v13++, a2, a3, a6);
while ( v12 > v13 );
}
if ( a1 > v12 )
{
if ( amd_printf )
amd_printf(" ...\n");
print_value(a1 - 1, a2, a3, a6);
}
}
else
{
if ( a4 > 4 && a1 > 0 )
{
for ( i = 0; i != a1; ++i )
print_value(i, a2, a3, a6);
}
if ( a4 <= 3 )
{
if ( !v14 )
return 0LL;
LABEL_34:
if ( amd_printf )
amd_printf("OK\n\n");
return 0LL;
}
}
result = 0LL;
if ( !amd_printf )
return result;
amd_printf(" dense vector ");
goto LABEL_34;
}
if ( a2 )
{
if ( a1 >= 0 )
{
if ( a4 <= 3 )
goto LABEL_10;
goto LABEL_8;
}
result = 4294967290LL;
if ( amd_printf )
{
amd_printf("ERROR: length of vector is < 0\n\n");
result = 4294967290LL;
}
}
else
{
result = 4294967291LL;
if ( amd_printf )
{
amd_printf("ERROR: vector not present\n\n");
result = 4294967291LL;
}
}
return result;
}

original_code:
int umfdi_report_vector
(
    int n,
    const double Xx [ ],
    const double Xz [ ],
    int prl,
    int user,
    int scalar
)
{
    int n2, i ;
    if (user || prl >= 4)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("dense vector, n = ""%d"". ", n) ; } ;
    }
    if (user)
    {
 if (!Xx)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: vector not present\n\n") ; } ;
     return ((-5)) ;
 }
 if (n < 0)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: length of vector is < 0\n\n") ; } ;
     return ((-6)) ;
 }
    }
    if (user || prl >= 4)
    {
 { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ; } } ;
    }
    if (prl == 4)
    {
 n2 = (((10) < (n)) ? (10) : (n)) ;
 for (i = 0 ; i < n2 ; i++)
 {
     print_value (i, Xx, Xz, scalar) ;
 }
 if (n2 < n)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("    ...\n") ; } ;
     print_value (n-1, Xx, Xz, scalar) ;
 }
    }
    else if (prl > 4)
    {
 for (i = 0 ; i < n ; i++)
 {
     print_value (i, Xx, Xz, scalar) ;
 }
    }
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("    dense vector ") ; } ; } } ;
    if (user || prl >= 4)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("OK\n\n") ; } ;
    }
    return ((0)) ;
}

canonical_original_code:
int umfdi_report_vector(int n, double Xx[], double Xz[], int prl, int user, int scalar)
{
    int n2; int i;
    if (user || prl >= 4)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("dense vector, n = ""%d"". ", n) ; } ;
    }
    if (user)
    {
 if (!Xx)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: vector not present\n\n") ; } ;
     return ((-5)) ;
 }
 if (n < 0)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: length of vector is < 0\n\n") ; } ;
     return ((-6)) ;
 }
    }
    if (user || prl >= 4)
    {
 { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ; } } ;
    }
    if (prl == 4)
    {
 n2 = (((10) < (n)) ? (10) : (n)) ;
 for (i = 0 ; i < n2 ; i++)
 {
     print_value (i, Xx, Xz, scalar) ;
 }
 if (n2 < n)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("    ...\n") ; } ;
     print_value (n-1, Xx, Xz, scalar) ;
 }
    }
    else if (prl > 4)
    {
 for (i = 0 ; i < n ; i++)
 {
     print_value (i, Xx, Xz, scalar) ;
 }
    }
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("    dense vector ") ; } ; } } ;
    if (user || prl >= 4)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("OK\n\n") ; } ;
    }
    return ((0)) ;
}

variable_types: n int

variable_types:
Xx
double []

variable_types:
Xz
double []

variable_types: user int

variable_types: scalar int

variable_types: i int


original_code:
long umfpack_dl_col_to_triplet
(
    long n_col,
    const long Ap [ ],
    long Tj [ ]
)
{
    long nz, j, p, p1, p2, length ;
    if (!Ap || !Tj)
    {
 return ((-5)) ;
    }
    if (n_col <= 0)
    {
 return ((-6)) ;
    }
    if (Ap [0] != 0)
    {
 return ((-8)) ;
    }
    nz = Ap [n_col] ;
    if (nz < 0)
    {
 return ((-8)) ;
    }
    for (j = 0 ; j < n_col ; j++)
    {
 p1 = Ap [j] ;
 p2 = Ap [j+1] ;
 length = p2 - p1 ;
 if (length < 0 || p2 > nz)
 {
     return ((-8)) ;
 }
 for (p = p1 ; p < p2 ; p++)
 {
     Tj [p] = j ;
 }
    }
    return ((0)) ;
}

canonical_original_code:
long umfpack_dl_col_to_triplet(long n_col, long Ap[], long Tj[])
{
    long nz; long j; long p; long p1; long p2; long length;
    if (!Ap || !Tj)
    {
 return ((-5)) ;
    }
    if (n_col <= 0)
    {
 return ((-6)) ;
    }
    if (Ap [0] != 0)
    {
 return ((-8)) ;
    }
    nz = Ap [n_col] ;
    if (nz < 0)
    {
 return ((-8)) ;
    }
    for (j = 0 ; j < n_col ; j++)
    {
 p1 = Ap [j] ;
 p2 = Ap [j+1] ;
 length = p2 - p1 ;
 if (length < 0 || p2 > nz)
 {
     return ((-8)) ;
 }
 for (p = p1 ; p < p2 ; p++)
 {
     Tj [p] = j ;
 }
    }
    return ((0)) ;
}

variable_types:
Ap
long []

variable_types:
Tj
long []

variable_types: nz long

variable_types: j long

variable_types: p long

variable_types: length long

return_type: long


original_code:
int umfzi_init_front
(
    NumericType *Numeric,
    WorkType *Work
)
{
    int i, j, fnr_curr, row, col, *Frows, *Fcols,
 *Fcpos, *Frpos, fncols, fnrows, *Wrow, fnr2, fnc2, rrdeg, ccdeg, *Wm,
 fnrows_extended ;
    DoubleComplex *Fcblock, *Fl, *Wy, *Wx ;
    if (Work->do_grow)
    {
 fnr2 = (1.2) * Work->fnrows_new + 2 ;
 fnc2 = (1.2) * Work->fncols_new + 2 ;
 if (!umfzi_grow_front (Numeric, fnr2, fnc2, Work,
     Work->pivrow_in_front ? 2 : 0))
 {
     ;
     return ((0)) ;
 }
    }
    ;
    fnr_curr = Work->fnr_curr ;
    ;
    ;
    ;
    ;
    Frows = Work->Frows ;
    Fcols = Work->Fcols ;
    Frpos = Work->Frpos ;
    Fcpos = Work->Fcpos ;
    Work->fnzeros = 0 ;
    ccdeg = Work->ccdeg ;
    rrdeg = Work->rrdeg ;
    fnrows = Work->fnrows ;
    fncols = Work->fncols ;
    ;
    Fl = Work->Flblock ;
    if (Work->pivcol_in_front)
    {
 Work->fscan_row = fnrows ;
 Work->NewRows = Work->Wrp ;
 Wy = Work->Wy ;
 for (i = 0 ; i < fnrows ; i++)
 {
     Fl [i] = Wy [i] ;
 }
 fnrows_extended = fnrows + ccdeg ;
 for (i = fnrows ; i < fnrows_extended ; i++)
 {
     Fl [i] = Wy [i] ;
     row = Frows [i] ;
     Work->NewRows [i] = (-(row)-2) ;
 }
 fnrows = fnrows_extended ;
    }
    else
    {
 Work->fscan_row = 0 ;
 Work->NewRows = Frows ;
 Wm = Work->Wm ;
 Wx = Work->Wx ;
 for (i = 0 ; i < ccdeg ; i++)
 {
     Fl [i] = Wx [i] ;
     row = Wm [i] ;
     Frows [i] = row ;
     Frpos [row] = i ;
 }
 fnrows = ccdeg ;
    }
    Work->fnrows = fnrows ;
    Wrow = Work->Wrow ;
    if (Work->pivrow_in_front)
    {
 Work->fscan_col = fncols ;
 Work->NewCols = Work->Wp ;
 ;
 if (Wrow == Fcols)
 {
     for (j = fncols ; j < rrdeg ; j++)
     {
  col = Wrow [j] ;
  Work->NewCols [j] = (-(col)-2) ;
  Fcpos [col] = j * fnr_curr ;
     }
 }
 else
 {
     for (j = fncols ; j < rrdeg ; j++)
     {
  col = Wrow [j] ;
  Fcols [j] = col ;
  Work->NewCols [j] = (-(col)-2) ;
  Fcpos [col] = j * fnr_curr ;
     }
 }
    }
    else
    {
 Work->fscan_col = 0 ;
 Work->NewCols = Fcols ;
 for (j = 0 ; j < rrdeg ; j++)
 {
     col = Wrow [j] ;
     Fcols [j] = col ;
     Fcpos [col] = j * fnr_curr ;
 }
    }
    ;
    fncols = rrdeg ;
    Work->fncols = fncols ;
    ;
    ;
    Fcblock = Work->Fcblock ;
    ;
    zero_init_front (fncols, fnrows, Fcblock, fnr_curr) ;
    return ((1)) ;
}

canonical_original_code:
int umfzi_init_front(struct NumericType *Numeric, struct WorkType *Work)
{
    int i; int j; int fnr_curr; int row; int col; int *Frows; int *Fcols; int *Fcpos; int *Frpos; int fncols; int fnrows; int *Wrow; int fnr2; int fnc2; int rrdeg; int ccdeg; int *Wm; int fnrows_extended;
    struct DoubleComplex *Fcblock; struct DoubleComplex *Fl; struct DoubleComplex *Wy; struct DoubleComplex *Wx;
    if (Work->do_grow)
    {
 fnr2 = (1.2) * Work->fnrows_new + 2 ;
 fnc2 = (1.2) * Work->fncols_new + 2 ;
 if (!umfzi_grow_front (Numeric, fnr2, fnc2, Work,
     Work->pivrow_in_front ? 2 : 0))
 {
     ;
     return ((0)) ;
 }
    }
    ;
    fnr_curr = Work->fnr_curr ;
    ;
    ;
    ;
    ;
    Frows = Work->Frows ;
    Fcols = Work->Fcols ;
    Frpos = Work->Frpos ;
    Fcpos = Work->Fcpos ;
    Work->fnzeros = 0 ;
    ccdeg = Work->ccdeg ;
    rrdeg = Work->rrdeg ;
    fnrows = Work->fnrows ;
    fncols = Work->fncols ;
    ;
    Fl = Work->Flblock ;
    if (Work->pivcol_in_front)
    {
 Work->fscan_row = fnrows ;
 Work->NewRows = Work->Wrp ;
 Wy = Work->Wy ;
 for (i = 0 ; i < fnrows ; i++)
 {
     Fl [i] = Wy [i] ;
 }
 fnrows_extended = fnrows + ccdeg ;
 for (i = fnrows ; i < fnrows_extended ; i++)
 {
     Fl [i] = Wy [i] ;
     row = Frows [i] ;
     Work->NewRows [i] = (-(row)-2) ;
 }
 fnrows = fnrows_extended ;
    }
    else
    {
 Work->fscan_row = 0 ;
 Work->NewRows = Frows ;
 Wm = Work->Wm ;
 Wx = Work->Wx ;
 for (i = 0 ; i < ccdeg ; i++)
 {
     Fl [i] = Wx [i] ;
     row = Wm [i] ;
     Frows [i] = row ;
     Frpos [row] = i ;
 }
 fnrows = ccdeg ;
    }
    Work->fnrows = fnrows ;
    Wrow = Work->Wrow ;
    if (Work->pivrow_in_front)
    {
 Work->fscan_col = fncols ;
 Work->NewCols = Work->Wp ;
 ;
 if (Wrow == Fcols)
 {
     for (j = fncols ; j < rrdeg ; j++)
     {
  col = Wrow [j] ;
  Work->NewCols [j] = (-(col)-2) ;
  Fcpos [col] = j * fnr_curr ;
     }
 }
 else
 {
     for (j = fncols ; j < rrdeg ; j++)
     {
  col = Wrow [j] ;
  Fcols [j] = col ;
  Work->NewCols [j] = (-(col)-2) ;
  Fcpos [col] = j * fnr_curr ;
     }
 }
    }
    else
    {
 Work->fscan_col = 0 ;
 Work->NewCols = Fcols ;
 for (j = 0 ; j < rrdeg ; j++)
 {
     col = Wrow [j] ;
     Fcols [j] = col ;
     Fcpos [col] = j * fnr_curr ;
 }
    }
    ;
    fncols = rrdeg ;
    Work->fncols = fncols ;
    ;
    ;
    Fcblock = Work->Fcblock ;
    ;
    zero_init_front (fncols, fnrows, Fcblock, fnr_curr) ;
    return ((1)) ;
}

variable_types: struct NumericType { double flops; int scale; int valid; union Unit_union { struct { int size; } header; double xxxxxx; } *Memory; int ihead; int *Rperm; int ulen; struct DoubleComplex { double component[2]; } *D; int do_recip; double *Rs; int n_row; int tail_usage; int maxnrows; } *

variable_types: struct WorkType { int *E; struct DoubleComplex *Wx; int *Wp; int *Lpattern; int *Diagonal_map; int n_row; int *Front_new1strow; int Pivrow[64]; struct DoubleComplex *Flublock; int *Frows; } *

variable_types: j int

variable_types: row int

variable_types: col int

variable_types:
Frows
int *

variable_types:
Fcols
int *

variable_types:
Fcpos
int *

variable_types:
Frpos
int *

variable_types: fncols int

variable_types: fnrows int

variable_types:
Wrow
int *

variable_types: rrdeg int

variable_types: ccdeg int

variable_types:
Wm
int *

return_type: int

user_defined_types: struct NumericType { double flops; int scale; int valid; union Unit_union *Memory; int ihead; int *Rperm; int ulen; struct DoubleComplex *D; int do_recip; double *Rs; int n_row; int tail_usage; int maxnrows; }


original_code:
static void zero_init_front (int m, int n, DoubleComplex *Fcblock, int d)
{
    int i, j ;
    DoubleComplex *F, *Fj = Fcblock ;
    for (j = 0 ; j < m ; j++)
    {
 F = Fj ;
 Fj += d ;
 for (i = 0 ; i < n ; i++)
 {
     { (*F).component [0] = 0. ; (*F).component [1] = 0. ; } ;
     F++ ;
 }
    }
}

canonical_original_code:
static void zero_init_front(int m, int n, struct DoubleComplex *Fcblock, int d)
{
    int i; int j;
    struct DoubleComplex *F; struct DoubleComplex *Fj = Fcblock;
    for (j = 0 ; j < m ; j++)
    {
 F = Fj ;
 Fj += d ;
 for (i = 0 ; i < n ; i++)
 {
     { (*F).component [0] = 0. ; (*F).component [1] = 0. ; } ;
     F++ ;
 }
    }
}

variable_types: m int

variable_types: n int

variable_types: struct DoubleComplex { double component[2]; } *

variable_types: d int

variable_types: i int

return_type: void


original_code:
int umfzi_extend_front
(
    NumericType *Numeric,
    WorkType *Work
)
{
    int j, i, *Frows, row, col, *Wrow, fnr2, fnc2, *Frpos, *Fcpos, *Fcols,
 fnrows_extended, rrdeg, ccdeg, fncols_extended, fnr_curr, fnc_curr,
 fnrows, fncols, pos, fnpiv, *Wm ;
    DoubleComplex *Wx, *Wy, *Fu, *Fl ;
    fnpiv = Work->fnpiv ;
    if (Work->do_grow)
    {
 fnr2 = (1.2) * Work->fnrows_new + 2 ;
 fnc2 = (1.2) * Work->fncols_new + 2 ;
 if (!umfzi_grow_front (Numeric, fnr2, fnc2, Work, 1))
 {
     ;
     return ((0)) ;
 }
    }
    fnr_curr = Work->fnr_curr ;
    fnc_curr = Work->fnc_curr ;
    ;
    ;
    ;
    Frows = Work->Frows ;
    Frpos = Work->Frpos ;
    Fcols = Work->Fcols ;
    Fcpos = Work->Fcpos ;
    fnrows = Work->fnrows ;
    fncols = Work->fncols ;
    rrdeg = Work->rrdeg ;
    ccdeg = Work->ccdeg ;
    Work->fscan_col = fncols ;
    Work->NewCols = Fcols ;
    Work->fscan_row = fnrows ;
    Work->NewRows = Frows ;
    fnrows_extended = fnrows ;
    fncols_extended = fncols ;
    Fl = Work->Flblock + fnpiv * fnr_curr ;
    if (Work->pivcol_in_front)
    {
 fnrows_extended += ccdeg ;
 Wy = Work->Wy ;
 for (i = 0 ; i < fnrows_extended ; i++)
 {
     Fl [i] = Wy [i] ;
 }
    }
    else
    {
 DoubleComplex *F ;
 Fu = Work->Flublock + fnpiv * Work->nb ;
 Wm = Work->Wm ;
 Wx = Work->Wx ;
 F = Fu ;
 for (i = 0 ; i < fnpiv ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
 F = Fl ;
 for (i = 0 ; i < fnrows ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
 for (i = 0 ; i < ccdeg ; i++)
 {
     row = Wm [i] ;
     pos = Frpos [row] ;
     if (pos < 0)
     {
  pos = fnrows_extended++ ;
  Frows [pos] = row ;
  Frpos [row] = pos ;
     }
     Fl [pos] = Wx [i] ;
 }
    }
    ;
    if (Work->pivrow_in_front)
    {
 if (Work->pivcol_in_front)
 {
     ;
     for (j = fncols ; j < rrdeg ; j++)
     {
  Fcpos [Fcols [j]] = j * fnr_curr ;
     }
 }
 else
 {
     Wrow = Work->Wrow ;
     ;
     if (Wrow == Fcols)
     {
  for (j = fncols ; j < rrdeg ; j++)
  {
      col = Wrow [j] ;
      ;
      ;
      Fcpos [col] = j * fnr_curr ;
  }
     }
     else
     {
  for (j = fncols ; j < rrdeg ; j++)
  {
      col = Wrow [j] ;
      ;
      ;
      Fcols [j] = col ;
      Fcpos [col] = j * fnr_curr ;
  }
     }
 }
 fncols_extended = rrdeg ;
    }
    else
    {
 ;
 Wrow = Work->Wrow ;
 for (j = 0 ; j < rrdeg ; j++)
 {
     col = Wrow [j] ;
     ;
     if (Fcpos [col] < 0)
     {
  ;
  Fcols [fncols_extended] = col ;
  Fcpos [col] = fncols_extended * fnr_curr ;
  fncols_extended++ ;
     }
 }
    }
    zero_front (Work->Flblock, Work->Fublock, Work->Fcblock,
 fnrows, fncols, fnr_curr, fnc_curr,
 fnpiv, fnrows_extended, fncols_extended) ;
    Work->fnrows = fnrows_extended ;
    Work->fncols = fncols_extended ;
    ;
    ;
    return ((1)) ;
}

canonical_original_code:
int umfzi_extend_front(struct NumericType *Numeric, struct WorkType *Work)
{
    int j; int i; int *Frows; int row; int col; int *Wrow; int fnr2; int fnc2; int *Frpos; int *Fcpos; int *Fcols; int fnrows_extended; int rrdeg; int ccdeg; int fncols_extended; int fnr_curr; int fnc_curr; int fnrows; int fncols; int pos; int fnpiv; int *Wm;
    struct DoubleComplex *Wx; struct DoubleComplex *Wy; struct DoubleComplex *Fu; struct DoubleComplex *Fl;
    fnpiv = Work->fnpiv ;
    if (Work->do_grow)
    {
 fnr2 = (1.2) * Work->fnrows_new + 2 ;
 fnc2 = (1.2) * Work->fncols_new + 2 ;
 if (!umfzi_grow_front (Numeric, fnr2, fnc2, Work, 1))
 {
     ;
     return ((0)) ;
 }
    }
    fnr_curr = Work->fnr_curr ;
    fnc_curr = Work->fnc_curr ;
    ;
    ;
    ;
    Frows = Work->Frows ;
    Frpos = Work->Frpos ;
    Fcols = Work->Fcols ;
    Fcpos = Work->Fcpos ;
    fnrows = Work->fnrows ;
    fncols = Work->fncols ;
    rrdeg = Work->rrdeg ;
    ccdeg = Work->ccdeg ;
    Work->fscan_col = fncols ;
    Work->NewCols = Fcols ;
    Work->fscan_row = fnrows ;
    Work->NewRows = Frows ;
    fnrows_extended = fnrows ;
    fncols_extended = fncols ;
    Fl = Work->Flblock + fnpiv * fnr_curr ;
    if (Work->pivcol_in_front)
    {
 fnrows_extended += ccdeg ;
 Wy = Work->Wy ;
 for (i = 0 ; i < fnrows_extended ; i++)
 {
     Fl [i] = Wy [i] ;
 }
    }
    else
    {
 struct DoubleComplex *F;
 Fu = Work->Flublock + fnpiv * Work->nb ;
 Wm = Work->Wm ;
 Wx = Work->Wx ;
 F = Fu ;
 for (i = 0 ; i < fnpiv ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
 F = Fl ;
 for (i = 0 ; i < fnrows ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
 for (i = 0 ; i < ccdeg ; i++)
 {
     row = Wm [i] ;
     pos = Frpos [row] ;
     if (pos < 0)
     {
  pos = fnrows_extended++ ;
  Frows [pos] = row ;
  Frpos [row] = pos ;
     }
     Fl [pos] = Wx [i] ;
 }
    }
    ;
    if (Work->pivrow_in_front)
    {
 if (Work->pivcol_in_front)
 {
     ;
     for (j = fncols ; j < rrdeg ; j++)
     {
  Fcpos [Fcols [j]] = j * fnr_curr ;
     }
 }
 else
 {
     Wrow = Work->Wrow ;
     ;
     if (Wrow == Fcols)
     {
  for (j = fncols ; j < rrdeg ; j++)
  {
      col = Wrow [j] ;
      ;
      ;
      Fcpos [col] = j * fnr_curr ;
  }
     }
     else
     {
  for (j = fncols ; j < rrdeg ; j++)
  {
      col = Wrow [j] ;
      ;
      ;
      Fcols [j] = col ;
      Fcpos [col] = j * fnr_curr ;
  }
     }
 }
 fncols_extended = rrdeg ;
    }
    else
    {
 ;
 Wrow = Work->Wrow ;
 for (j = 0 ; j < rrdeg ; j++)
 {
     col = Wrow [j] ;
     ;
     if (Fcpos [col] < 0)
     {
  ;
  Fcols [fncols_extended] = col ;
  Fcpos [col] = fncols_extended * fnr_curr ;
  fncols_extended++ ;
     }
 }
    }
    zero_front (Work->Flblock, Work->Fublock, Work->Fcblock,
 fnrows, fncols, fnr_curr, fnc_curr,
 fnpiv, fnrows_extended, fncols_extended) ;
    Work->fnrows = fnrows_extended ;
    Work->fncols = fncols_extended ;
    ;
    ;
    return ((1)) ;
}

variable_types: struct NumericType { double flops; int scale; int valid; union Unit_union { struct { int size; } header; double xxxxxx; } *Memory; int ihead; int *Rperm; int ulen; struct DoubleComplex { double component[2]; } *D; int do_recip; double *Rs; int n_row; int tail_usage; int maxnrows; } *

variable_types: struct WorkType { int *E; struct DoubleComplex *Wx; int *Wp; int *Lpattern; int *Diagonal_map; int n_row; int *Front_new1strow; int Pivrow[64]; struct DoubleComplex *Flublock; int *Frows; } *

variable_types: j int

variable_types: row int

variable_types: pos int

variable_types: fnpiv int


original_code:
static void zero_front (
    DoubleComplex *Flblock, DoubleComplex *Fublock, DoubleComplex *Fcblock,
    int fnrows, int fncols, int fnr_curr, int fnc_curr,
    int fnpiv, int fnrows_extended, int fncols_extended)
{
    int j, i ;
    DoubleComplex *F, *Fj, *Fi ;
    Fj = Fcblock + fnrows ;
    for (j = 0 ; j < fncols ; j++)
    {
 F = Fj ;
 Fj += fnr_curr ;
#pragma ivdep
 for (i = fnrows ; i < fnrows_extended ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
    Fj -= fnrows ;
    for (j = fncols ; j < fncols_extended ; j++)
    {
 F = Fj ;
 Fj += fnr_curr ;
#pragma ivdep
 for (i = 0 ; i < fnrows_extended ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
    Fj = Flblock + fnrows ;
    for (j = 0 ; j < fnpiv ; j++)
    {
 F = Fj ;
 Fj += fnr_curr ;
#pragma ivdep
 for (i = fnrows ; i < fnrows_extended ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
    Fi = Fublock + fncols ;
    for (i = 0 ; i < fnpiv ; i++)
    {
 F = Fi ;
 Fi += fnc_curr ;
#pragma ivdep
 for (j = fncols ; j < fncols_extended ; j++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
}

canonical_original_code:
static void zero_front(struct DoubleComplex *Flblock, struct DoubleComplex *Fublock, struct DoubleComplex *Fcblock, int fnrows, int fncols, int fnr_curr, int fnc_curr, int fnpiv, int fnrows_extended, int fncols_extended)
{
    int j; int i;
    struct DoubleComplex *F; struct DoubleComplex *Fj; struct DoubleComplex *Fi;
    Fj = Fcblock + fnrows ;
    for (j = 0 ; j < fncols ; j++)
    {
 F = Fj ;
 Fj += fnr_curr ;
#pragma ivdep
 for (i = fnrows ; i < fnrows_extended ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
    Fj -= fnrows ;
    for (j = fncols ; j < fncols_extended ; j++)
    {
 F = Fj ;
 Fj += fnr_curr ;
#pragma ivdep
 for (i = 0 ; i < fnrows_extended ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
    Fj = Flblock + fnrows ;
    for (j = 0 ; j < fnpiv ; j++)
    {
 F = Fj ;
 Fj += fnr_curr ;
#pragma ivdep
 for (i = fnrows ; i < fnrows_extended ; i++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
    Fi = Fublock + fncols ;
    for (i = 0 ; i < fnpiv ; i++)
    {
 F = Fi ;
 Fi += fnc_curr ;
#pragma ivdep
 for (j = fncols ; j < fncols_extended ; j++)
 {
     { F->component [0] = 0. ; F->component [1] = 0. ; F++ ; } ;
 }
    }
}

variable_types:
Fublock
struct DoubleComplex *

variable_types:
Fcblock
struct DoubleComplex *

variable_types: fncols int

user_defined_types: struct DoubleComplex { double component[2]; }


decompiled_code:
void __fastcall umfpack_zl_report_status(double *a1, __int64 a2)
{
__int64 v2; // rbp

if ( a1 )
{
v2 = (unsigned int)(int)*a1;
if ( !(int)*a1 )
return;
}
else
{
v2 = 1LL;
}
if ( a2 || v2 > 1 )
{
if ( amd_printf )
{
amd_printf("\n");
if ( v2 > 3 )
{
if ( amd_printf )
amd_printf("%s\n");
}
}
if ( v2 > 5 )
{
if ( !amd_printf )
goto LABEL_26;
amd_printf("%s");
if ( !amd_printf )
goto LABEL_26;
amd_printf("%s");
if ( !amd_printf )
goto LABEL_26;
amd_printf("%s");
}
if ( amd_printf )
{
amd_printf("UMFPACK V%d.%d.%d (%s): ", 5LL, 6LL, 1LL, "Jun 20, 2012");
if ( a2 == -911 )
{
if ( !amd_printf )
return;
amd_printf(
"INTERNAL ERROR!\n"
"Input arguments might be corrupted or aliased, or an internal\n"
"error has occurred. Check your input arguments with the\n"
"umfpack_*_report_* routines before calling the umfpack_*\n"
"computational routines. Recompile UMFPACK with debugging\n"
"enabled, and look for failed assertions. If all else fails\n"
"please report this error to Tim Davis\n"
"(DrTimothyAldenDavis@gmail.com).\n");
LABEL_19:
if ( amd_printf )
amd_printf("\n");
return;
}
LABEL_24:
if ( !amd_printf )
return;
amd_printf("ERROR: Unrecognized error code: %ld\n", a2);
goto LABEL_19;
}
LABEL_26:
if ( a2 == -911 )
return;
goto LABEL_24;
}
}

canonical_decompiled_code:
void __fastcall func0(double *a1, __int64 a2)
{
__int64 v2; // rbp

if ( a1 )
{
v2 = (unsigned int)(int)*a1;
if ( !(int)*a1 )
return;
}
else
{
v2 = 1LL;
}
if ( a2 || v2 > 1 )
{
if ( amd_printf )
{
amd_printf("\n");
if ( v2 > 3 )
{
if ( amd_printf )
amd_printf("%s\n");
}
}
if ( v2 > 5 )
{
if ( !amd_printf )
goto LABEL_26;
amd_printf("%s");
if ( !amd_printf )
goto LABEL_26;
amd_printf("%s");
if ( !amd_printf )
goto LABEL_26;
amd_printf("%s");
}
if ( amd_printf )
{
amd_printf("UMFPACK V%d.%d.%d (%s): ", 5LL, 6LL, 1LL, "Jun 20, 2012");
if ( a2 == -911 )
{
if ( !amd_printf )
return;
amd_printf(
"INTERNAL ERROR!\n"
"Input arguments might be corrupted or aliased, or an internal\n"
"error has occurred. Check your input arguments with the\n"
"umfpack_*_report_* routines before calling the umfpack_*\n"
"computational routines. Recompile UMFPACK with debugging\n"
"enabled, and look for failed assertions. If all else fails\n"
"please report this error to Tim Davis\n"
"(DrTimothyAldenDavis@gmail.com).\n");
LABEL_19:
if ( amd_printf )
amd_printf("\n");
return;
}
LABEL_24:
if ( !amd_printf )
return;
amd_printf("ERROR: Unrecognized error code: %ld\n", a2);
goto LABEL_19;
}
LABEL_26:
if ( a2 == -911 )
return;
goto LABEL_24;
}
}

original_code:
void umfpack_zl_report_status
(
    const double Control [20],
    long status
)
{
    long prl ;
    prl = ((Control != (double *) ((void *)0)) ? (((Control [0]) != (Control [0])) ? 1 : Control [0]) : 1) ;
    if (prl < 1)
    {
 return ;
    }
    if (status == (0) && prl <= 1)
    {
 return ;
    }
    { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ;
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s\n", "UMFPACK:  Copyright (c) 2005-2012 by Timothy A. Davis.  All Rights Reserved.\n") ; } ; } } ;
    { if (prl >= (6)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s", "\nUMFPACK License:\n" "\n" "   UMFPACK is available under alternate licenses,\n" "   contact T. Davis for details.\n" "\n" "   Your use or distribution of UMFPACK or any modified version of\n" "   UMFPACK implies that you agree to this License.\n" "\n" "   This library is free software; you can redistribute it and/or\n" "   modify it under the terms of the GNU General Public\n" "   License as published by the Free Software Foundation; either\n" "   version 2 of the License, or (at your option) any later version.\n" "\n" "   This library is distributed in the hope that it will be useful,\n" "   but WITHOUT ANY WARRANTY; without even the implied warranty of\n" "   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n" "   General Public License for more details.\n" "\n" "   You should have received a copy of the GNU General Public\n" "   License along with this library; if not, write to the Free Software\n" "   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301\n" "   USA\n") ; } ; } } ;
    { if (prl >= (6)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s", "\n" "   Permission is hereby granted to use or copy this program under the\n" "   terms of the GNU GPL, provided that the Copyright, this License,\n" "   and the Availability of the original version is retained on all copies.\n" "   User documentation of any code that uses this code or any modified\n" "   version of this code must cite the Copyright, this License, the\n" "   Availability note, and \"Used by permission.\" Permission to modify\n" "   the code and to distribute modified code is granted, provided the\n" "   Copyright, this License, and the Availability note are retained,\n" "   and a notice that the code was modified is included.\n") ; } ; } } ;
    { if (prl >= (6)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s", "\n" "Availability: http://www.suitesparse.com" "\n") ; } ; } } ;
    { if (amd_printf != ((void *)0)) (void) amd_printf ("UMFPACK V%d.%d.%d (%s): ", 5, 6, 1, "Jun 20, 2012") ; } ;
    switch (status)
    {
 case (0):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("OK\n") ; } ;
     break ;
 case (1):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("WARNING: matrix is singular\n") ; } ;
     break ;
 case (-1):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: out of memory\n") ; } ;
     break ;
 case (-3):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: Numeric object is invalid\n") ; } ;
     break ;
 case (-4):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: Symbolic object is invalid\n") ; } ;
     break ;
 case (-5):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: required argument(s) missing\n") ; } ;
     break ;
 case (-6):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: dimension (n_row or n_col) must be > 0\n") ; } ;
     break ;
 case (-8):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: input matrix is invalid\n") ; } ;
     break ;
 case (-13):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: system argument invalid\n") ; } ;
     break ;
 case (-15):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: invalid permutation\n") ; } ;
     break ;
 case (-11):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: pattern of matrix (Ap and/or Ai) has changed\n") ; } ;
     break ;
        case (-18):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: ordering failed\n") ; } ;
     break ;
 case (-911):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("INTERNAL ERROR!\n" "Input arguments might be corrupted or aliased, or an internal\n" "error has occurred.  Check your input arguments with the\n" "umfpack_*_report_* routines before calling the umfpack_*\n" "computational routines.  Recompile UMFPACK with debugging\n" "enabled, and look for failed assertions.  If all else fails\n" "please report this error to Tim Davis\n" "(DrTimothyAldenDavis@gmail.com).\n" ) ; } ;
     break ;
 default:
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: Unrecognized error code: ""%" "ld""\n", status) ; } ;
    }
    { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ;
}

canonical_original_code:
void umfpack_zl_report_status(double Control[20], long status)
{
    long prl;
    prl = ((Control != (double *) ((void *)0)) ? (((Control [0]) != (Control [0])) ? 1 : Control [0]) : 1) ;
    if (prl < 1)
    {
 return ;
    }
    if (status == (0) && prl <= 1)
    {
 return ;
    }
    { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ;
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s\n", "UMFPACK:  Copyright (c) 2005-2012 by Timothy A. Davis.  All Rights Reserved.\n") ; } ; } } ;
    { if (prl >= (6)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s", "\nUMFPACK License:\n" "\n" "   UMFPACK is available under alternate licenses,\n" "   contact T. Davis for details.\n" "\n" "   Your use or distribution of UMFPACK or any modified version of\n" "   UMFPACK implies that you agree to this License.\n" "\n" "   This library is free software; you can redistribute it and/or\n" "   modify it under the terms of the GNU General Public\n" "   License as published by the Free Software Foundation; either\n" "   version 2 of the License, or (at your option) any later version.\n" "\n" "   This library is distributed in the hope that it will be useful,\n" "   but WITHOUT ANY WARRANTY; without even the implied warranty of\n" "   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n" "   General Public License for more details.\n" "\n" "   You should have received a copy of the GNU General Public\n" "   License along with this library; if not, write to the Free Software\n" "   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301\n" "   USA\n") ; } ; } } ;
    { if (prl >= (6)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s", "\n" "   Permission is hereby granted to use or copy this program under the\n" "   terms of the GNU GPL, provided that the Copyright, this License,\n" "   and the Availability of the original version is retained on all copies.\n" "   User documentation of any code that uses this code or any modified\n" "   version of this code must cite the Copyright, this License, the\n" "   Availability note, and \"Used by permission.\" Permission to modify\n" "   the code and to distribute modified code is granted, provided the\n" "   Copyright, this License, and the Availability note are retained,\n" "   and a notice that the code was modified is included.\n") ; } ; } } ;
    { if (prl >= (6)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("%s", "\n" "Availability: http://www.suitesparse.com" "\n") ; } ; } } ;
    { if (amd_printf != ((void *)0)) (void) amd_printf ("UMFPACK V%d.%d.%d (%s): ", 5, 6, 1, "Jun 20, 2012") ; } ;
    switch (status)
    {
 case (0):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("OK\n") ; } ;
     break ;
 case (1):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("WARNING: matrix is singular\n") ; } ;
     break ;
 case (-1):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: out of memory\n") ; } ;
     break ;
 case (-3):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: Numeric object is invalid\n") ; } ;
     break ;
 case (-4):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: Symbolic object is invalid\n") ; } ;
     break ;
 case (-5):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: required argument(s) missing\n") ; } ;
     break ;
 case (-6):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: dimension (n_row or n_col) must be > 0\n") ; } ;
     break ;
 case (-8):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: input matrix is invalid\n") ; } ;
     break ;
 case (-13):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: system argument invalid\n") ; } ;
     break ;
 case (-15):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: invalid permutation\n") ; } ;
     break ;
 case (-11):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: pattern of matrix (Ap and/or Ai) has changed\n") ; } ;
     break ;
        case (-18):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: ordering failed\n") ; } ;
     break ;
 case (-911):
     { if (amd_printf != ((void *)0)) (void) amd_printf ("INTERNAL ERROR!\n" "Input arguments might be corrupted or aliased, or an internal\n" "error has occurred.  Check your input arguments with the\n" "umfpack_*_report_* routines before calling the umfpack_*\n" "computational routines.  Recompile UMFPACK with debugging\n" "enabled, and look for failed assertions.  If all else fails\n" "please report this error to Tim Davis\n" "(DrTimothyAldenDavis@gmail.com).\n" ) ; } ;
     break ;
 default:
     { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: Unrecognized error code: ""%" "ld""\n", status) ; } ;
    }
    { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ;
}

variable_types:
Control
double [20]

variable_types: status long

variable_types: prl long


original_code:
long umfpack_dl_get_lunz
(
    long *lnz,
    long *unz,
    long *n_row,
    long *n_col,
    long *nz_udiag,
    void *NumericHandle
)
{
    NumericType *Numeric ;
    Numeric = (NumericType *) NumericHandle ;
    if (!umfdl_valid_numeric (Numeric))
    {
 return ((-3)) ;
    }
    if (!lnz || !unz || !n_row || !n_col || !nz_udiag)
    {
 return ((-5)) ;
    }
    *n_row = Numeric->n_row ;
    *n_col = Numeric->n_col ;
    *lnz = Numeric->lnz + (((Numeric->n_row) < (Numeric->n_col)) ? (Numeric->n_row) : (Numeric->n_col)) ;
    *unz = Numeric->unz + Numeric->nnzpiv ;
    *nz_udiag = Numeric->nnzpiv ;
    return ((0)) ;
}

canonical_original_code:
long umfpack_dl_get_lunz(long *lnz, long *unz, long *n_row, long *n_col, long *nz_udiag, void *NumericHandle)
{
    struct NumericType *Numeric;
    Numeric = (struct NumericType *) NumericHandle ;
    if (!umfdl_valid_numeric (Numeric))
    {
 return ((-3)) ;
    }
    if (!lnz || !unz || !n_row || !n_col || !nz_udiag)
    {
 return ((-5)) ;
    }
    *n_row = Numeric->n_row ;
    *n_col = Numeric->n_col ;
    *lnz = Numeric->lnz + (((Numeric->n_row) < (Numeric->n_col)) ? (Numeric->n_row) : (Numeric->n_col)) ;
    *unz = Numeric->unz + Numeric->nnzpiv ;
    *nz_udiag = Numeric->nnzpiv ;
    return ((0)) ;
}

variable_types:
lnz
long *

variable_types:
unz
long *

variable_types:
NumericHandle
void *

variable_types: struct NumericType { double flops; long scale; long valid; union Unit_union { struct { long size; } header; double xxxxxx; } *Memory; long ihead; long *Rperm; long ulen; double *D; long do_recip; double *Rs; long n_row; long tail_usage; long maxnrows; } *

user_defined_types: struct NumericType { double flops; long scale; long valid; union Unit_union *Memory; long ihead; long *Rperm; long ulen; double *D; long do_recip; double *Rs; long n_row; long tail_usage; long maxnrows; }


original_code:
long umfzl_grow_front
(
    NumericType *Numeric,
    long fnr2,
    long fnc2,
    WorkType *Work,
    long do_what
)
{
    double s ;
    DoubleComplex *Fcold, *Fcnew ;
    long j, i, col, *Fcpos, *Fcols, fnrows_max, fncols_max, fnr_curr, nb,
 fnrows_new, fncols_new, fnr_min, fnc_min, minsize,
 newsize, fnrows, fncols, *E, eloc ;
    Fcols = Work->Fcols ;
    Fcpos = Work->Fcpos ;
    E = Work->E ;
    nb = Work->nb ;
    fnrows_max = Work->fnrows_max + nb ;
    fncols_max = Work->fncols_max + nb ;
    ;
    ;
    ;
    ;
    ;
    fnrows_new = Work->fnrows_new + 1 ;
    fncols_new = Work->fncols_new + 1 ;
    ;
    if (fnrows_new % 2 == 0) fnrows_new++ ;
    fnrows_new += nb ;
    fncols_new += nb ;
    fnr_min = (((fnrows_new) < (fnrows_max)) ? (fnrows_new) : (fnrows_max)) ;
    fnc_min = (((fncols_new) < (fncols_max)) ? (fncols_new) : (fncols_max)) ;
    minsize = fnr_min * fnc_min ;
    if (((!(((double) fnr_min * (double) fnc_min * sizeof (DoubleComplex)) * (1.0+1e-8) <= (double) 0x7fffffffffffffffL)) || (((double) fnr_min * (double) fnc_min * sizeof (DoubleComplex)) != ((double) fnr_min * (double) fnc_min * sizeof (DoubleComplex)))))
    {
 return ((0)) ;
    }
    ;
    ;
    ;
    ;
    fnr2 += nb ;
    fnc2 += nb ;
    ;
    if (fnr2 % 2 == 0) fnr2++ ;
    fnr2 = (((fnr2) > (fnr_min)) ? (fnr2) : (fnr_min)) ;
    fnc2 = (((fnc2) > (fnc_min)) ? (fnc2) : (fnc_min)) ;
    fnr2 = (((fnr2) < (fnrows_max)) ? (fnr2) : (fnrows_max)) ;
    fnc2 = (((fnc2) < (fncols_max)) ? (fnc2) : (fncols_max)) ;
    ;
    ;
    ;
    s = ((double) fnr2) * ((double) fnc2) ;
    if (((!((s * sizeof (DoubleComplex)) * (1.0+1e-8) <= (double) 0x7fffffffffffffffL)) || ((s * sizeof (DoubleComplex)) != (s * sizeof (DoubleComplex)))))
    {
 double a = 0.9 * sqrt ((0x7fffffffffffffffL / sizeof (DoubleComplex)) / s) ;
 fnr2 = (((fnr_min) > (a * fnr2)) ? (fnr_min) : (a * fnr2)) ;
 fnc2 = (((fnc_min) > (a * fnc2)) ? (fnc_min) : (a * fnc2)) ;
 newsize = fnr2 * fnc2 ;
 ;
 if (fnr2 % 2 == 0) fnr2++ ;
 fnc2 = newsize / fnr2 ;
    }
    fnr2 = (((fnr2) > (fnr_min)) ? (fnr2) : (fnr_min)) ;
    fnc2 = (((fnc2) > (fnc_min)) ? (fnc2) : (fnc_min)) ;
    newsize = fnr2 * fnc2 ;
    ;
    ;
    ;
    ;
    ;
    if (E [0] && do_what != 1)
    {
 ;
 umfzl_mem_free_tail_block (Numeric, E [0]) ;
 E [0] = 0 ;
 Work->Flublock = (DoubleComplex *) ((void *)0) ;
 Work->Flblock = (DoubleComplex *) ((void *)0) ;
 Work->Fublock = (DoubleComplex *) ((void *)0) ;
 Work->Fcblock = (DoubleComplex *) ((void *)0) ;
    }
    ;
    eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    if (!eloc)
    {
 ;
 if (!umfzl_get_memory (Numeric, Work, 1 + (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit)))),
     Work->fnrows, Work->fncols, (0)))
 {
     return ((0)) ;
 }
 ;
 eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    }
    while ((fnr2 != fnr_min || fnc2 != fnc_min) && !eloc)
    {
 fnr2 = (((fnr2 - 2) < (fnr2 * (0.95))) ? (fnr2 - 2) : (fnr2 * (0.95))) ;
 fnc2 = (((fnc2 - 2) < (fnc2 * (0.95))) ? (fnc2 - 2) : (fnc2 * (0.95))) ;
 ;
 ;
 fnr2 = (((fnr_min) > (fnr2)) ? (fnr_min) : (fnr2)) ;
 fnc2 = (((fnc_min) > (fnc2)) ? (fnc_min) : (fnc2)) ;
 ;
 if (fnr2 % 2 == 0) fnr2++ ;
 newsize = fnr2 * fnc2 ;
 ;
 eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    }
    if (!eloc)
    {
 fnr2 = fnr_min ;
 fnc2 = fnc_min ;
 newsize = minsize ;
 ;
 eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    }
    if (!eloc)
    {
 return ((0)) ;
    }
    ;
    ;
    ;
    fnr_curr = Work->fnr_curr ;
    ;
    ;
    fnrows = Work->fnrows ;
    fncols = Work->fncols ;
    Fcold = Work->Fcblock ;
    fnr2 -= nb ;
    fnc2 -= nb ;
    Work->Flublock = (DoubleComplex *) (Numeric->Memory + eloc) ;
    Work->Flblock = Work->Flublock + nb * nb ;
    Work->Fublock = Work->Flblock + nb * fnr2 ;
    Work->Fcblock = Work->Fublock + nb * fnc2 ;
    Fcnew = Work->Fcblock ;
    if (E [0])
    {
 for (j = 0 ; j < fncols ; j++)
 {
     col = Fcols [j] ;
     ;
     ;
     for (i = 0 ; i < fnrows ; i++)
     {
  Fcnew [i] = Fcold [i] ;
     }
     Fcnew += fnr2 ;
     Fcold += fnr_curr ;
     ;
     Fcpos [col] = j * fnr2 ;
 }
    }
    else if (do_what == 2)
    {
 for (j = 0 ; j < fncols ; j++)
 {
     col = Fcols [j] ;
     ;
     Fcpos [col] = j * fnr2 ;
 }
    }
    umfzl_mem_free_tail_block (Numeric, E [0]) ;
    E [0] = eloc ;
    Work->fnr_curr = fnr2 ;
    Work->fnc_curr = fnc2 ;
    Work->fcurr_size = newsize ;
    Work->do_grow = (0) ;
    ;
    ;
    ;
    return ((1)) ;
}

canonical_original_code:
long umfzl_grow_front(struct NumericType *Numeric, long fnr2, long fnc2, struct WorkType *Work, long do_what)
{
    double s;
    struct DoubleComplex *Fcold; struct DoubleComplex *Fcnew;
    long j; long i; long col; long *Fcpos; long *Fcols; long fnrows_max; long fncols_max; long fnr_curr; long nb; long fnrows_new; long fncols_new; long fnr_min; long fnc_min; long minsize; long newsize; long fnrows; long fncols; long *E; long eloc;
    Fcols = Work->Fcols ;
    Fcpos = Work->Fcpos ;
    E = Work->E ;
    nb = Work->nb ;
    fnrows_max = Work->fnrows_max + nb ;
    fncols_max = Work->fncols_max + nb ;
    ;
    ;
    ;
    ;
    ;
    fnrows_new = Work->fnrows_new + 1 ;
    fncols_new = Work->fncols_new + 1 ;
    ;
    if (fnrows_new % 2 == 0) fnrows_new++ ;
    fnrows_new += nb ;
    fncols_new += nb ;
    fnr_min = (((fnrows_new) < (fnrows_max)) ? (fnrows_new) : (fnrows_max)) ;
    fnc_min = (((fncols_new) < (fncols_max)) ? (fncols_new) : (fncols_max)) ;
    minsize = fnr_min * fnc_min ;
    if (((!(((double) fnr_min * (double) fnc_min * sizeof (DoubleComplex)) * (1.0+1e-8) <= (double) 0x7fffffffffffffffL)) || (((double) fnr_min * (double) fnc_min * sizeof (DoubleComplex)) != ((double) fnr_min * (double) fnc_min * sizeof (DoubleComplex)))))
    {
 return ((0)) ;
    }
    ;
    ;
    ;
    ;
    fnr2 += nb ;
    fnc2 += nb ;
    ;
    if (fnr2 % 2 == 0) fnr2++ ;
    fnr2 = (((fnr2) > (fnr_min)) ? (fnr2) : (fnr_min)) ;
    fnc2 = (((fnc2) > (fnc_min)) ? (fnc2) : (fnc_min)) ;
    fnr2 = (((fnr2) < (fnrows_max)) ? (fnr2) : (fnrows_max)) ;
    fnc2 = (((fnc2) < (fncols_max)) ? (fnc2) : (fncols_max)) ;
    ;
    ;
    ;
    s = ((double) fnr2) * ((double) fnc2) ;
    if (((!((s * sizeof (DoubleComplex)) * (1.0+1e-8) <= (double) 0x7fffffffffffffffL)) || ((s * sizeof (DoubleComplex)) != (s * sizeof (DoubleComplex)))))
    {
 double a = 0.9 * sqrt ((0x7fffffffffffffffL / sizeof (DoubleComplex)) / s);
 fnr2 = (((fnr_min) > (a * fnr2)) ? (fnr_min) : (a * fnr2)) ;
 fnc2 = (((fnc_min) > (a * fnc2)) ? (fnc_min) : (a * fnc2)) ;
 newsize = fnr2 * fnc2 ;
 ;
 if (fnr2 % 2 == 0) fnr2++ ;
 fnc2 = newsize / fnr2 ;
    }
    fnr2 = (((fnr2) > (fnr_min)) ? (fnr2) : (fnr_min)) ;
    fnc2 = (((fnc2) > (fnc_min)) ? (fnc2) : (fnc_min)) ;
    newsize = fnr2 * fnc2 ;
    ;
    ;
    ;
    ;
    ;
    if (E [0] && do_what != 1)
    {
 ;
 umfzl_mem_free_tail_block (Numeric, E [0]) ;
 E [0] = 0 ;
 Work->Flublock = (struct DoubleComplex *) ((void *)0) ;
 Work->Flblock = (struct DoubleComplex *) ((void *)0) ;
 Work->Fublock = (struct DoubleComplex *) ((void *)0) ;
 Work->Fcblock = (struct DoubleComplex *) ((void *)0) ;
    }
    ;
    eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    if (!eloc)
    {
 ;
 if (!umfzl_get_memory (Numeric, Work, 1 + (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit)))),
     Work->fnrows, Work->fncols, (0)))
 {
     return ((0)) ;
 }
 ;
 eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    }
    while ((fnr2 != fnr_min || fnc2 != fnc_min) && !eloc)
    {
 fnr2 = (((fnr2 - 2) < (fnr2 * (0.95))) ? (fnr2 - 2) : (fnr2 * (0.95))) ;
 fnc2 = (((fnc2 - 2) < (fnc2 * (0.95))) ? (fnc2 - 2) : (fnc2 * (0.95))) ;
 ;
 ;
 fnr2 = (((fnr_min) > (fnr2)) ? (fnr_min) : (fnr2)) ;
 fnc2 = (((fnc_min) > (fnc2)) ? (fnc_min) : (fnc2)) ;
 ;
 if (fnr2 % 2 == 0) fnr2++ ;
 newsize = fnr2 * fnc2 ;
 ;
 eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    }
    if (!eloc)
    {
 fnr2 = fnr_min ;
 fnc2 = fnc_min ;
 newsize = minsize ;
 ;
 eloc = umfzl_mem_alloc_tail_block (Numeric, (((((sizeof (DoubleComplex) * (newsize))) + (sizeof (Unit)) - 1) / (sizeof (Unit))))) ;
    }
    if (!eloc)
    {
 return ((0)) ;
    }
    ;
    ;
    ;
    fnr_curr = Work->fnr_curr ;
    ;
    ;
    fnrows = Work->fnrows ;
    fncols = Work->fncols ;
    Fcold = Work->Fcblock ;
    fnr2 -= nb ;
    fnc2 -= nb ;
    Work->Flublock = (struct DoubleComplex *) (Numeric->Memory + eloc) ;
    Work->Flblock = Work->Flublock + nb * nb ;
    Work->Fublock = Work->Flblock + nb * fnr2 ;
    Work->Fcblock = Work->Fublock + nb * fnc2 ;
    Fcnew = Work->Fcblock ;
    if (E [0])
    {
 for (j = 0 ; j < fncols ; j++)
 {
     col = Fcols [j] ;
     ;
     ;
     for (i = 0 ; i < fnrows ; i++)
     {
  Fcnew [i] = Fcold [i] ;
     }
     Fcnew += fnr2 ;
     Fcold += fnr_curr ;
     ;
     Fcpos [col] = j * fnr2 ;
 }
    }
    else if (do_what == 2)
    {
 for (j = 0 ; j < fncols ; j++)
 {
     col = Fcols [j] ;
     ;
     Fcpos [col] = j * fnr2 ;
 }
    }
    umfzl_mem_free_tail_block (Numeric, E [0]) ;
    E [0] = eloc ;
    Work->fnr_curr = fnr2 ;
    Work->fnc_curr = fnc2 ;
    Work->fcurr_size = newsize ;
    Work->do_grow = (0) ;
    ;
    ;
    ;
    return ((1)) ;
}

variable_types: struct NumericType { double flops; long scale; long valid; union Unit_union { struct { long size; } header; double xxxxxx; } *Memory; long ihead; long *Rperm; long ulen; struct DoubleComplex { double component[2]; } *D; long do_recip; double *Rs; long n_row; long tail_usage; long maxnrows; } *

variable_types: struct WorkType { long *E; struct DoubleComplex *Wx; long *Wp; long *Lpattern; long *Diagonal_map; long n_row; long *Front_new1strow; long Pivrow[64]; struct DoubleComplex *Flublock; long *Frows; } *

variable_types: s double

variable_types: j long

variable_types: i long

variable_types: col long

variable_types:
Fcpos
long *

variable_types:
Fcols
long *

variable_types: nb long

variable_types: minsize long

variable_types: newsize long

variable_types: fnrows long

variable_types: fncols long

variable_types:
E
long *

variable_types: eloc long

variable_types: a double

user_defined_types: struct NumericType { double flops; long scale; long valid; union Unit_union *Memory; long ihead; long *Rperm; long ulen; struct DoubleComplex *D; long do_recip; double *Rs; long n_row; long tail_usage; long maxnrows; }


original_code:
int umfzi_start_front
(
    int chain,
    NumericType *Numeric,
    WorkType *Work,
    SymbolicType *Symbolic
)
{
    double maxbytes ;
    int fnrows_max, fncols_max, fnr2, fnc2, fsize, fcurr_size, maxfrsize,
 overflow, nb, f, cdeg ;
    nb = Symbolic->nb ;
    fnrows_max = Symbolic->Chain_maxrows [chain] ;
    fncols_max = Symbolic->Chain_maxcols [chain] ;
    ;
    Work->fnrows_max = fnrows_max ;
    Work->fncols_max = fncols_max ;
    Work->any_skip = (0) ;
    maxbytes = sizeof (DoubleComplex) *
 (double) (fnrows_max + nb) * (double) (fncols_max + nb) ;
    fcurr_size = Work->fcurr_size ;
    if (Symbolic->prefer_diagonal)
    {
 int col, tpi, e, *E, *Col_tuples, *Col_tlen, *Cols ;
 Tuple *tp, *tpend ;
 Unit *Memory, *p ;
 Element *ep ;
 E = Work->E ;
 Memory = Numeric->Memory ;
 Col_tuples = Numeric->Lip ;
 Col_tlen = Numeric->Lilen ;
 col = Work->nextcand ;
 tpi = Col_tuples [col] ;
 tp = (Tuple *) Memory + tpi ;
 tpend = tp + Col_tlen [col] ;
 cdeg = 0 ;
 ;
 for ( ; tp < tpend ; tp++)
 {
     ;
     e = tp->e ;
     if (!E [e]) continue ;
     f = tp->f ;
     p = Memory + E [e] ;
     ep = (Element *) p ;
     p += (((((sizeof (Element) * (1))) + (sizeof (Unit)) - 1) / (sizeof (Unit)))) ;
     Cols = (int *) p ;
     if (Cols [f] == (-1)) continue ;
     ;
     cdeg += ep->nrowsleft ;
 }
 if (Symbolic->amd_dmax > 0)
 {
     cdeg = (((cdeg) < (Symbolic->amd_dmax)) ? (cdeg) : (Symbolic->amd_dmax)) ;
 }
 cdeg += 2 ;
 cdeg = (((cdeg) < (fnrows_max)) ? (cdeg) : (fnrows_max)) ;
    }
    else
    {
 cdeg = 0 ;
    }
    ;
    ;
    ;
    ;
    overflow = ((!((maxbytes) * (1.0+1e-8) <= (double) 0x7fffffff)) || ((maxbytes) != (maxbytes))) ;
    if (overflow)
    {
 maxfrsize = 0x7fffffff / sizeof (DoubleComplex) ;
    }
    else
    {
 maxfrsize = (fnrows_max + nb) * (fncols_max + nb) ;
    }
    ;
    if (Numeric->front_alloc_init < 0)
    {
 fsize = -Numeric->front_alloc_init ;
 fsize = (((1) > (fsize)) ? (1) : (fsize)) ;
    }
    else
    {
 if (((!((Numeric->front_alloc_init * maxbytes) * (1.0+1e-8) <= (double) 0x7fffffff)) || ((Numeric->front_alloc_init * maxbytes) != (Numeric->front_alloc_init * maxbytes))))
 {
     fsize = 0x7fffffff / sizeof (DoubleComplex) ;
 }
 else
 {
     fsize = Numeric->front_alloc_init * maxfrsize ;
 }
 if (cdeg > 0)
 {
     int fsize2 ;
     cdeg += nb ;
     if (((!((((double) cdeg * (double) cdeg) * sizeof (DoubleComplex)) * (1.0+1e-8) <= (double) 0x7fffffff)) || ((((double) cdeg * (double) cdeg) * sizeof (DoubleComplex)) != (((double) cdeg * (double) cdeg) * sizeof (DoubleComplex)))))
     {
  fsize2 = 0x7fffffff / sizeof (DoubleComplex) ;
     }
     else
     {
  fsize2 = (((cdeg * cdeg) > (fcurr_size)) ? (cdeg * cdeg) : (fcurr_size)) ;
     }
     fsize = (((fsize) < (fsize2)) ? (fsize) : (fsize2)) ;
 }
    }
    fsize = (((fsize) > (2*nb*nb)) ? (fsize) : (2*nb*nb)) ;
    ;
    Work->fnrows_new = 0 ;
    Work->fncols_new = 0 ;
    ;
    ;
    if (fsize >= maxfrsize && !overflow)
    {
 fnr2 = fnrows_max + nb ;
 fnc2 = fncols_max + nb ;
 fsize = maxfrsize ;
 ;
    }
    else
    {
 if (fnrows_max <= fncols_max)
 {
     fnr2 = (int) sqrt ((double) fsize) ;
     fnr2 = (((fnr2) > (1)) ? (fnr2) : (1)) ;
     if (fnr2 % 2 == 0) fnr2++ ;
     fnr2 = (((fnr2) < (fnrows_max + nb)) ? (fnr2) : (fnrows_max + nb)) ;
     fnc2 = fsize / fnr2 ;
 }
 else
 {
     fnc2 = (int) sqrt ((double) fsize) ;
     fnc2 = (((fnc2) < (fncols_max + nb)) ? (fnc2) : (fncols_max + nb)) ;
     fnr2 = fsize / fnc2 ;
     fnr2 = (((fnr2) > (1)) ? (fnr2) : (1)) ;
     if (fnr2 % 2 == 0)
     {
  fnr2++ ;
  fnc2 = fsize / fnr2 ;
     }
 }
 ;
    }
    fnr2 = (((fnr2) < (fnrows_max + nb)) ? (fnr2) : (fnrows_max + nb)) ;
    fnc2 = (((fnc2) < (fncols_max + nb)) ? (fnc2) : (fncols_max + nb)) ;
    ;
    ;
    fnr2 -= nb ;
    fnc2 -= nb ;
    ;
    ;
    if (fsize > fcurr_size)
    {
 ;
 Work->do_grow = (1) ;
 if (!umfzi_grow_front (Numeric, fnr2, fnc2, Work, -1))
 {
     ;
     return ((0)) ;
 }
    }
    else
    {
 ;
 Work->fnr_curr = fnr2 ;
 Work->fnc_curr = fnc2 ;
 Work->Flblock = Work->Flublock + nb * nb ;
 Work->Fublock = Work->Flblock + nb * fnr2 ;
 Work->Fcblock = Work->Fublock + nb * fnc2 ;
    }
    ;
    ;
    ;
    return ((1)) ;
}

canonical_original_code:
int umfzi_start_front(int chain, struct NumericType *Numeric, struct WorkType *Work, struct SymbolicType *Symbolic)
{
    double maxbytes;
    int fnrows_max; int fncols_max; int fnr2; int fnc2; int fsize; int fcurr_size; int maxfrsize; int overflow; int nb; int f; int cdeg;
    nb = Symbolic->nb ;
    fnrows_max = Symbolic->Chain_maxrows [chain] ;
    fncols_max = Symbolic->Chain_maxcols [chain] ;
    ;
    Work->fnrows_max = fnrows_max ;
    Work->fncols_max = fncols_max ;
    Work->any_skip = (0) ;
    maxbytes = sizeof (DoubleComplex) *
 (double) (fnrows_max + nb) * (double) (fncols_max + nb) ;
    fcurr_size = Work->fcurr_size ;
    if (Symbolic->prefer_diagonal)
    {
 int col; int tpi; int e; int *E; int *Col_tuples; int *Col_tlen; int *Cols;
 struct Tuple *tp; struct Tuple *tpend;
 union Unit_union *Memory; union Unit_union *p;
 struct Element *ep;
 E = Work->E ;
 Memory = Numeric->Memory ;
 Col_tuples = Numeric->Lip ;
 Col_tlen = Numeric->Lilen ;
 col = Work->nextcand ;
 tpi = Col_tuples [col] ;
 tp = (struct Tuple *) Memory + tpi ;
 tpend = tp + Col_tlen [col] ;
 cdeg = 0 ;
 ;
 for ( ; tp < tpend ; tp++)
 {
     ;
     e = tp->e ;
     if (!E [e]) continue ;
     f = tp->f ;
     p = Memory + E [e] ;
     ep = (struct Element *) p ;
     p += (((((sizeof (Element) * (1))) + (sizeof (Unit)) - 1) / (sizeof (Unit)))) ;
     Cols = (int *) p ;
     if (Cols [f] == (-1)) continue ;
     ;
     cdeg += ep->nrowsleft ;
 }
 if (Symbolic->amd_dmax > 0)
 {
     cdeg = (((cdeg) < (Symbolic->amd_dmax)) ? (cdeg) : (Symbolic->amd_dmax)) ;
 }
 cdeg += 2 ;
 cdeg = (((cdeg) < (fnrows_max)) ? (cdeg) : (fnrows_max)) ;
    }
    else
    {
 cdeg = 0 ;
    }
    ;
    ;
    ;
    ;
    overflow = ((!((maxbytes) * (1.0+1e-8) <= (double) 0x7fffffff)) || ((maxbytes) != (maxbytes))) ;
    if (overflow)
    {
 maxfrsize = 0x7fffffff / sizeof (DoubleComplex) ;
    }
    else
    {
 maxfrsize = (fnrows_max + nb) * (fncols_max + nb) ;
    }
    ;
    if (Numeric->front_alloc_init < 0)
    {
 fsize = -Numeric->front_alloc_init ;
 fsize = (((1) > (fsize)) ? (1) : (fsize)) ;
    }
    else
    {
 if (((!((Numeric->front_alloc_init * maxbytes) * (1.0+1e-8) <= (double) 0x7fffffff)) || ((Numeric->front_alloc_init * maxbytes) != (Numeric->front_alloc_init * maxbytes))))
 {
     fsize = 0x7fffffff / sizeof (DoubleComplex) ;
 }
 else
 {
     fsize = Numeric->front_alloc_init * maxfrsize ;
 }
 if (cdeg > 0)
 {
     int fsize2;
     cdeg += nb ;
     if (((!((((double) cdeg * (double) cdeg) * sizeof (DoubleComplex)) * (1.0+1e-8) <= (double) 0x7fffffff)) || ((((double) cdeg * (double) cdeg) * sizeof (DoubleComplex)) != (((double) cdeg * (double) cdeg) * sizeof (DoubleComplex)))))
     {
  fsize2 = 0x7fffffff / sizeof (DoubleComplex) ;
     }
     else
     {
  fsize2 = (((cdeg * cdeg) > (fcurr_size)) ? (cdeg * cdeg) : (fcurr_size)) ;
     }
     fsize = (((fsize) < (fsize2)) ? (fsize) : (fsize2)) ;
 }
    }
    fsize = (((fsize) > (2*nb*nb)) ? (fsize) : (2*nb*nb)) ;
    ;
    Work->fnrows_new = 0 ;
    Work->fncols_new = 0 ;
    ;
    ;
    if (fsize >= maxfrsize && !overflow)
    {
 fnr2 = fnrows_max + nb ;
 fnc2 = fncols_max + nb ;
 fsize = maxfrsize ;
 ;
    }
    else
    {
 if (fnrows_max <= fncols_max)
 {
     fnr2 = (int) sqrt ((double) fsize) ;
     fnr2 = (((fnr2) > (1)) ? (fnr2) : (1)) ;
     if (fnr2 % 2 == 0) fnr2++ ;
     fnr2 = (((fnr2) < (fnrows_max + nb)) ? (fnr2) : (fnrows_max + nb)) ;
     fnc2 = fsize / fnr2 ;
 }
 else
 {
     fnc2 = (int) sqrt ((double) fsize) ;
     fnc2 = (((fnc2) < (fncols_max + nb)) ? (fnc2) : (fncols_max + nb)) ;
     fnr2 = fsize / fnc2 ;
     fnr2 = (((fnr2) > (1)) ? (fnr2) : (1)) ;
     if (fnr2 % 2 == 0)
     {
  fnr2++ ;
  fnc2 = fsize / fnr2 ;
     }
 }
 ;
    }
    fnr2 = (((fnr2) < (fnrows_max + nb)) ? (fnr2) : (fnrows_max + nb)) ;
    fnc2 = (((fnc2) < (fncols_max + nb)) ? (fnc2) : (fncols_max + nb)) ;
    ;
    ;
    fnr2 -= nb ;
    fnc2 -= nb ;
    ;
    ;
    if (fsize > fcurr_size)
    {
 ;
 Work->do_grow = (1) ;
 if (!umfzi_grow_front (Numeric, fnr2, fnc2, Work, -1))
 {
     ;
     return ((0)) ;
 }
    }
    else
    {
 ;
 Work->fnr_curr = fnr2 ;
 Work->fnc_curr = fnc2 ;
 Work->Flblock = Work->Flublock + nb * nb ;
 Work->Fublock = Work->Flblock + nb * fnr2 ;
 Work->Fcblock = Work->Fublock + nb * fnc2 ;
    }
    ;
    ;
    ;
    return ((1)) ;
}

variable_types: chain int

variable_types: struct NumericType { double flops; int scale; int valid; union Unit_union { struct { int size; } header; double xxxxxx; } *Memory; int ihead; int *Rperm; int ulen; struct DoubleComplex { double component[2]; } *D; int do_recip; double *Rs; int n_row; int tail_usage; int maxnrows; } *

variable_types: struct WorkType { int *E; struct DoubleComplex *Wx; int *Wp; int *Lpattern; int *Diagonal_map; int n_row; int *Front_new1strow; int Pivrow[64]; struct DoubleComplex *Flublock; int *Frows; } *

variable_types: struct SymbolicType { double num_mem_usage_est; int valid; } *

variable_types: maxbytes double

variable_types: fsize int

variable_types: maxfrsize int

variable_types: overflow int

variable_types: nb int

variable_types: f int

variable_types: cdeg int

variable_types: col int

variable_types: tpi int

variable_types: e int

variable_types:
E
int *

variable_types:
Cols
int *

variable_types:
tp
struct Tuple { int e; } *

variable_types:
tpend
struct Tuple { int e; } *

variable_types:
ep
struct Element { int cdeg; } *


original_code:
long umfdl_triplet_map_x
(
    long n_row,
    long n_col,
    long nz,
    const long Ti [ ],
    const long Tj [ ],
    long Ap [ ],
    long Ai [ ],
    long Rp [ ],
    long Rj [ ],
    long W [ ],
    long RowCount [ ]
    , const double Tx [ ]
    , double Ax [ ]
    , double Rx [ ]
    , long Map [ ]
    , long Map2 [ ]
)
{
    long i, j, k, p, cp, p1, p2, pdest, pj ;
    long duplicates ;
    for (i = 0 ; i < n_row ; i++)
    {
 W [i] = 0 ;
    }
    for (k = 0 ; k < nz ; k++)
    {
 i = Ti [k] ;
 j = Tj [k] ;
 if (i < 0 || i >= n_row || j < 0 || j >= n_col)
 {
     return ((-8)) ;
 }
 W [i]++ ;
    }
    Rp [0] = 0 ;
    for (i = 0 ; i < n_row ; i++)
    {
 Rp [i+1] = Rp [i] + W [i] ;
 W [i] = Rp [i] ;
    }
    for (k = 0 ; k < nz ; k++)
    {
 p = W [Ti [k]]++ ;
 Map [k] = p ;
 Rj [p] = Tj [k] ;
 Rx [p] = Tx [k] ;
    }
    for (j = 0 ; j < n_col ; j++)
    {
 W [j] = (-1) ;
    }
    duplicates = (0) ;
    for (i = 0 ; i < n_row ; i++)
    {
 p1 = Rp [i] ;
 p2 = Rp [i+1] ;
 pdest = p1 ;
 for (p = p1 ; p < p2 ; p++)
 {
     j = Rj [p] ;
     ;
     pj = W [j] ;
     if (pj >= p1)
     {
  ;
  ;
  Map2 [p] = pj ;
  duplicates = (1) ;
  Rx [pj] += Rx [p] ;
     }
     else
     {
  W [j] = pdest ;
  Map2 [p] = pdest ;
  if (pdest != p)
  {
      Rj [pdest] = j ;
      Rx [pdest] = Rx [p] ;
  }
  pdest++ ;
     }
 }
 RowCount [i] = pdest - p1 ;
    }
    if (duplicates)
    {
 for (k = 0 ; k < nz ; k++)
 {
     Map [k] = Map2 [Map [k]] ;
 }
    }
    for (j = 0 ; j < n_col ; j++)
    {
 W [j] = 0 ;
    }
    for (i = 0 ; i < n_row ; i++)
    {
 for (p = Rp [i] ; p < Rp [i] + RowCount [i] ; p++)
 {
     j = Rj [p] ;
     ;
     W [j]++ ;
 }
    }
    Ap [0] = 0 ;
    for (j = 0 ; j < n_col ; j++)
    {
 Ap [j+1] = Ap [j] + W [j] ;
    }
    for (j = 0 ; j < n_col ; j++)
    {
 W [j] = Ap [j] ;
    }
    for (i = 0 ; i < n_row ; i++)
    {
 for (p = Rp [i] ; p < Rp [i] + RowCount [i] ; p++)
 {
     cp = W [Rj [p]]++ ;
     Map2 [p] = cp ;
     Ai [cp] = i ;
     Ax [cp] = Rx [p] ;
 }
    }
    for (k = 0 ; k < nz ; k++)
    {
 Map [k] = Map2 [Map [k]] ;
    }
    return ((0)) ;
}

canonical_original_code:
long umfdl_triplet_map_x(long n_row, long n_col, long nz, long Ti[], long Tj[], long Ap[], long Ai[], long Rp[], long Rj[], long W[], long RowCount[], double Tx[], double Ax[], double Rx[], long Map[], long Map2[])
{
    long i; long j; long k; long p; long cp; long p1; long p2; long pdest; long pj;
    long duplicates;
    for (i = 0 ; i < n_row ; i++)
    {
 W [i] = 0 ;
    }
    for (k = 0 ; k < nz ; k++)
    {
 i = Ti [k] ;
 j = Tj [k] ;
 if (i < 0 || i >= n_row || j < 0 || j >= n_col)
 {
     return ((-8)) ;
 }
 W [i]++ ;
    }
    Rp [0] = 0 ;
    for (i = 0 ; i < n_row ; i++)
    {
 Rp [i+1] = Rp [i] + W [i] ;
 W [i] = Rp [i] ;
    }
    for (k = 0 ; k < nz ; k++)
    {
 p = W [Ti [k]]++ ;
 Map [k] = p ;
 Rj [p] = Tj [k] ;
 Rx [p] = Tx [k] ;
    }
    for (j = 0 ; j < n_col ; j++)
    {
 W [j] = (-1) ;
    }
    duplicates = (0) ;
    for (i = 0 ; i < n_row ; i++)
    {
 p1 = Rp [i] ;
 p2 = Rp [i+1] ;
 pdest = p1 ;
 for (p = p1 ; p < p2 ; p++)
 {
     j = Rj [p] ;
     ;
     pj = W [j] ;
     if (pj >= p1)
     {
  ;
  ;
  Map2 [p] = pj ;
  duplicates = (1) ;
  Rx [pj] += Rx [p] ;
     }
     else
     {
  W [j] = pdest ;
  Map2 [p] = pdest ;
  if (pdest != p)
  {
      Rj [pdest] = j ;
      Rx [pdest] = Rx [p] ;
  }
  pdest++ ;
     }
 }
 RowCount [i] = pdest - p1 ;
    }
    if (duplicates)
    {
 for (k = 0 ; k < nz ; k++)
 {
     Map [k] = Map2 [Map [k]] ;
 }
    }
    for (j = 0 ; j < n_col ; j++)
    {
 W [j] = 0 ;
    }
    for (i = 0 ; i < n_row ; i++)
    {
 for (p = Rp [i] ; p < Rp [i] + RowCount [i] ; p++)
 {
     j = Rj [p] ;
     ;
     W [j]++ ;
 }
    }
    Ap [0] = 0 ;
    for (j = 0 ; j < n_col ; j++)
    {
 Ap [j+1] = Ap [j] + W [j] ;
    }
    for (j = 0 ; j < n_col ; j++)
    {
 W [j] = Ap [j] ;
    }
    for (i = 0 ; i < n_row ; i++)
    {
 for (p = Rp [i] ; p < Rp [i] + RowCount [i] ; p++)
 {
     cp = W [Rj [p]]++ ;
     Map2 [p] = cp ;
     Ai [cp] = i ;
     Ax [cp] = Rx [p] ;
 }
    }
    for (k = 0 ; k < nz ; k++)
    {
 Map [k] = Map2 [Map [k]] ;
    }
    return ((0)) ;
}

variable_types: nz long

variable_types:
Ti
long []

variable_types:
Tj
long []

variable_types:
Ap
long []

variable_types:
Ai
long []

variable_types:
Rp
long []

variable_types:
Rj
long []

variable_types:
W
long []

variable_types:
RowCount
long []

variable_types:
Tx
double []

variable_types:
Ax
double []

variable_types:
Rx
double []

variable_types:
Map
long []

variable_types: i long

variable_types: j long

variable_types: k long

variable_types: p long

variable_types: cp long

variable_types: pdest long

variable_types: pj long

variable_types: duplicates long


decompiled_code:
__int64 __fastcall umfpack_di_report_symbolic(__int64 a1, double *a2)
{
int v2; // er15
__int64 result; // rax
int v4; // ebx
__int64 v5; // r14
__int64 v6; // r13
unsigned int v7; // er12
unsigned int v8; // ebp
int v9; // eax
int v10; // eax
unsigned int v11; // ebp
__int64 v12; // rdi
__int64 v13; // rbp
int v14; // er12
unsigned int v15; // ebx
__int64 (*v16)(const char *, ...); // rcx
int v17; // ebx
__int64 v18; // rdi
__int64 v19; // rax
int v20; // ebx
int v21; // er12
__int64 v22; // rbx
int v23; // eax
unsigned int v24; // er12
__int64 v25; // rsi
__int64 v26; // [rsp+8h] [rbp-90h]
__int64 v27; // [rsp+10h] [rbp-88h]
__int64 v28; // [rsp+18h] [rbp-80h]
unsigned int v29; // [rsp+20h] [rbp-78h]
int v30; // [rsp+20h] [rbp-78h]
int v31; // [rsp+24h] [rbp-74h]
__int64 v32; // [rsp+28h] [rbp-70h]
_DWORD *v34; // [rsp+38h] [rbp-60h]
__int64 v35; // [rsp+40h] [rbp-58h]
__int64 v36; // [rsp+48h] [rbp-50h]
__int64 v37; // [rsp+50h] [rbp-48h]
unsigned int v38; // [rsp+58h] [rbp-40h]
unsigned int v39; // [rsp+5Ch] [rbp-3Ch]

if ( !a2 )
return 0LL;
v2 = (int)*a2;
result = 0LL;
if ( v2 <= 2 )
return result;
if ( amd_printf )
amd_printf("Symbolic object: ");
if ( !(unsigned int)umfdi_valid_symbolic(a1) )
{
result = 4294967292LL;
if ( amd_printf )
{
amd_printf("ERROR: invalid\n");
result = 4294967292LL;
}
return result;
}
v38 = *(_DWORD *)(a1 + 208);
v39 = *(_DWORD *)(a1 + 212);
v4 = *(_DWORD *)(a1 + 64);
v31 = *(_DWORD *)(a1 + 204);
v32 = *(_QWORD *)(a1 + 72);
v36 = *(_QWORD *)(a1 + 80);
v37 = *(_QWORD *)(a1 + 88);
v26 = *(_QWORD *)(a1 + 104);
v5 = *(_QWORD *)(a1 + 112);
v6 = *(_QWORD *)(a1 + 120);
v27 = *(_QWORD *)(a1 + 128);
if ( v2 <= 3 )
goto LABEL_61;
v7 = *(_DWORD *)(a1 + 96);
v8 = *(_DWORD *)(a1 + 100);
if ( amd_printf )
{
v29 = *(_DWORD *)(a1 + 216);
amd_printf("\n matrix to be factorized:\n");
if ( amd_printf )
{
amd_printf("\tn_row: %d n_col: %d\n", v38, v39);
if ( amd_printf )
{
amd_printf("\tnumber of entries: %d\n", v29);
if ( amd_printf )
{
amd_printf(" block size used for dense matrix kernels: %d\n", *(unsigned int *)(a1 + 220));
if ( amd_printf )
amd_printf(" strategy used: ");
}
}
}
}
if ( *(_DWORD *)(a1 + 236) == 3 )
{
if ( amd_printf && (amd_printf("symmetric\n"), amd_printf) )
{
amd_printf(" ordering used: ");
v10 = *(_DWORD *)(a1 + 240);
if ( v10 == 1 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("amd on A\n");
goto LABEL_40;
}
}
else
{
v10 = *(_DWORD *)(a1 + 240);
if ( v10 == 1 )
goto LABEL_43;
}
if ( v10 != 2 )
{
if ( v10 != 6 )
{
if ( v10 == 3 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("metis on A");
}
goto LABEL_40;
}
if ( !amd_printf )
goto LABEL_43;
LABEL_37:
amd_printf("user function");
goto LABEL_40;
}
if ( !amd_printf )
goto LABEL_43;
}
else
{
if ( amd_printf && (amd_printf("unsymmetric\n"), amd_printf) )
{
amd_printf(" ordering used: ");
v9 = *(_DWORD *)(a1 + 240);
if ( v9 == 1 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("colamd on A\n");
goto LABEL_40;
}
}
else
{
v9 = *(_DWORD *)(a1 + 240);
if ( v9 == 1 )
goto LABEL_43;
}
if ( v9 != 2 )
{
if ( v9 != 6 )
{
if ( v9 == 3 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("metis on A'A");
}
goto LABEL_40;
}
if ( !amd_printf )
goto LABEL_43;
goto LABEL_37;
}
if ( !amd_printf )
goto LABEL_43;
}
amd_printf("user permutation");
LABEL_40:
if ( amd_printf )
{
amd_printf("\n");
if ( amd_printf )
amd_printf(" performn column etree postorder: ");
}
LABEL_43:
if ( *(_DWORD *)(a1 + 244) )
{
if ( !amd_printf )
goto LABEL_129;
amd_printf("no\n");
}
else
{
if ( !amd_printf )
{
LABEL_129:
if ( *(_DWORD *)(a1 + 248) )
goto LABEL_61;
goto LABEL_130;
}
amd_printf("yes\n");
}
if ( !amd_printf )
goto LABEL_129;
amd_printf(" prefer diagonal pivoting (attempt P=Q): ");
if ( *(_DWORD *)(a1 + 248) )
{
if ( amd_printf )
{
amd_printf("yes\n");
LABEL_50:
if ( amd_printf )
{
amd_printf(" variable-size part of Numeric object:\n");
if ( amd_printf )
{
amd_printf(
"\tminimum initial size (Units): %.20g (MBytes): %.1f\n",
*(double *)(a1 + 32),
*(double *)(a1 + 32) * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(
"\testimated peak size (Units): %.20g (MBytes): %.1f\n",
*(double *)a1,
*(double *)a1 * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(
"\testimated final size (Units): %.20g (MBytes): %.1f\n",
*(double *)(a1 + 8),
*(double *)(a1 + 8) * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(
" symbolic factorization memory usage (Units): %.20g (MBytes): %.1f\n",
*(double *)(a1 + 16),
*(double *)(a1 + 16) * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(" frontal matrices / supercolumns:\n");
if ( amd_printf )
{
amd_printf("\tnumber of frontal chains: %d\n", (unsigned int)v4);
if ( amd_printf )
{
amd_printf("\tnumber of frontal matrices: %d\n", (unsigned int)v31);
if ( amd_printf )
{
amd_printf("\tlargest frontal matrix row dimension: %d\n", v7);
if ( amd_printf )
amd_printf("\tlargest frontal matrix column dimension: %d\n", v8);
}
}
}
}
}
}
}
}
}
goto LABEL_61;
}
goto LABEL_61;
}
LABEL_130:
if ( amd_printf )
{
amd_printf("no\n");
goto LABEL_50;
}
LABEL_61:
if ( v4 > 0 )
{
v34 = (_DWORD *)(v26 + 4LL * v31);
v35 = (unsigned int)v4;
v28 = 0LL;
v11 = 0;
while ( 1 )
{
LODWORD(v22) = *(_DWORD *)(v32 + 4 * v28);
v23 = *(_DWORD *)(v32 + 4 * v28 + 4);
v30 = v23 - 1;
if ( v2 > 3 )
{
if ( amd_printf )
{
amd_printf(
"\n Frontal chain: %d. Frontal matrices %d to %d\n",
(unsigned int)v28,
(unsigned int)v22,
(unsigned int)(v23 - 1));
if ( amd_printf )
amd_printf(
"\tLargest frontal matrix in Frontal chain: %d-by-%d\n",
*(unsigned int *)(v36 + 4 * v28),
*(unsigned int *)(v37 + 4 * v28));
}
}
if ( (int)v22 <= v30 )
break;
if ( v2 > 3 && *v34 )
{
LABEL_87:
v16 = amd_printf;
v17 = 0;
if ( amd_printf )
{
LABEL_88:
v16("\tFront: %d placeholder for %d empty columns\n", (unsigned int)v31);
if ( v17 )
goto LABEL_89;
}
}
LABEL_106:
if ( v35 == ++v28 )
goto LABEL_89;
}
v22 = (int)v22;
while ( 1 )
{
v24 = *(_DWORD *)(v26 + 4 * v22);
if ( v2 <= 3 )
{
if ( *(_DWORD *)(v27 + 4 * v22) == -1 )
goto LABEL_115;
goto LABEL_114;
}
if ( !amd_printf )
break;
amd_printf("\tFront: %d pivot cols: %d (pivot columns %d to %d)\n", (unsigned int)v22, v24, v11, v24 + v11 - 1);
if ( !amd_printf )
break;
amd_printf(
"\t pivot row candidates: %d to %d\n",
*(unsigned int *)(v5 + 4LL * *(int *)(v6 + 4 * v22)),
(unsigned int)(*(_DWORD *)(v5 + 4 * v22 + 4) - 1));
if ( !amd_printf )
break;
amd_printf("\t leftmost descendant: %d\n", *(unsigned int *)(v6 + 4 * v22));
if ( !amd_printf )
break;
amd_printf("\t 1st new candidate row : %d\n", *(unsigned int *)(v5 + 4 * v22));
if ( !amd_printf )
break;
amd_printf("\t parent:");
v25 = *(unsigned int *)(v27 + 4 * v22);
if ( (_DWORD)v25 != -1 )
goto LABEL_123;
if ( amd_printf )
amd_printf(" (none)\n");
LABEL_114:
if ( (_DWORD)v22 == 20 && v2 == 4 && v31 > 21 )
{
if ( !amd_printf )
goto LABEL_89;
amd_printf("\t...\n");
if ( *v34 )
{
v16 = amd_printf;
if ( !amd_printf )
goto LABEL_89;
v17 = 1;
goto LABEL_88;
}
v12 = v39;
if ( (int)v38 >= (int)v39 )
v12 = v38;
v13 = umf_i_malloc(v12, 4LL);
if ( !v13 )
goto LABEL_97;
LABEL_78:
if ( amd_printf )
amd_printf("\nInitial column permutation, Q1: ");
v14 = umf_i_report_perm(v39, *(_QWORD *)(a1 + 136), v13, (unsigned int)v2, 0LL);
if ( amd_printf )
amd_printf("\nInitial row permutation, P1: ");
v15 = umf_i_report_perm(v38, *(_QWORD *)(a1 + 144), v13, (unsigned int)v2, 0LL);
umf_i_free(v13);
result = v14 | v15;
if ( v14 | v15 )
return 4294967292LL;
if ( amd_printf )
{
amd_printf(" Symbolic object: ");
goto LABEL_94;
}
return result;
}
LABEL_115:
v11 += v24;
if ( v30 < (int)++v22 )
{
if ( v2 > 3 && *v34 )
goto LABEL_87;
goto LABEL_106;
}
}
v25 = *(unsigned int *)(v27 + 4 * v22);
if ( (_DWORD)v25 == -1 )
goto LABEL_114;
LABEL_123:
if ( amd_printf )
amd_printf(" %d\n", v25);
goto LABEL_114;
}
LABEL_89:
v18 = v39;
if ( (int)v38 >= (int)v39 )
v18 = v38;
v19 = umf_i_malloc(v18, 4LL);
v13 = v19;
if ( v19 )
{
if ( v2 > 3 )
goto LABEL_78;
v20 = umf_i_report_perm(v39, *(_QWORD *)(a1 + 136), v19, 3LL, 0LL);
v21 = umf_i_report_perm(v38, *(_QWORD *)(a1 + 144), v13, 3LL, 0LL);
umf_i_free(v13);
if ( v20 | v21 )
{
result = 4294967292LL;
}
else
{
LABEL_94:
if ( amd_printf )
amd_printf("OK\n\n");
result = 0LL;
}
}
else
{
LABEL_97:
result = 0xFFFFFFFFLL;
if ( amd_printf )
{
amd_printf("ERROR: out of memory to check Symbolic object\n\n");
result = 0xFFFFFFFFLL;
}
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1, double *a2)
{
int v2; // er15
__int64 result; // rax
int v4; // ebx
__int64 v5; // r14
__int64 v6; // r13
unsigned int v7; // er12
unsigned int v8; // ebp
int v9; // eax
int v10; // eax
unsigned int v11; // ebp
__int64 v12; // rdi
__int64 v13; // rbp
int v14; // er12
unsigned int v15; // ebx
__int64 (*v16)(const char *, ...); // rcx
int v17; // ebx
__int64 v18; // rdi
__int64 v19; // rax
int v20; // ebx
int v21; // er12
__int64 v22; // rbx
int v23; // eax
unsigned int v24; // er12
__int64 v25; // rsi
__int64 v26; // [rsp+8h] [rbp-90h]
__int64 v27; // [rsp+10h] [rbp-88h]
__int64 v28; // [rsp+18h] [rbp-80h]
unsigned int v29; // [rsp+20h] [rbp-78h]
int v30; // [rsp+20h] [rbp-78h]
int v31; // [rsp+24h] [rbp-74h]
__int64 v32; // [rsp+28h] [rbp-70h]
_DWORD *v34; // [rsp+38h] [rbp-60h]
__int64 v35; // [rsp+40h] [rbp-58h]
__int64 v36; // [rsp+48h] [rbp-50h]
__int64 v37; // [rsp+50h] [rbp-48h]
unsigned int v38; // [rsp+58h] [rbp-40h]
unsigned int v39; // [rsp+5Ch] [rbp-3Ch]

if ( !a2 )
return 0LL;
v2 = (int)*a2;
result = 0LL;
if ( v2 <= 2 )
return result;
if ( amd_printf )
amd_printf("Symbolic object: ");
if ( !(unsigned int)umfdi_valid_symbolic(a1) )
{
result = 4294967292LL;
if ( amd_printf )
{
amd_printf("ERROR: invalid\n");
result = 4294967292LL;
}
return result;
}
v38 = *(_DWORD *)(a1 + 208);
v39 = *(_DWORD *)(a1 + 212);
v4 = *(_DWORD *)(a1 + 64);
v31 = *(_DWORD *)(a1 + 204);
v32 = *(_QWORD *)(a1 + 72);
v36 = *(_QWORD *)(a1 + 80);
v37 = *(_QWORD *)(a1 + 88);
v26 = *(_QWORD *)(a1 + 104);
v5 = *(_QWORD *)(a1 + 112);
v6 = *(_QWORD *)(a1 + 120);
v27 = *(_QWORD *)(a1 + 128);
if ( v2 <= 3 )
goto LABEL_61;
v7 = *(_DWORD *)(a1 + 96);
v8 = *(_DWORD *)(a1 + 100);
if ( amd_printf )
{
v29 = *(_DWORD *)(a1 + 216);
amd_printf("\n matrix to be factorized:\n");
if ( amd_printf )
{
amd_printf("\tn_row: %d n_col: %d\n", v38, v39);
if ( amd_printf )
{
amd_printf("\tnumber of entries: %d\n", v29);
if ( amd_printf )
{
amd_printf(" block size used for dense matrix kernels: %d\n", *(unsigned int *)(a1 + 220));
if ( amd_printf )
amd_printf(" strategy used: ");
}
}
}
}
if ( *(_DWORD *)(a1 + 236) == 3 )
{
if ( amd_printf && (amd_printf("symmetric\n"), amd_printf) )
{
amd_printf(" ordering used: ");
v10 = *(_DWORD *)(a1 + 240);
if ( v10 == 1 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("amd on A\n");
goto LABEL_40;
}
}
else
{
v10 = *(_DWORD *)(a1 + 240);
if ( v10 == 1 )
goto LABEL_43;
}
if ( v10 != 2 )
{
if ( v10 != 6 )
{
if ( v10 == 3 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("metis on A");
}
goto LABEL_40;
}
if ( !amd_printf )
goto LABEL_43;
LABEL_37:
amd_printf("user function");
goto LABEL_40;
}
if ( !amd_printf )
goto LABEL_43;
}
else
{
if ( amd_printf && (amd_printf("unsymmetric\n"), amd_printf) )
{
amd_printf(" ordering used: ");
v9 = *(_DWORD *)(a1 + 240);
if ( v9 == 1 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("colamd on A\n");
goto LABEL_40;
}
}
else
{
v9 = *(_DWORD *)(a1 + 240);
if ( v9 == 1 )
goto LABEL_43;
}
if ( v9 != 2 )
{
if ( v9 != 6 )
{
if ( v9 == 3 )
{
if ( !amd_printf )
goto LABEL_43;
amd_printf("metis on A'A");
}
goto LABEL_40;
}
if ( !amd_printf )
goto LABEL_43;
goto LABEL_37;
}
if ( !amd_printf )
goto LABEL_43;
}
amd_printf("user permutation");
LABEL_40:
if ( amd_printf )
{
amd_printf("\n");
if ( amd_printf )
amd_printf(" performn column etree postorder: ");
}
LABEL_43:
if ( *(_DWORD *)(a1 + 244) )
{
if ( !amd_printf )
goto LABEL_129;
amd_printf("no\n");
}
else
{
if ( !amd_printf )
{
LABEL_129:
if ( *(_DWORD *)(a1 + 248) )
goto LABEL_61;
goto LABEL_130;
}
amd_printf("yes\n");
}
if ( !amd_printf )
goto LABEL_129;
amd_printf(" prefer diagonal pivoting (attempt P=Q): ");
if ( *(_DWORD *)(a1 + 248) )
{
if ( amd_printf )
{
amd_printf("yes\n");
LABEL_50:
if ( amd_printf )
{
amd_printf(" variable-size part of Numeric object:\n");
if ( amd_printf )
{
amd_printf(
"\tminimum initial size (Units): %.20g (MBytes): %.1f\n",
*(double *)(a1 + 32),
*(double *)(a1 + 32) * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(
"\testimated peak size (Units): %.20g (MBytes): %.1f\n",
*(double *)a1,
*(double *)a1 * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(
"\testimated final size (Units): %.20g (MBytes): %.1f\n",
*(double *)(a1 + 8),
*(double *)(a1 + 8) * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(
" symbolic factorization memory usage (Units): %.20g (MBytes): %.1f\n",
*(double *)(a1 + 16),
*(double *)(a1 + 16) * 8.0 * 0.00000095367431640625);
if ( amd_printf )
{
amd_printf(" frontal matrices / supercolumns:\n");
if ( amd_printf )
{
amd_printf("\tnumber of frontal chains: %d\n", (unsigned int)v4);
if ( amd_printf )
{
amd_printf("\tnumber of frontal matrices: %d\n", (unsigned int)v31);
if ( amd_printf )
{
amd_printf("\tlargest frontal matrix row dimension: %d\n", v7);
if ( amd_printf )
amd_printf("\tlargest frontal matrix column dimension: %d\n", v8);
}
}
}
}
}
}
}
}
}
goto LABEL_61;
}
goto LABEL_61;
}
LABEL_130:
if ( amd_printf )
{
amd_printf("no\n");
goto LABEL_50;
}
LABEL_61:
if ( v4 > 0 )
{
v34 = (_DWORD *)(v26 + 4LL * v31);
v35 = (unsigned int)v4;
v28 = 0LL;
v11 = 0;
while ( 1 )
{
LODWORD(v22) = *(_DWORD *)(v32 + 4 * v28);
v23 = *(_DWORD *)(v32 + 4 * v28 + 4);
v30 = v23 - 1;
if ( v2 > 3 )
{
if ( amd_printf )
{
amd_printf(
"\n Frontal chain: %d. Frontal matrices %d to %d\n",
(unsigned int)v28,
(unsigned int)v22,
(unsigned int)(v23 - 1));
if ( amd_printf )
amd_printf(
"\tLargest frontal matrix in Frontal chain: %d-by-%d\n",
*(unsigned int *)(v36 + 4 * v28),
*(unsigned int *)(v37 + 4 * v28));
}
}
if ( (int)v22 <= v30 )
break;
if ( v2 > 3 && *v34 )
{
LABEL_87:
v16 = amd_printf;
v17 = 0;
if ( amd_printf )
{
LABEL_88:
v16("\tFront: %d placeholder for %d empty columns\n", (unsigned int)v31);
if ( v17 )
goto LABEL_89;
}
}
LABEL_106:
if ( v35 == ++v28 )
goto LABEL_89;
}
v22 = (int)v22;
while ( 1 )
{
v24 = *(_DWORD *)(v26 + 4 * v22);
if ( v2 <= 3 )
{
if ( *(_DWORD *)(v27 + 4 * v22) == -1 )
goto LABEL_115;
goto LABEL_114;
}
if ( !amd_printf )
break;
amd_printf("\tFront: %d pivot cols: %d (pivot columns %d to %d)\n", (unsigned int)v22, v24, v11, v24 + v11 - 1);
if ( !amd_printf )
break;
amd_printf(
"\t pivot row candidates: %d to %d\n",
*(unsigned int *)(v5 + 4LL * *(int *)(v6 + 4 * v22)),
(unsigned int)(*(_DWORD *)(v5 + 4 * v22 + 4) - 1));
if ( !amd_printf )
break;
amd_printf("\t leftmost descendant: %d\n", *(unsigned int *)(v6 + 4 * v22));
if ( !amd_printf )
break;
amd_printf("\t 1st new candidate row : %d\n", *(unsigned int *)(v5 + 4 * v22));
if ( !amd_printf )
break;
amd_printf("\t parent:");
v25 = *(unsigned int *)(v27 + 4 * v22);
if ( (_DWORD)v25 != -1 )
goto LABEL_123;
if ( amd_printf )
amd_printf(" (none)\n");
LABEL_114:
if ( (_DWORD)v22 == 20 && v2 == 4 && v31 > 21 )
{
if ( !amd_printf )
goto LABEL_89;
amd_printf("\t...\n");
if ( *v34 )
{
v16 = amd_printf;
if ( !amd_printf )
goto LABEL_89;
v17 = 1;
goto LABEL_88;
}
v12 = v39;
if ( (int)v38 >= (int)v39 )
v12 = v38;
v13 = umf_i_malloc(v12, 4LL);
if ( !v13 )
goto LABEL_97;
LABEL_78:
if ( amd_printf )
amd_printf("\nInitial column permutation, Q1: ");
v14 = umf_i_report_perm(v39, *(_QWORD *)(a1 + 136), v13, (unsigned int)v2, 0LL);
if ( amd_printf )
amd_printf("\nInitial row permutation, P1: ");
v15 = umf_i_report_perm(v38, *(_QWORD *)(a1 + 144), v13, (unsigned int)v2, 0LL);
umf_i_free(v13);
result = v14 | v15;
if ( v14 | v15 )
return 4294967292LL;
if ( amd_printf )
{
amd_printf(" Symbolic object: ");
goto LABEL_94;
}
return result;
}
LABEL_115:
v11 += v24;
if ( v30 < (int)++v22 )
{
if ( v2 > 3 && *v34 )
goto LABEL_87;
goto LABEL_106;
}
}
v25 = *(unsigned int *)(v27 + 4 * v22);
if ( (_DWORD)v25 == -1 )
goto LABEL_114;
LABEL_123:
if ( amd_printf )
amd_printf(" %d\n", v25);
goto LABEL_114;
}
LABEL_89:
v18 = v39;
if ( (int)v38 >= (int)v39 )
v18 = v38;
v19 = umf_i_malloc(v18, 4LL);
v13 = v19;
if ( v19 )
{
if ( v2 > 3 )
goto LABEL_78;
v20 = umf_i_report_perm(v39, *(_QWORD *)(a1 + 136), v19, 3LL, 0LL);
v21 = umf_i_report_perm(v38, *(_QWORD *)(a1 + 144), v13, 3LL, 0LL);
umf_i_free(v13);
if ( v20 | v21 )
{
result = 4294967292LL;
}
else
{
LABEL_94:
if ( amd_printf )
amd_printf("OK\n\n");
result = 0LL;
}
}
else
{
LABEL_97:
result = 0xFFFFFFFFLL;
if ( amd_printf )
{
amd_printf("ERROR: out of memory to check Symbolic object\n\n");
result = 0xFFFFFFFFLL;
}
}
return result;
}

original_code:
int umfpack_di_report_symbolic
(
    void *SymbolicHandle,
    const double Control [20]
)
{
    int n_row, n_col, nz, nchains, nfr, maxnrows, maxncols, prl,
 k, chain, frontid, frontid1, frontid2, kk, *Chain_start, *W,
 *Chain_maxrows, *Chain_maxcols, *Front_npivcol, *Front_1strow,
 *Front_leftmostdesc, *Front_parent, done, status1, status2 ;
    SymbolicType *Symbolic ;
    prl = ((Control != (double *) ((void *)0)) ? (((Control [0]) != (Control [0])) ? 1 : Control [0]) : 1) ;
    if (prl <= 2)
    {
 return ((0)) ;
    }
    { if (amd_printf != ((void *)0)) (void) amd_printf ("Symbolic object: ") ; } ;
    Symbolic = (SymbolicType *) SymbolicHandle ;
    if (!umfdi_valid_symbolic (Symbolic))
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: invalid\n") ; } ;
 return ((-4)) ;
    }
    n_row = Symbolic->n_row ;
    n_col = Symbolic->n_col ;
    nz = Symbolic->nz ;
    nchains = Symbolic->nchains ;
    nfr = Symbolic->nfr ;
    maxnrows = Symbolic->maxnrows ;
    maxncols = Symbolic->maxncols ;
    Chain_start = Symbolic->Chain_start ;
    Chain_maxrows = Symbolic->Chain_maxrows ;
    Chain_maxcols = Symbolic->Chain_maxcols ;
    Front_npivcol = Symbolic->Front_npivcol ;
    Front_1strow = Symbolic->Front_1strow ;
    Front_leftmostdesc = Symbolic->Front_leftmostdesc ;
    Front_parent = Symbolic->Front_parent ;
    if (prl >= 4)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\n    matrix to be factorized:\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tn_row: ""%d"" n_col: ""%d""\n", n_row, n_col) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tnumber of entries: ""%d""\n", nz) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    block size used for dense matrix kernels:   ""%d""\n", Symbolic->nb) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    strategy used:                              ") ; } ;
 if (Symbolic->strategy == 3)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("symmetric\n") ; } ;
            { if (amd_printf != ((void *)0)) (void) amd_printf ("    ordering used:                              ") ; } ;
            if (Symbolic->ordering == 1)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("amd on A\n") ; } ;
            }
            else if (Symbolic->ordering == 2)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user permutation") ; } ;
            }
            else if (Symbolic->ordering == 6)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user function") ; } ;
            }
            else if (Symbolic->ordering == 3)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("metis on A") ; } ;
            }
 }
 else
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("unsymmetric\n") ; } ;
            { if (amd_printf != ((void *)0)) (void) amd_printf ("    ordering used:                              ") ; } ;
            if (Symbolic->ordering == 1)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("colamd on A\n") ; } ;
            }
            else if (Symbolic->ordering == 2)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user permutation") ; } ;
            }
            else if (Symbolic->ordering == 6)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user function") ; } ;
            }
            else if (Symbolic->ordering == 3)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("metis on A'A") ; } ;
            }
 }
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    performn column etree postorder:            ") ; } ;
 if (Symbolic->fixQ)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("no\n") ; } ;
 }
 else
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("yes\n") ; } ;
 }
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    prefer diagonal pivoting (attempt P=Q):     ") ; } ;
 if (Symbolic->prefer_diagonal)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("yes\n") ; } ;
 }
 else
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("no\n") ; } ;
 }
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    variable-size part of Numeric object:\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tminimum initial size (Units): %.20g  (MBytes): %.1f\n", Symbolic->dnum_mem_init_usage, (((Symbolic->dnum_mem_init_usage) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\testimated peak size (Units):  %.20g  (MBytes): %.1f\n", Symbolic->num_mem_usage_est, (((Symbolic->num_mem_usage_est) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\testimated final size (Units): %.20g  (MBytes): %.1f\n", Symbolic->num_mem_size_est, (((Symbolic->num_mem_size_est) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    symbolic factorization memory usage (Units):" " %.20g  (MBytes): %.1f\n", Symbolic->peak_sym_usage, (((Symbolic->peak_sym_usage) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    frontal matrices / supercolumns:\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tnumber of frontal chains: ""%d""\n", nchains) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tnumber of frontal matrices: ""%d""\n", nfr) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tlargest frontal matrix row dimension: ""%d""\n", maxnrows) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tlargest frontal matrix column dimension: ""%d""\n",maxncols) ; };
    }
    k = 0 ;
    done = (0) ;
    for (chain = 0 ; chain < nchains ; chain++)
    {
 frontid1 = Chain_start [chain] ;
 frontid2 = Chain_start [chain+1] - 1 ;
 { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\n    Frontal chain: ""%d"".  Frontal matrices ""%d"" to ""%d""\n", (chain), (frontid1), (frontid2)) ; } ; } } ;
 { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\tLargest frontal matrix in Frontal chain: ""%d""-by-""%d""\n", Chain_maxrows [chain], Chain_maxcols [chain]) ; } ; } } ;
 for (frontid = frontid1 ; frontid <= frontid2 ; frontid++)
 {
     kk = Front_npivcol [frontid] ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\tFront: ""%d""  pivot cols: ""%d"" (pivot columns ""%d"" to " "%d"")\n", (frontid), kk, (k), (k+kk-1)) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    pivot row candidates: ""%d"" to ""%d""\n", (Front_1strow [Front_leftmostdesc [frontid]]), (Front_1strow [frontid+1]-1)) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    leftmost descendant: ""%d""\n", (Front_leftmostdesc [frontid])) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    1st new candidate row : ""%d""\n", (Front_1strow [frontid])) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    parent:") ; } ; } } ;
     if (Front_parent [frontid] == (-1))
     {
  { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf (" (none)\n") ; } ; } } ;
     }
     else
     {
  { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf (" ""%d""\n", (Front_parent [frontid])) ; } ; } } ;
     }
     done = (frontid == 20 && frontid < nfr-1 && prl == 4) ;
     if (done)
     {
  { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t...\n") ; } ; } } ;
  break ;
     }
     k += kk ;
 }
 if (Front_npivcol [nfr] != 0)
 {
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\tFront: ""%d"" placeholder for ""%d"" empty columns\n", (nfr), Front_npivcol [nfr]) ; } ; } } ;
 }
 if (done)
 {
     break ;
 }
    }
    W = (int *) umf_i_malloc ((((n_row) > (n_col)) ? (n_row) : (n_col)), sizeof (int)) ;
    if (!W)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: out of memory to check Symbolic object\n\n") ; } ;
 return ((-1)) ;
    }
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\nInitial column permutation, Q1: ") ; } ; } } ;
    status1 = umf_i_report_perm (n_col, Symbolic->Cperm_init, W, prl, 0) ;
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\nInitial row permutation, P1: ") ; } ; } } ;
    status2 = umf_i_report_perm (n_row, Symbolic->Rperm_init, W, prl, 0) ;
    (void) umf_i_free ((void *) W) ;
    if (status1 != (0) || status2 != (0))
    {
 return ((-4)) ;
    }
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("    Symbolic object:  ") ; } ; } } ;
    { if (amd_printf != ((void *)0)) (void) amd_printf ("OK\n\n") ; } ;
    return ((0)) ;
}

canonical_original_code:
int umfpack_di_report_symbolic(void *SymbolicHandle, double Control[20])
{
    int n_row; int n_col; int nz; int nchains; int nfr; int maxnrows; int maxncols; int prl; int k; int chain; int frontid; int frontid1; int frontid2; int kk; int *Chain_start; int *W; int *Chain_maxrows; int *Chain_maxcols; int *Front_npivcol; int *Front_1strow; int *Front_leftmostdesc; int *Front_parent; int done; int status1; int status2;
    struct SymbolicType *Symbolic;
    prl = ((Control != (double *) ((void *)0)) ? (((Control [0]) != (Control [0])) ? 1 : Control [0]) : 1) ;
    if (prl <= 2)
    {
 return ((0)) ;
    }
    { if (amd_printf != ((void *)0)) (void) amd_printf ("Symbolic object: ") ; } ;
    Symbolic = (struct SymbolicType *) SymbolicHandle ;
    if (!umfdi_valid_symbolic (Symbolic))
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: invalid\n") ; } ;
 return ((-4)) ;
    }
    n_row = Symbolic->n_row ;
    n_col = Symbolic->n_col ;
    nz = Symbolic->nz ;
    nchains = Symbolic->nchains ;
    nfr = Symbolic->nfr ;
    maxnrows = Symbolic->maxnrows ;
    maxncols = Symbolic->maxncols ;
    Chain_start = Symbolic->Chain_start ;
    Chain_maxrows = Symbolic->Chain_maxrows ;
    Chain_maxcols = Symbolic->Chain_maxcols ;
    Front_npivcol = Symbolic->Front_npivcol ;
    Front_1strow = Symbolic->Front_1strow ;
    Front_leftmostdesc = Symbolic->Front_leftmostdesc ;
    Front_parent = Symbolic->Front_parent ;
    if (prl >= 4)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\n    matrix to be factorized:\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tn_row: ""%d"" n_col: ""%d""\n", n_row, n_col) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tnumber of entries: ""%d""\n", nz) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    block size used for dense matrix kernels:   ""%d""\n", Symbolic->nb) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    strategy used:                              ") ; } ;
 if (Symbolic->strategy == 3)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("symmetric\n") ; } ;
            { if (amd_printf != ((void *)0)) (void) amd_printf ("    ordering used:                              ") ; } ;
            if (Symbolic->ordering == 1)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("amd on A\n") ; } ;
            }
            else if (Symbolic->ordering == 2)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user permutation") ; } ;
            }
            else if (Symbolic->ordering == 6)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user function") ; } ;
            }
            else if (Symbolic->ordering == 3)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("metis on A") ; } ;
            }
 }
 else
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("unsymmetric\n") ; } ;
            { if (amd_printf != ((void *)0)) (void) amd_printf ("    ordering used:                              ") ; } ;
            if (Symbolic->ordering == 1)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("colamd on A\n") ; } ;
            }
            else if (Symbolic->ordering == 2)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user permutation") ; } ;
            }
            else if (Symbolic->ordering == 6)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("user function") ; } ;
            }
            else if (Symbolic->ordering == 3)
            {
                { if (amd_printf != ((void *)0)) (void) amd_printf ("metis on A'A") ; } ;
            }
 }
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    performn column etree postorder:            ") ; } ;
 if (Symbolic->fixQ)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("no\n") ; } ;
 }
 else
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("yes\n") ; } ;
 }
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    prefer diagonal pivoting (attempt P=Q):     ") ; } ;
 if (Symbolic->prefer_diagonal)
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("yes\n") ; } ;
 }
 else
 {
     { if (amd_printf != ((void *)0)) (void) amd_printf ("no\n") ; } ;
 }
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    variable-size part of Numeric object:\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tminimum initial size (Units): %.20g  (MBytes): %.1f\n", Symbolic->dnum_mem_init_usage, (((Symbolic->dnum_mem_init_usage) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\testimated peak size (Units):  %.20g  (MBytes): %.1f\n", Symbolic->num_mem_usage_est, (((Symbolic->num_mem_usage_est) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\testimated final size (Units): %.20g  (MBytes): %.1f\n", Symbolic->num_mem_size_est, (((Symbolic->num_mem_size_est) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    symbolic factorization memory usage (Units):" " %.20g  (MBytes): %.1f\n", Symbolic->peak_sym_usage, (((Symbolic->peak_sym_usage) * sizeof (Unit)) / 1048576.0)) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("    frontal matrices / supercolumns:\n") ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tnumber of frontal chains: ""%d""\n", nchains) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tnumber of frontal matrices: ""%d""\n", nfr) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tlargest frontal matrix row dimension: ""%d""\n", maxnrows) ; } ;
 { if (amd_printf != ((void *)0)) (void) amd_printf ("\tlargest frontal matrix column dimension: ""%d""\n",maxncols) ; };
    }
    k = 0 ;
    done = (0) ;
    for (chain = 0 ; chain < nchains ; chain++)
    {
 frontid1 = Chain_start [chain] ;
 frontid2 = Chain_start [chain+1] - 1 ;
 { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\n    Frontal chain: ""%d"".  Frontal matrices ""%d"" to ""%d""\n", (chain), (frontid1), (frontid2)) ; } ; } } ;
 { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\tLargest frontal matrix in Frontal chain: ""%d""-by-""%d""\n", Chain_maxrows [chain], Chain_maxcols [chain]) ; } ; } } ;
 for (frontid = frontid1 ; frontid <= frontid2 ; frontid++)
 {
     kk = Front_npivcol [frontid] ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\tFront: ""%d""  pivot cols: ""%d"" (pivot columns ""%d"" to " "%d"")\n", (frontid), kk, (k), (k+kk-1)) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    pivot row candidates: ""%d"" to ""%d""\n", (Front_1strow [Front_leftmostdesc [frontid]]), (Front_1strow [frontid+1]-1)) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    leftmost descendant: ""%d""\n", (Front_leftmostdesc [frontid])) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    1st new candidate row : ""%d""\n", (Front_1strow [frontid])) ; } ; } } ;
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t    parent:") ; } ; } } ;
     if (Front_parent [frontid] == (-1))
     {
  { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf (" (none)\n") ; } ; } } ;
     }
     else
     {
  { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf (" ""%d""\n", (Front_parent [frontid])) ; } ; } } ;
     }
     done = (frontid == 20 && frontid < nfr-1 && prl == 4) ;
     if (done)
     {
  { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\t...\n") ; } ; } } ;
  break ;
     }
     k += kk ;
 }
 if (Front_npivcol [nfr] != 0)
 {
     { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\tFront: ""%d"" placeholder for ""%d"" empty columns\n", (nfr), Front_npivcol [nfr]) ; } ; } } ;
 }
 if (done)
 {
     break ;
 }
    }
    W = (int *) umf_i_malloc ((((n_row) > (n_col)) ? (n_row) : (n_col)), sizeof (int)) ;
    if (!W)
    {
 { if (amd_printf != ((void *)0)) (void) amd_printf ("ERROR: out of memory to check Symbolic object\n\n") ; } ;
 return ((-1)) ;
    }
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\nInitial column permutation, Q1: ") ; } ; } } ;
    status1 = umf_i_report_perm (n_col, Symbolic->Cperm_init, W, prl, 0) ;
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("\nInitial row permutation, P1: ") ; } ; } } ;
    status2 = umf_i_report_perm (n_row, Symbolic->Rperm_init, W, prl, 0) ;
    (void) umf_i_free ((void *) W) ;
    if (status1 != (0) || status2 != (0))
    {
 return ((-4)) ;
    }
    { if (prl >= (4)) { { if (amd_printf != ((void *)0)) (void) amd_printf ("    Symbolic object:  ") ; } ; } } ;
    { if (amd_printf != ((void *)0)) (void) amd_printf ("OK\n\n") ; } ;
    return ((0)) ;
}

variable_types:
SymbolicHandle
void *

variable_types:
Control
double [20]

variable_types: nz int

variable_types: nchains int

variable_types: nfr int

variable_types: maxnrows int

variable_types: maxncols int

variable_types: prl int

variable_types: k int

variable_types: chain int

variable_types: frontid int

variable_types: kk int

variable_types:
W
int *

variable_types: done int

variable_types: struct SymbolicType { double num_mem_usage_est; int valid; } *


decompiled_code:
__int64 umfpack_timer()
{
return SuiteSparse_time();
}

canonical_decompiled_code:
__int64 func0()
{
return SuiteSparse_time();
}

original_code:
double umfpack_timer ( void )
{
    return (SuiteSparse_time ( )) ;
}

canonical_original_code:
double umfpack_timer()
{
    return (SuiteSparse_time ( )) ;
}

return_type: double