#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ colamd(int, int, int, int *, int *, double *, int *);
int colamd_recommended(int, int, int);
int /*<<< orphan*/ colamd_set_defaults(double *);
void *stub1(size_t, size_t);
void stub10(void *);
void stub11(void *);
void stub12(void *);
void stub13(void *);
void stub14(void *);
void stub15(void *);
void *stub2(size_t, size_t);
void stub3(void *);
void stub4(void *);
void stub5(void *);
void stub6(void *);
void stub7(void *);
void stub8(void *);
void *stub9(size_t, size_t);
int symamd(int n, int A[], int p[], int perm[], double knobs[20], int stats[20],
           void *(*allocate)(size_t, size_t), void (*release)(void *)) {
  int *count;
  int *mark;
  int *M;
  int Mlen;
  int n_row;
  int nnz;
  int i;
  int j;
  int k;
  int mnz;
  int pp;
  int last_row;
  int length;
  double cknobs[20];
  double default_knobs[20];
  int cstats[20];
  if (!stats) {
    ;
    ;
    return ((0));
  }
  for (i = 0; i < 20; i++) {
    stats[i] = 0;
  }
  stats[3] = (0);
  stats[4] = -1;
  stats[5] = -1;
  if (!A) {
    stats[3] = (-1);
    ;
    ;
    return ((0));
  }
  if (!p) {
    stats[3] = (-2);
    ;
    ;
    return ((0));
  }
  if (n < 0) {
    stats[3] = (-4);
    stats[4] = n;
    ;
    ;
    return ((0));
  }
  nnz = p[n];
  if (nnz < 0) {
    stats[3] = (-5);
    stats[4] = nnz;
    ;
    ;
    return ((0));
  }
  if (p[0] != 0) {
    stats[3] = (-6);
    stats[4] = p[0];
    ;
    ;
    return ((0));
  }
  if (!knobs) {
    colamd_set_defaults(default_knobs);
    knobs = default_knobs;
  }
  count = (int *)((*allocate)(n + 1, sizeof(int)));
  if (!count) {
    stats[3] = (-10);
    ;
    ;
    return ((0));
  }
  mark = (int *)((*allocate)(n + 1, sizeof(int)));
  if (!mark) {
    stats[3] = (-10);
    (*release)((void *)count);
    ;
    ;
    return ((0));
  }
  stats[6] = 0;
  for (i = 0; i < n; i++) {
    mark[i] = -1;
  }
  for (j = 0; j < n; j++) {
    last_row = -1;
    length = p[j + 1] - p[j];
    if (length < 0) {
      stats[3] = (-8);
      stats[4] = j;
      stats[5] = length;
      (*release)((void *)count);
      (*release)((void *)mark);
      ;
      ;
      return ((0));
    }
    for (pp = p[j]; pp < p[j + 1]; pp++) {
      i = A[pp];
      if (i < 0 || i >= n) {
        stats[3] = (-9);
        stats[4] = j;
        stats[5] = i;
        stats[6] = n;
        (*release)((void *)count);
        (*release)((void *)mark);
        ;
        ;
        return ((0));
      }
      if (i <= last_row || mark[i] == j) {
        stats[3] = (1);
        stats[4] = j;
        stats[5] = i;
        (stats[6])++;
        ;
        ;
      }
      if (i > j && mark[i] != j) {
        count[i]++;
        count[j]++;
      }
      mark[i] = j;
      last_row = i;
    }
  }
  if (stats[3] == (0)) {
    (*release)((void *)mark);
  }
  perm[0] = 0;
  for (j = 1; j <= n; j++) {
    perm[j] = perm[j - 1] + count[j - 1];
  }
  for (j = 0; j < n; j++) {
    count[j] = perm[j];
  }
  mnz = perm[n];
  n_row = mnz / 2;
  Mlen = colamd_recommended(mnz, n_row, n);
  M = (int *)((*allocate)(Mlen, sizeof(int)));
  ;
  ;
  if (!M) {
    stats[3] = (-10);
    (*release)((void *)count);
    (*release)((void *)mark);
    ;
    ;
    return ((0));
  }
  k = 0;
  if (stats[3] == (0)) {
    for (j = 0; j < n; j++) {
      ((void)0);
      for (pp = p[j]; pp < p[j + 1]; pp++) {
        i = A[pp];
        ((void)0);
        if (i > j) {
          M[count[i]++] = k;
          M[count[j]++] = k;
          k++;
        }
      }
    }
  } else {
    ;
    ;
    for (i = 0; i < n; i++) {
      mark[i] = -1;
    }
    for (j = 0; j < n; j++) {
      ((void)0);
      for (pp = p[j]; pp < p[j + 1]; pp++) {
        i = A[pp];
        ((void)0);
        if (i > j && mark[i] != j) {
          M[count[i]++] = k;
          M[count[j]++] = k;
          k++;
          mark[i] = j;
        }
      }
    }
    (*release)((void *)mark);
  }
  (*release)((void *)count);
  ((void)0);
  for (i = 0; i < 20; i++) {
    cknobs[i] = knobs[i];
  }
  cknobs[0] = 1.0;
  if (n_row != 0 && n < n_row) {
    cknobs[1] = (knobs[0] * n) / n_row;
  } else {
    cknobs[1] = 1.0;
  };
  ;
  if (!colamd(n_row, n, Mlen, M, perm, cknobs, cstats)) {
    stats[3] = (-999);
    (*release)((void *)M);
    ;
    ;
    return ((0));
  }
  stats[0] = cstats[1];
  stats[1] = cstats[1];
  stats[2] = cstats[2];
  (*release)((void *)M);
  ;
  ;
  return ((1));
}


x86 assembly (clang, -O0):
<symamd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1171 <symamd+0x41>
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
movl   $0x0,-0x58(%rbp)
cmpl   $0x14,-0x58(%rbp)
jge    119f <symamd+0x6f>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1178 <symamd+0x48>
mov    -0x30(%rbp),%rax
movl   $0x0,0xc(%rax)
mov    -0x30(%rbp),%rax
movl   $0xffffffff,0x10(%rax)
mov    -0x30(%rbp),%rax
movl   $0xffffffff,0x14(%rax)
cmpq   $0x0,-0x10(%rbp)
jne    11e2 <symamd+0xb2>
mov    -0x30(%rbp),%rax
movl   $0xffffffff,0xc(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
cmpq   $0x0,-0x18(%rbp)
jne    1204 <symamd+0xd4>
mov    -0x30(%rbp),%rax
movl   $0xfffffffe,0xc(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
cmpl   $0x0,-0x8(%rbp)
jge    122f <symamd+0xff>
mov    -0x30(%rbp),%rax
movl   $0xfffffffc,0xc(%rax)
mov    -0x8(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x10(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
jge    1268 <symamd+0x138>
mov    -0x30(%rbp),%rax
movl   $0xfffffffb,0xc(%rax)
mov    -0x54(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x10(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1299 <symamd+0x169>
mov    -0x30(%rbp),%rax
movl   $0xfffffffa,0xc(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x10(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
cmpq   $0x0,-0x28(%rbp)
jne    12bb <symamd+0x18b>
lea    -0x1b0(%rbp),%rdi
call   1050 <colamd_set_defaults@plt>
lea    -0x1b0(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdi
mov    $0x4,%esi
call   *%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    12f5 <symamd+0x1c5>
mov    -0x30(%rbp),%rax
movl   $0xfffffff6,0xc(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdi
mov    $0x4,%esi
call   *%rax
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    1339 <symamd+0x209>
mov    -0x30(%rbp),%rax
movl   $0xfffffff6,0xc(%rax)
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rdi
call   *%rax
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
mov    -0x30(%rbp),%rax
movl   $0x0,0x18(%rax)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1374 <symamd+0x244>
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    134b <symamd+0x21b>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    154c <symamd+0x41c>
movl   $0xffffffff,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x70(%rbp)
jge    13f5 <symamd+0x2c5>
mov    -0x30(%rbp),%rax
movl   $0xfffffff8,0xc(%rax)
mov    -0x5c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x70(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rdi
call   *%rax
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rdi
call   *%rax
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1539 <symamd+0x409>
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x58(%rbp)
jl     1440 <symamd+0x310>
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jl     1489 <symamd+0x359>
mov    -0x30(%rbp),%rax
movl   $0xfffffff7,0xc(%rax)
mov    -0x5c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rdi
call   *%rax
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rdi
call   *%rax
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
mov    -0x58(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jle    14a9 <symamd+0x379>
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x5c(%rbp),%eax
jne    14d5 <symamd+0x3a5>
mov    -0x30(%rbp),%rax
movl   $0x1,0xc(%rax)
mov    -0x5c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x30(%rbp),%rax
mov    0x18(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x18(%rax)
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    1517 <symamd+0x3e7>
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x5c(%rbp),%eax
je     1517 <symamd+0x3e7>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1403 <symamd+0x2d3>
jmp    153e <symamd+0x40e>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    137b <symamd+0x24b>
mov    -0x30(%rbp),%rax
cmpl   $0x0,0xc(%rax)
jne    1564 <symamd+0x434>
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rdi
call   *%rax
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     15ba <symamd+0x48a>
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1575 <symamd+0x445>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15f1 <symamd+0x4c1>
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    15c1 <symamd+0x491>
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x50(%rbp)
mov    -0x64(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x8(%rbp),%edx
call   1030 <colamd_recommended@plt>
mov    %eax,-0x4c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rdi
mov    $0x4,%esi
call   *%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    1667 <symamd+0x537>
mov    -0x30(%rbp),%rax
movl   $0xfffffff6,0xc(%rax)
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rdi
call   *%rax
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rdi
call   *%rax
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
movl   $0x0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x0,0xc(%rax)
jne    174a <symamd+0x61a>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1745 <symamd+0x615>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1732 <symamd+0x602>
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    171f <symamd+0x5ef>
mov    -0x60(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rsi
movslq -0x58(%rbp),%rdi
mov    (%rsi,%rdi,4),%ecx
mov    %ecx,%r8d
add    $0x1,%r8d
mov    %r8d,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
mov    (%rsi,%rdi,4),%ecx
mov    %ecx,%r8d
add    $0x1,%r8d
mov    %r8d,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1724 <symamd+0x5f4>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    169d <symamd+0x56d>
jmp    1737 <symamd+0x607>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1683 <symamd+0x553>
jmp    186f <symamd+0x73f>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    177a <symamd+0x64a>
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1751 <symamd+0x621>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1865 <symamd+0x735>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1852 <symamd+0x722>
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    183f <symamd+0x70f>
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x5c(%rbp),%eax
je     183f <symamd+0x70f>
mov    -0x60(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rsi
movslq -0x58(%rbp),%rdi
mov    (%rsi,%rdi,4),%ecx
mov    %ecx,%r8d
add    $0x1,%r8d
mov    %r8d,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rsi
movslq -0x5c(%rbp),%rdi
mov    (%rsi,%rdi,4),%ecx
mov    %ecx,%r8d
add    $0x1,%r8d
mov    %r8d,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1844 <symamd+0x714>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    179b <symamd+0x66b>
jmp    1857 <symamd+0x727>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1781 <symamd+0x651>
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rdi
call   *%rax
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rdi
call   *%rax
movl   $0x0,-0x58(%rbp)
cmpl   $0x14,-0x58(%rbp)
jge    18b2 <symamd+0x782>
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x58(%rbp),%rax
movsd  %xmm0,-0x110(%rbp,%rax,8)
ff ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1880 <symamd+0x750>
movsd  0x746(%rip),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
cmpl   $0x0,-0x50(%rbp)
je     18ff <symamd+0x7cf>
mov    -0x8(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    18ff <symamd+0x7cf>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
cvtsi2sdl -0x8(%rbp),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    190f <symamd+0x7df>
movsd  0x6f9(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x50(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    -0x48(%rbp),%rcx
mov    -0x20(%rbp),%r8
lea    -0x110(%rbp),%r9
lea    -0x200(%rbp),%rax
mov    %rax,(%rsp)
call   1040 <colamd@plt>
cmp    $0x0,%eax
jne    1961 <symamd+0x831>
mov    -0x30(%rbp),%rax
movl   $0xfffffc19,0xc(%rax)
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rdi
call   *%rax
movl   $0x0,-0x4(%rbp)
jmp    1998 <symamd+0x868>
mov    -0x1fc(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1fc(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rdi
call   *%rax
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x210,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<symamd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d8,%rsp
xor    %eax,%eax
test   %r9,%r9
je     11f8 <symamd+0xa8>
mov    %r9,%rbx
mov    %rsi,%r12
xorpd  %xmm0,%xmm0
movupd %xmm0,0x10(%r9)
movupd %xmm0,0x40(%r9)
movupd %xmm0,0x30(%r9)
movupd %xmm0,0x20(%r9)
movupd %xmm0,(%r9)
movq   $0xffffffffffffffff,0x10(%r9)
ff
test   %rsi,%rsi
je     11d0 <symamd+0x80>
mov    %rdx,%r13
test   %rdx,%rdx
je     11d9 <symamd+0x89>
mov    %edi,%edx
test   %edi,%edi
js     11e2 <symamd+0x92>
mov    %edx,%edi
mov    0x0(%r13,%rdi,4),%esi
test   %esi,%esi
js     11ee <symamd+0x9e>
cmpl   $0x0,0x0(%r13)
je     120a <symamd+0xba>
movl   $0xfffffffa,0xc(%rbx)
mov    0x0(%r13),%ecx
mov    %ecx,0x10(%rbx)
jmp    11f8 <symamd+0xa8>
movl   $0xffffffff,0xc(%rbx)
jmp    11f8 <symamd+0xa8>
movl   $0xfffffffe,0xc(%rbx)
jmp    11f8 <symamd+0xa8>
movl   $0xfffffffc,0xc(%rbx)
mov    %edx,0x10(%rbx)
jmp    11f8 <symamd+0xa8>
movl   $0xfffffffb,0xc(%rbx)
mov    %esi,0x10(%rbx)
add    $0x1d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%rbp
mov    %rdi,0x10(%rsp)
mov    %rcx,0x18(%rsp)
mov    0x210(%rsp),%r15
test   %r8,%r8
jne    123a <symamd+0xea>
lea    0x130(%rsp),%rbp
mov    %rbp,%rdi
mov    %rdx,%r14
call   1070 <colamd_set_defaults@plt>
mov    %r14,%rdx
mov    %rbp,0x38(%rsp)
mov    %rdx,0x8(%rsp)
lea    0x1(%rdx),%r14d
mov    $0x4,%esi
mov    %r14,%rdi
call   *%r15
test   %rax,%rax
je     1348 <symamd+0x1f8>
mov    %r15,%rcx
mov    %rax,%r15
mov    $0x4,%esi
mov    %r14,%rdi
call   *%rcx
test   %rax,%rax
je     1356 <symamd+0x206>
mov    %rax,%r10
movl   $0x0,0x18(%rbx)
mov    0x8(%rsp),%rdx
test   %edx,%edx
mov    0x10(%rsp),%r9
je     1396 <symamd+0x246>
lea    0x0(,%r9,4),%rdx
mov    %r10,%rdi
mov    $0xff,%esi
mov    %r10,%rbp
call   1030 <memset@plt>
mov    %rbp,%r10
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdx
mov    0x0(%r13),%ebp
xor    %eax,%eax
jmp    12c9 <symamd+0x179>
mov    %edi,%ebp
cmp    %r9,%rax
je     1396 <symamd+0x246>
mov    %rax,%rcx
add    $0x1,%rax
mov    0x4(%r13,%rcx,4),%edi
mov    %edi,%esi
sub    %ebp,%esi
js     14c4 <symamd+0x374>
jle    12be <symamd+0x16e>
movslq %ebp,%rbp
mov    $0xffffffff,%esi
jmp    1302 <symamd+0x1b2>
nopl   0x0(%rax,%rax,1)
mov    %ecx,(%r10,%rsi,4)
add    $0x1,%rbp
movslq 0x0(%r13,%rax,4),%rdi
cmp    %rdi,%rbp
jge    12be <symamd+0x16e>
mov    %esi,%edi
mov    (%r12,%rbp,4),%esi
test   %esi,%esi
js     136e <symamd+0x21e>
cmp    %edx,%esi
jge    136e <symamd+0x21e>
cmp    %edi,%esi
jle    131d <symamd+0x1cd>
mov    (%r10,%rsi,4),%edi
cmp    %rdi,%rcx
jne    132e <symamd+0x1de>
movl   $0x1,0xc(%rbx)
mov    %ecx,0x10(%rbx)
mov    %esi,0x14(%rbx)
addl   $0x1,0x18(%rbx)
cmp    %rsi,%rcx
jae    12f0 <symamd+0x1a0>
mov    (%r10,%rsi,4),%edi
cmp    %rdi,%rcx
je     12f0 <symamd+0x1a0>
addl   $0x1,(%r15,%rsi,4)
addl   $0x1,(%r15,%rcx,4)
jmp    12f0 <symamd+0x1a0>
movl   $0xfffffff6,0xc(%rbx)
xor    %eax,%eax
jmp    11f8 <symamd+0xa8>
movl   $0xfffffff6,0xc(%rbx)
mov    %r15,%rdi
call   *0x218(%rsp)
xor    %eax,%eax
jmp    11f8 <symamd+0xa8>
movl   $0xfffffff7,0xc(%rbx)
mov    %ecx,0x10(%rbx)
mov    %esi,0x14(%rbx)
mov    %edx,0x18(%rbx)
mov    %r15,%rdi
mov    0x218(%rsp),%rbx
mov    %r10,%rbp
call   *%rbx
mov    %rbp,%rdi
jmp    176c <symamd+0x61c>
cmpl   $0x0,0xc(%rbx)
jne    13b6 <symamd+0x266>
mov    %r10,%rdi
mov    %r10,%rbp
call   *0x218(%rsp)
mov    %rbp,%r10
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdx
mov    0x18(%rsp),%rax
movl   $0x0,(%rax)
test   %edx,%edx
jle    144a <symamd+0x2fa>
lea    -0x1(%r14),%rsi
add    $0xfffffffffffffffe,%r14
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x3,%r14
jae    13e5 <symamd+0x295>
mov    $0x1,%edi
xor    %ecx,%ecx
jmp    1422 <symamd+0x2d2>
and    $0xfffffffffffffffc,%rsi
xor    %ecx,%ecx
xor    %edi,%edi
mov    0x18(%rsp),%rbp
add    (%r15,%rdi,4),%ecx
mov    %ecx,0x4(%rbp,%rdi,4)
add    0x4(%r15,%rdi,4),%ecx
mov    %ecx,0x8(%rbp,%rdi,4)
add    0x8(%r15,%rdi,4),%ecx
mov    %ecx,0xc(%rbp,%rdi,4)
add    0xc(%r15,%rdi,4),%ecx
mov    %ecx,0x10(%rbp,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    13f2 <symamd+0x2a2>
add    $0x1,%rdi
test   %rax,%rax
je     144a <symamd+0x2fa>
mov    0x18(%rsp),%rsi
lea    (%rsi,%rdi,4),%rsi
lea    (%r15,%rdi,4),%rbp
add    $0xfffffffffffffffc,%rbp
xor    %edi,%edi
add    0x0(%rbp,%rdi,4),%ecx
mov    %ecx,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    143a <symamd+0x2ea>
test   %edx,%edx
mov    0x18(%rsp),%rbp
je     15d7 <symamd+0x487>
movl   $0x0,(%r15)
cmp    $0x1,%edx
je     15d7 <symamd+0x487>
lea    -0x1(%r9),%r8
mov    $0x1,%eax
cmp    $0x8,%r8
jb     157f <symamd+0x42f>
lea    0x4(%r15),%rdi
lea    0x0(,%r9,4),%rsi
add    %rbp,%rsi
cmp    %rsi,%rdi
jae    149f <symamd+0x34f>
lea    (%r15,%r9,4),%rdi
lea    0x4(%rbp),%rsi
cmp    %rsi,%rdi
ja     157f <symamd+0x42f>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    14d6 <symamd+0x386>
xor    %esi,%esi
jmp    1542 <symamd+0x3f2>
movl   $0xfffffff8,0xc(%rbx)
mov    %ecx,0x10(%rbx)
mov    %esi,0x14(%rbx)
jmp    137e <symamd+0x22e>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
movups 0x4(%rbp,%rsi,4),%xmm0
movups 0x14(%rbp,%rsi,4),%xmm1
movups %xmm0,0x4(%r15,%rsi,4)
movups %xmm1,0x14(%r15,%rsi,4)
movups 0x24(%rbp,%rsi,4),%xmm0
movups 0x34(%rbp,%rsi,4),%xmm1
movups %xmm0,0x24(%r15,%rsi,4)
movups %xmm1,0x34(%r15,%rsi,4)
movups 0x44(%rbp,%rsi,4),%xmm0
movups 0x54(%rbp,%rsi,4),%xmm1
movups %xmm0,0x44(%r15,%rsi,4)
movups %xmm1,0x54(%r15,%rsi,4)
movupd 0x64(%rbp,%rsi,4),%xmm0
movupd 0x74(%rbp,%rsi,4),%xmm1
movupd %xmm0,0x64(%r15,%rsi,4)
movupd %xmm1,0x74(%r15,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    14dc <symamd+0x38c>
test   %rcx,%rcx
je     1576 <symamd+0x426>
lea    0x0(,%rsi,4),%rdi
or     $0x4,%rdi
movupd 0x0(%rbp,%rdi,1),%xmm0
movupd 0x10(%rbp,%rdi,1),%xmm1
movupd %xmm0,(%r15,%rdi,1)
movupd %xmm1,0x10(%r15,%rdi,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%rcx
jne    1547 <symamd+0x3f7>
cmp    %rax,%r8
je     15d7 <symamd+0x487>
or     $0x1,%rax
mov    %r9d,%edi
sub    %eax,%edi
mov    %rax,%rcx
not    %rcx
add    %r9,%rcx
and    $0x3,%rdi
je     15a5 <symamd+0x455>
mov    0x0(%rbp,%rax,4),%esi
mov    %esi,(%r15,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1593 <symamd+0x443>
cmp    $0x3,%rcx
jb     15d7 <symamd+0x487>
mov    0x0(%rbp,%rax,4),%ecx
mov    %ecx,(%r15,%rax,4)
mov    0x4(%rbp,%rax,4),%ecx
mov    %ecx,0x4(%r15,%rax,4)
mov    0x8(%rbp,%rax,4),%ecx
mov    %ecx,0x8(%r15,%rax,4)
mov    0xc(%rbp,%rax,4),%ecx
mov    %ecx,0xc(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%r9
jne    15ab <symamd+0x45b>
mov    %r10,0x28(%rsp)
mov    0x0(%rbp,%r9,4),%edi
mov    %edi,%esi
shr    $0x1f,%esi
add    %edi,%esi
sar    %esi
mov    %edi,0x34(%rsp)
mov    %esi,0x24(%rsp)
call   1040 <colamd_recommended@plt>
mov    %eax,0x20(%rsp)
movslq %eax,%rdi
mov    $0x4,%esi
call   *0x210(%rsp)
test   %rax,%rax
je     1753 <symamd+0x603>
mov    %rax,%r14
cmpl   $0x0,0xc(%rbx)
je     1775 <symamd+0x625>
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%rax
mov    0x28(%rsp),%rdi
je     16c9 <symamd+0x579>
lea    0x0(,%rax,4),%rdx
mov    $0xff,%esi
call   1030 <memset@plt>
mov    0x28(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x0(%r13),%eax
xor    %r8d,%r8d
xor    %r10d,%r10d
jmp    1664 <symamd+0x514>
mov    %ecx,%eax
cmp    %r9,%r8
je     16c9 <symamd+0x579>
mov    %r8,%rdx
add    $0x1,%r8
mov    0x4(%r13,%rdx,4),%ecx
cmp    %ecx,%eax
jge    165d <symamd+0x50d>
movslq %eax,%rsi
jmp    168c <symamd+0x53c>
nopl   0x0(%rax)
add    $0x1,%rsi
movslq %ecx,%rax
cmp    %rax,%rsi
jge    165d <symamd+0x50d>
movslq (%r12,%rsi,4),%rax
cmp    %rax,%rdx
jge    1680 <symamd+0x530>
mov    (%rdi,%rax,4),%ebp
cmp    %rbp,%rdx
je     1680 <symamd+0x530>
movslq (%r15,%rax,4),%rcx
lea    0x1(%rcx),%ebp
mov    %ebp,(%r15,%rax,4)
mov    %r10d,(%r14,%rcx,4)
movslq (%r15,%rdx,4),%rcx
lea    0x1(%rcx),%ebp
mov    %ebp,(%r15,%rdx,4)
mov    %r10d,(%r14,%rcx,4)
add    $0x1,%r10d
mov    %edx,(%rdi,%rax,4)
mov    0x0(%r13,%r8,4),%ecx
jmp    1680 <symamd+0x530>
call   *0x218(%rsp)
mov    %r15,%rdi
mov    0x218(%rsp),%r15
call   *%r15
lea    0x90(%rsp),%rdi
mov    $0xa0,%edx
mov    0x38(%rsp),%rbp
mov    %rbp,%rsi
call   1050 <memcpy@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x90(%rsp)
mov    0x34(%rsp),%eax
add    $0xfffffffe,%eax
movsd  0x8e7(%rip),%xmm0
cmp    $0xfffffffc,%eax
ja     17ed <symamd+0x69d>
mov    0x8(%rsp),%rsi
mov    0x24(%rsp),%edi
cmp    %esi,%edi
mov    0x20(%rsp),%edx
jle    17fa <symamd+0x6aa>
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd  0x0(%rbp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd  %xmm1,%xmm0
jmp    17fa <symamd+0x6aa>
movl   $0xfffffff6,0xc(%rbx)
mov    %r15,%rdi
mov    0x218(%rsp),%rbx
call   *%rbx
mov    0x28(%rsp),%rdi
call   *%rbx
xor    %eax,%eax
jmp    11f8 <symamd+0xa8>
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%r9
je     16d0 <symamd+0x580>
mov    0x0(%r13),%esi
xor    %r8d,%r8d
xor    %ecx,%ecx
jmp    179b <symamd+0x64b>
mov    %edi,%esi
cmp    %r9,%r8
je     16d0 <symamd+0x580>
mov    %r8,%rdx
add    $0x1,%r8
mov    0x4(%r13,%rdx,4),%edi
cmp    %edi,%esi
jge    1790 <symamd+0x640>
movslq %esi,%rsi
jmp    17bc <symamd+0x66c>
add    $0x1,%rsi
movslq %edi,%rax
cmp    %rax,%rsi
jge    1790 <symamd+0x640>
movslq (%r12,%rsi,4),%rax
cmp    %rax,%rdx
jge    17b0 <symamd+0x660>
movslq (%r15,%rax,4),%rdi
lea    0x1(%rdi),%ebp
mov    %ebp,(%r15,%rax,4)
mov    %ecx,(%r14,%rdi,4)
movslq (%r15,%rdx,4),%rax
lea    0x1(%rax),%edi
mov    %edi,(%r15,%rdx,4)
mov    %ecx,(%r14,%rax,4)
add    $0x1,%ecx
mov    0x0(%r13,%r8,4),%edi
jmp    17b0 <symamd+0x660>
mov    0x8(%rsp),%rsi
mov    0x24(%rsp),%edi
mov    0x20(%rsp),%edx
movsd  %xmm0,0x98(%rsp)
lea    0x40(%rsp),%rax
mov    %rax,(%rsp)
lea    0x90(%rsp),%r9
mov    %r14,%rcx
mov    0x18(%rsp),%r8
call   1060 <colamd@plt>
test   %eax,%eax
je     1845 <symamd+0x6f5>
mov    0x44(%rsp),%eax
mov    %eax,(%rbx)
mov    %eax,0x4(%rbx)
mov    0x48(%rsp),%eax
mov    %eax,0x8(%rbx)
mov    %r14,%rdi
call   *%r15
mov    $0x1,%eax
jmp    11f8 <symamd+0xa8>
movl   $0xfffffc19,0xc(%rbx)
mov    %r14,%rdi
call   *%r15
xor    %eax,%eax
jmp    11f8 <symamd+0xa8>

LLVM IR (-O0):
define i32 @symamd(i32 %0, i32* %1, i32* %2, i32* %3, double* %4, i32* %5, i8* (i64, i64)* %6, void (i8*)* %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca double*
%15 = alloca i32*
%16 = alloca i8* (i64, i64)*
%17 = alloca void (i8*)*
%18 = alloca i32*
%19 = alloca i32*
%20 = alloca i32*
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca [20 x double]
%32 = alloca [20 x double]
%33 = alloca [20 x i32]
store i32 %0, i32* %10
store i32* %1, i32** %11
store i32* %2, i32** %12
store i32* %3, i32** %13
store double* %4, double** %14
store i32* %5, i32** %15
store i8* (i64, i64)* %6, i8* (i64, i64)** %16
store void (i8*)* %7, void (i8*)** %17
%34 = load i32*, i32** %15
%35 = icmp ne i32* %34, null
br i1 %35, label %37, label %36
36: ; preds = %8
store i32 0, i32* %9
br label %607
37: ; preds = %8
store i32 0, i32* %24
br label %38
38: ; preds = %46, %37
%39 = load i32, i32* %24
%40 = icmp slt i32 %39, 20
br i1 %40, label %41, label %49
41: ; preds = %38
%42 = load i32*, i32** %15
%43 = load i32, i32* %24
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %42, i64 %44
store i32 0, i32* %45
br label %46
46: ; preds = %41
%47 = load i32, i32* %24
%48 = add nsw i32 %47, 1
store i32 %48, i32* %24
br label %38
49: ; preds = %38
%50 = load i32*, i32** %15
%51 = getelementptr inbounds i32, i32* %50, i64 3
store i32 0, i32* %51
%52 = load i32*, i32** %15
%53 = getelementptr inbounds i32, i32* %52, i64 4
store i32 -1, i32* %53
%54 = load i32*, i32** %15
%55 = getelementptr inbounds i32, i32* %54, i64 5
store i32 -1, i32* %55
%56 = load i32*, i32** %11
%57 = icmp ne i32* %56, null
br i1 %57, label %61, label %58
58: ; preds = %49
%59 = load i32*, i32** %15
%60 = getelementptr inbounds i32, i32* %59, i64 3
store i32 -1, i32* %60
store i32 0, i32* %9
br label %607
61: ; preds = %49
%62 = load i32*, i32** %12
%63 = icmp ne i32* %62, null
br i1 %63, label %67, label %64
64: ; preds = %61
%65 = load i32*, i32** %15
%66 = getelementptr inbounds i32, i32* %65, i64 3
store i32 -2, i32* %66
store i32 0, i32* %9
br label %607
67: ; preds = %61
%68 = load i32, i32* %10
%69 = icmp slt i32 %68, 0
br i1 %69, label %70, label %76
70: ; preds = %67
%71 = load i32*, i32** %15
%72 = getelementptr inbounds i32, i32* %71, i64 3
store i32 -4, i32* %72
%73 = load i32, i32* %10
%74 = load i32*, i32** %15
%75 = getelementptr inbounds i32, i32* %74, i64 4
store i32 %73, i32* %75
store i32 0, i32* %9
br label %607
76: ; preds = %67
%77 = load i32*, i32** %12
%78 = load i32, i32* %10
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
%81 = load i32, i32* %80
store i32 %81, i32* %23
%82 = load i32, i32* %23
%83 = icmp slt i32 %82, 0
br i1 %83, label %84, label %90
84: ; preds = %76
%85 = load i32*, i32** %15
%86 = getelementptr inbounds i32, i32* %85, i64 3
store i32 -5, i32* %86
%87 = load i32, i32* %23
%88 = load i32*, i32** %15
%89 = getelementptr inbounds i32, i32* %88, i64 4
store i32 %87, i32* %89
store i32 0, i32* %9
br label %607
90: ; preds = %76
%91 = load i32*, i32** %12
%92 = getelementptr inbounds i32, i32* %91, i64 0
%93 = load i32, i32* %92
%94 = icmp ne i32 %93, 0
br i1 %94, label %95, label %103
95: ; preds = %90
%96 = load i32*, i32** %15
%97 = getelementptr inbounds i32, i32* %96, i64 3
store i32 -6, i32* %97
%98 = load i32*, i32** %12
%99 = getelementptr inbounds i32, i32* %98, i64 0
%100 = load i32, i32* %99
%101 = load i32*, i32** %15
%102 = getelementptr inbounds i32, i32* %101, i64 4
store i32 %100, i32* %102
store i32 0, i32* %9
br label %607
103: ; preds = %90
%104 = load double*, double** %14
%105 = icmp ne double* %104, null
br i1 %105, label %110, label %106
106: ; preds = %103
%107 = getelementptr inbounds [20 x double], [20 x double]* %32, i64 0, i64 0
%108 = call i32 @colamd_set_defaults(double* %107)
%109 = getelementptr inbounds [20 x double], [20 x double]* %32, i64 0, i64 0
store double* %109, double** %14
br label %110
110: ; preds = %106, %103
%111 = load i8* (i64, i64)*, i8* (i64, i64)** %16
%112 = load i32, i32* %10
%113 = add nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = call i8* %111(i64 %114, i64 4)
%116 = bitcast i8* %115 to i32*
store i32* %116, i32** %18
%117 = load i32*, i32** %18
%118 = icmp ne i32* %117, null
br i1 %118, label %122, label %119
119: ; preds = %110
%120 = load i32*, i32** %15
%121 = getelementptr inbounds i32, i32* %120, i64 3
store i32 -10, i32* %121
store i32 0, i32* %9
br label %607
122: ; preds = %110
%123 = load i8* (i64, i64)*, i8* (i64, i64)** %16
%124 = load i32, i32* %10
%125 = add nsw i32 %124, 1
%126 = sext i32 %125 to i64
%127 = call i8* %123(i64 %126, i64 4)
%128 = bitcast i8* %127 to i32*
store i32* %128, i32** %19
%129 = load i32*, i32** %19
%130 = icmp ne i32* %129, null
br i1 %130, label %137, label %131
131: ; preds = %122
%132 = load i32*, i32** %15
%133 = getelementptr inbounds i32, i32* %132, i64 3
store i32 -10, i32* %133
%134 = load void (i8*)*, void (i8*)** %17
%135 = load i32*, i32** %18
%136 = bitcast i32* %135 to i8*
store i32 0, i32* %9
br label %607
137: ; preds = %122
%138 = load i32*, i32** %15
%139 = getelementptr inbounds i32, i32* %138, i64 6
store i32 0, i32* %139
store i32 0, i32* %24
br label %140
140: ; preds = %149, %137
%141 = load i32, i32* %24
%142 = load i32, i32* %10
%143 = icmp slt i32 %141, %142
br i1 %143, label %144, label %152
144: ; preds = %140
%145 = load i32*, i32** %19
%146 = load i32, i32* %24
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
store i32 -1, i32* %148
br label %149
149: ; preds = %144
%150 = load i32, i32* %24
%151 = add nsw i32 %150, 1
store i32 %151, i32* %24
br label %140
152: ; preds = %140
store i32 0, i32* %25
br label %153
153: ; preds = %293, %152
%154 = load i32, i32* %25
%155 = load i32, i32* %10
%156 = icmp slt i32 %154, %155
br i1 %156, label %157, label %296
157: ; preds = %153
store i32 -1, i32* %29
%158 = load i32*, i32** %12
%159 = load i32, i32* %25
%160 = add nsw i32 %159, 1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %158, i64 %161
%163 = load i32, i32* %162
%164 = load i32*, i32** %12
%165 = load i32, i32* %25
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i32, i32* %164, i64 %166
%168 = load i32, i32* %167
%169 = sub nsw i32 %163, %168
store i32 %169, i32* %30
%170 = load i32, i32* %30
%171 = icmp slt i32 %170, 0
br i1 %171, label %172, label %187
172: ; preds = %157
%173 = load i32*, i32** %15
%174 = getelementptr inbounds i32, i32* %173, i64 3
store i32 -8, i32* %174
%175 = load i32, i32* %25
%176 = load i32*, i32** %15
%177 = getelementptr inbounds i32, i32* %176, i64 4
store i32 %175, i32* %177
%178 = load i32, i32* %30
%179 = load i32*, i32** %15
%180 = getelementptr inbounds i32, i32* %179, i64 5
store i32 %178, i32* %180
%181 = load void (i8*)*, void (i8*)** %17
%182 = load i32*, i32** %18
%183 = bitcast i32* %182 to i8*
%184 = load void (i8*)*, void (i8*)** %17
%185 = load i32*, i32** %19
%186 = bitcast i32* %185 to i8*
store i32 0, i32* %9
br label %607
187: ; preds = %157
%188 = load i32*, i32** %12
%189 = load i32, i32* %25
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %188, i64 %190
%192 = load i32, i32* %191
store i32 %192, i32* %28
br label %193
193: ; preds = %289, %187
%194 = load i32, i32* %28
%195 = load i32*, i32** %12
%196 = load i32, i32* %25
%197 = add nsw i32 %196, 1
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %195, i64 %198
%200 = load i32, i32* %199
%201 = icmp slt i32 %194, %200
br i1 %201, label %202, label %292
202: ; preds = %193
%203 = load i32*, i32** %11
%204 = load i32, i32* %28
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %203, i64 %205
%207 = load i32, i32* %206
store i32 %207, i32* %24
%208 = load i32, i32* %24
%209 = icmp slt i32 %208, 0
br i1 %209, label %214, label %210
210: ; preds = %202
%211 = load i32, i32* %24
%212 = load i32, i32* %10
%213 = icmp sge i32 %211, %212
br i1 %213, label %214, label %232
214: ; preds = %210, %202
%215 = load i32*, i32** %15
%216 = getelementptr inbounds i32, i32* %215, i64 3
store i32 -9, i32* %216
%217 = load i32, i32* %25
%218 = load i32*, i32** %15
%219 = getelementptr inbounds i32, i32* %218, i64 4
store i32 %217, i32* %219
%220 = load i32, i32* %24
%221 = load i32*, i32** %15
%222 = getelementptr inbounds i32, i32* %221, i64 5
store i32 %220, i32* %222
%223 = load i32, i32* %10
%224 = load i32*, i32** %15
%225 = getelementptr inbounds i32, i32* %224, i64 6
store i32 %223, i32* %225
%226 = load void (i8*)*, void (i8*)** %17
%227 = load i32*, i32** %18
%228 = bitcast i32* %227 to i8*
%229 = load void (i8*)*, void (i8*)** %17
%230 = load i32*, i32** %19
%231 = bitcast i32* %230 to i8*
store i32 0, i32* %9
br label %607
232: ; preds = %210
%233 = load i32, i32* %24
%234 = load i32, i32* %29
%235 = icmp sle i32 %233, %234
br i1 %235, label %244, label %236
236: ; preds = %232
%237 = load i32*, i32** %19
%238 = load i32, i32* %24
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i32, i32* %237, i64 %239
%241 = load i32, i32* %240
%242 = load i32, i32* %25
%243 = icmp eq i32 %241, %242
br i1 %243, label %244, label %257
244: ; preds = %236, %232
%245 = load i32*, i32** %15
%246 = getelementptr inbounds i32, i32* %245, i64 3
store i32 1, i32* %246
%247 = load i32, i32* %25
%248 = load i32*, i32** %15
%249 = getelementptr inbounds i32, i32* %248, i64 4
store i32 %247, i32* %249
%250 = load i32, i32* %24
%251 = load i32*, i32** %15
%252 = getelementptr inbounds i32, i32* %251, i64 5
store i32 %250, i32* %252
%253 = load i32*, i32** %15
%254 = getelementptr inbounds i32, i32* %253, i64 6
%255 = load i32, i32* %254
%256 = add nsw i32 %255, 1
store i32 %256, i32* %254
br label %257
257: ; preds = %244, %236
%258 = load i32, i32* %24
%259 = load i32, i32* %25
%260 = icmp sgt i32 %258, %259
br i1 %260, label %261, label %282
261: ; preds = %257
%262 = load i32*, i32** %19
%263 = load i32, i32* %24
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i32, i32* %262, i64 %264
%266 = load i32, i32* %265
%267 = load i32, i32* %25
%268 = icmp ne i32 %266, %267
br i1 %268, label %269, label %282
269: ; preds = %261
%270 = load i32*, i32** %18
%271 = load i32, i32* %24
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i32, i32* %270, i64 %272
%274 = load i32, i32* %273
%275 = add nsw i32 %274, 1
store i32 %275, i32* %273
%276 = load i32*, i32** %18
%277 = load i32, i32* %25
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %276, i64 %278
%280 = load i32, i32* %279
%281 = add nsw i32 %280, 1
store i32 %281, i32* %279
br label %282
282: ; preds = %269, %261, %257
%283 = load i32, i32* %25
%284 = load i32*, i32** %19
%285 = load i32, i32* %24
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i32, i32* %284, i64 %286
store i32 %283, i32* %287
%288 = load i32, i32* %24
store i32 %288, i32* %29
br label %289
289: ; preds = %282
%290 = load i32, i32* %28
%291 = add nsw i32 %290, 1
store i32 %291, i32* %28
br label %193
292: ; preds = %193
br label %293
293: ; preds = %292
%294 = load i32, i32* %25
%295 = add nsw i32 %294, 1
store i32 %295, i32* %25
br label %153
296: ; preds = %153
%297 = load i32*, i32** %15
%298 = getelementptr inbounds i32, i32* %297, i64 3
%299 = load i32, i32* %298
%300 = icmp eq i32 %299, 0
br i1 %300, label %301, label %305
301: ; preds = %296
%302 = load void (i8*)*, void (i8*)** %17
%303 = load i32*, i32** %19
%304 = bitcast i32* %303 to i8*
br label %305
305: ; preds = %301, %296
%306 = load i32*, i32** %13
%307 = getelementptr inbounds i32, i32* %306, i64 0
store i32 0, i32* %307
store i32 1, i32* %25
br label %308
308: ; preds = %330, %305
%309 = load i32, i32* %25
%310 = load i32, i32* %10
%311 = icmp sle i32 %309, %310
br i1 %311, label %312, label %333
312: ; preds = %308
%313 = load i32*, i32** %13
%314 = load i32, i32* %25
%315 = sub nsw i32 %314, 1
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i32, i32* %313, i64 %316
%318 = load i32, i32* %317
%319 = load i32*, i32** %18
%320 = load i32, i32* %25
%321 = sub nsw i32 %320, 1
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32, i32* %319, i64 %322
%324 = load i32, i32* %323
%325 = add nsw i32 %318, %324
%326 = load i32*, i32** %13
%327 = load i32, i32* %25
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %326, i64 %328
store i32 %325, i32* %329
br label %330
330: ; preds = %312
%331 = load i32, i32* %25
%332 = add nsw i32 %331, 1
store i32 %332, i32* %25
br label %308
333: ; preds = %308
store i32 0, i32* %25
br label %334
334: ; preds = %348, %333
%335 = load i32, i32* %25
%336 = load i32, i32* %10
%337 = icmp slt i32 %335, %336
br i1 %337, label %338, label %351
338: ; preds = %334
%339 = load i32*, i32** %13
%340 = load i32, i32* %25
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %339, i64 %341
%343 = load i32, i32* %342
%344 = load i32*, i32** %18
%345 = load i32, i32* %25
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32, i32* %344, i64 %346
store i32 %343, i32* %347
br label %348
348: ; preds = %338
%349 = load i32, i32* %25
%350 = add nsw i32 %349, 1
store i32 %350, i32* %25
br label %334
351: ; preds = %334
%352 = load i32*, i32** %13
%353 = load i32, i32* %10
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i32, i32* %352, i64 %354
%356 = load i32, i32* %355
store i32 %356, i32* %27
%357 = load i32, i32* %27
%358 = sdiv i32 %357, 2
store i32 %358, i32* %22
%359 = load i32, i32* %27
%360 = load i32, i32* %22
%361 = load i32, i32* %10
%362 = call i32 @colamd_recommended(i32 %359, i32 %360, i32 %361)
store i32 %362, i32* %21
%363 = load i8* (i64, i64)*, i8* (i64, i64)** %16
%364 = load i32, i32* %21
%365 = sext i32 %364 to i64
%366 = call i8* %363(i64 %365, i64 4)
%367 = bitcast i8* %366 to i32*
store i32* %367, i32** %20
%368 = load i32*, i32** %20
%369 = icmp ne i32* %368, null
br i1 %369, label %379, label %370
370: ; preds = %351
%371 = load i32*, i32** %15
%372 = getelementptr inbounds i32, i32* %371, i64 3
store i32 -10, i32* %372
%373 = load void (i8*)*, void (i8*)** %17
%374 = load i32*, i32** %18
%375 = bitcast i32* %374 to i8*
%376 = load void (i8*)*, void (i8*)** %17
%377 = load i32*, i32** %19
%378 = bitcast i32* %377 to i8*
store i32 0, i32* %9
br label %607
379: ; preds = %351
store i32 0, i32* %26
%380 = load i32*, i32** %15
%381 = getelementptr inbounds i32, i32* %380, i64 3
%382 = load i32, i32* %381
%383 = icmp eq i32 %382, 0
br i1 %383, label %384, label %445
384: ; preds = %379
store i32 0, i32* %25
br label %385
385: ; preds = %441, %384
%386 = load i32, i32* %25
%387 = load i32, i32* %10
%388 = icmp slt i32 %386, %387
br i1 %388, label %389, label %444
389: ; preds = %385
%390 = load i32*, i32** %12
%391 = load i32, i32* %25
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds i32, i32* %390, i64 %392
%394 = load i32, i32* %393
store i32 %394, i32* %28
br label %395
395: ; preds = %437, %389
%396 = load i32, i32* %28
%397 = load i32*, i32** %12
%398 = load i32, i32* %25
%399 = add nsw i32 %398, 1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i32, i32* %397, i64 %400
%402 = load i32, i32* %401
%403 = icmp slt i32 %396, %402
br i1 %403, label %404, label %440
404: ; preds = %395
%405 = load i32*, i32** %11
%406 = load i32, i32* %28
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %405, i64 %407
%409 = load i32, i32* %408
store i32 %409, i32* %24
%410 = load i32, i32* %24
%411 = load i32, i32* %25
%412 = icmp sgt i32 %410, %411
br i1 %412, label %413, label %436
413: ; preds = %404
%414 = load i32, i32* %26
%415 = load i32*, i32** %20
%416 = load i32*, i32** %18
%417 = load i32, i32* %24
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i32, i32* %416, i64 %418
%420 = load i32, i32* %419
%421 = add nsw i32 %420, 1
store i32 %421, i32* %419
%422 = sext i32 %420 to i64
%423 = getelementptr inbounds i32, i32* %415, i64 %422
store i32 %414, i32* %423
%424 = load i32, i32* %26
%425 = load i32*, i32** %20
%426 = load i32*, i32** %18
%427 = load i32, i32* %25
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds i32, i32* %426, i64 %428
%430 = load i32, i32* %429
%431 = add nsw i32 %430, 1
store i32 %431, i32* %429
%432 = sext i32 %430 to i64
%433 = getelementptr inbounds i32, i32* %425, i64 %432
store i32 %424, i32* %433
%434 = load i32, i32* %26
%435 = add nsw i32 %434, 1
store i32 %435, i32* %26
br label %436
436: ; preds = %413, %404
br label %437
437: ; preds = %436
%438 = load i32, i32* %28
%439 = add nsw i32 %438, 1
store i32 %439, i32* %28
br label %395
440: ; preds = %395
br label %441
441: ; preds = %440
%442 = load i32, i32* %25
%443 = add nsw i32 %442, 1
store i32 %443, i32* %25
br label %385
444: ; preds = %385
br label %535
445: ; preds = %379
store i32 0, i32* %24
br label %446
446: ; preds = %455, %445
%447 = load i32, i32* %24
%448 = load i32, i32* %10
%449 = icmp slt i32 %447, %448
br i1 %449, label %450, label %458
450: ; preds = %446
%451 = load i32*, i32** %19
%452 = load i32, i32* %24
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds i32, i32* %451, i64 %453
store i32 -1, i32* %454
br label %455
455: ; preds = %450
%456 = load i32, i32* %24
%457 = add nsw i32 %456, 1
store i32 %457, i32* %24
br label %446
458: ; preds = %446
store i32 0, i32* %25
br label %459
459: ; preds = %528, %458
%460 = load i32, i32* %25
%461 = load i32, i32* %10
%462 = icmp slt i32 %460, %461
br i1 %462, label %463, label %531
463: ; preds = %459
%464 = load i32*, i32** %12
%465 = load i32, i32* %25
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds i32, i32* %464, i64 %466
%468 = load i32, i32* %467
store i32 %468, i32* %28
br label %469
469: ; preds = %524, %463
%470 = load i32, i32* %28
%471 = load i32*, i32** %12
%472 = load i32, i32* %25
%473 = add nsw i32 %472, 1
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i32, i32* %471, i64 %474
%476 = load i32, i32* %475
%477 = icmp slt i32 %470, %476
br i1 %477, label %478, label %527
478: ; preds = %469
%479 = load i32*, i32** %11
%480 = load i32, i32* %28
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i32, i32* %479, i64 %481
%483 = load i32, i32* %482
store i32 %483, i32* %24
%484 = load i32, i32* %24
%485 = load i32, i32* %25
%486 = icmp sgt i32 %484, %485
br i1 %486, label %487, label %523
487: ; preds = %478
%488 = load i32*, i32** %19
%489 = load i32, i32* %24
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds i32, i32* %488, i64 %490
%492 = load i32, i32* %491
%493 = load i32, i32* %25
%494 = icmp ne i32 %492, %493
br i1 %494, label %495, label %523
495: ; preds = %487
%496 = load i32, i32* %26
%497 = load i32*, i32** %20
%498 = load i32*, i32** %18
%499 = load i32, i32* %24
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds i32, i32* %498, i64 %500
%502 = load i32, i32* %501
%503 = add nsw i32 %502, 1
store i32 %503, i32* %501
%504 = sext i32 %502 to i64
%505 = getelementptr inbounds i32, i32* %497, i64 %504
store i32 %496, i32* %505
%506 = load i32, i32* %26
%507 = load i32*, i32** %20
%508 = load i32*, i32** %18
%509 = load i32, i32* %25
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds i32, i32* %508, i64 %510
%512 = load i32, i32* %511
%513 = add nsw i32 %512, 1
store i32 %513, i32* %511
%514 = sext i32 %512 to i64
%515 = getelementptr inbounds i32, i32* %507, i64 %514
store i32 %506, i32* %515
%516 = load i32, i32* %26
%517 = add nsw i32 %516, 1
store i32 %517, i32* %26
%518 = load i32, i32* %25
%519 = load i32*, i32** %19
%520 = load i32, i32* %24
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds i32, i32* %519, i64 %521
store i32 %518, i32* %522
br label %523
523: ; preds = %495, %487, %478
br label %524
524: ; preds = %523
%525 = load i32, i32* %28
%526 = add nsw i32 %525, 1
store i32 %526, i32* %28
br label %469
527: ; preds = %469
br label %528
528: ; preds = %527
%529 = load i32, i32* %25
%530 = add nsw i32 %529, 1
store i32 %530, i32* %25
br label %459
531: ; preds = %459
%532 = load void (i8*)*, void (i8*)** %17
%533 = load i32*, i32** %19
%534 = bitcast i32* %533 to i8*
br label %535
535: ; preds = %531, %444
%536 = load void (i8*)*, void (i8*)** %17
%537 = load i32*, i32** %18
%538 = bitcast i32* %537 to i8*
store i32 0, i32* %24
br label %539
539: ; preds = %551, %535
%540 = load i32, i32* %24
%541 = icmp slt i32 %540, 20
br i1 %541, label %542, label %554
542: ; preds = %539
%543 = load double*, double** %14
%544 = load i32, i32* %24
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %543, i64 %545
%547 = load double, double* %546
%548 = load i32, i32* %24
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds [20 x double], [20 x double]* %31, i64 0, i64 %549
store double %547, double* %550
br label %551
551: ; preds = %542
%552 = load i32, i32* %24
%553 = add nsw i32 %552, 1
store i32 %553, i32* %24
br label %539
554: ; preds = %539
%555 = getelementptr inbounds [20 x double], [20 x double]* %31, i64 0, i64 0
store double 1.000000e+00, double* %555
%556 = load i32, i32* %22
%557 = icmp ne i32 %556, 0
br i1 %557, label %558, label %573
558: ; preds = %554
%559 = load i32, i32* %10
%560 = load i32, i32* %22
%561 = icmp slt i32 %559, %560
br i1 %561, label %562, label %573
562: ; preds = %558
%563 = load double*, double** %14
%564 = getelementptr inbounds double, double* %563, i64 0
%565 = load double, double* %564
%566 = load i32, i32* %10
%567 = sitofp i32 %566 to double
%568 = fmul double %565, %567
%569 = load i32, i32* %22
%570 = sitofp i32 %569 to double
%571 = fdiv double %568, %570
%572 = getelementptr inbounds [20 x double], [20 x double]* %31, i64 0, i64 1
store double %571, double* %572
br label %575
573: ; preds = %558, %554
%574 = getelementptr inbounds [20 x double], [20 x double]* %31, i64 0, i64 1
store double 1.000000e+00, double* %574
br label %575
575: ; preds = %573, %562
%576 = load i32, i32* %22
%577 = load i32, i32* %10
%578 = load i32, i32* %21
%579 = load i32*, i32** %20
%580 = load i32*, i32** %13
%581 = getelementptr inbounds [20 x double], [20 x double]* %31, i64 0, i64 0
%582 = getelementptr inbounds [20 x i32], [20 x i32]* %33, i64 0, i64 0
%583 = call i32 @colamd(i32 %576, i32 %577, i32 %578, i32* %579, i32* %580, double* %581, i32* %582)
%584 = icmp ne i32 %583, 0
br i1 %584, label %591, label %585
585: ; preds = %575
%586 = load i32*, i32** %15
%587 = getelementptr inbounds i32, i32* %586, i64 3
store i32 -999, i32* %587
%588 = load void (i8*)*, void (i8*)** %17
%589 = load i32*, i32** %20
%590 = bitcast i32* %589 to i8*
store i32 0, i32* %9
br label %607
591: ; preds = %575
%592 = getelementptr inbounds [20 x i32], [20 x i32]* %33, i64 0, i64 1
%593 = load i32, i32* %592
%594 = load i32*, i32** %15
%595 = getelementptr inbounds i32, i32* %594, i64 0
store i32 %593, i32* %595
%596 = getelementptr inbounds [20 x i32], [20 x i32]* %33, i64 0, i64 1
%597 = load i32, i32* %596
%598 = load i32*, i32** %15
%599 = getelementptr inbounds i32, i32* %598, i64 1
store i32 %597, i32* %599
%600 = getelementptr inbounds [20 x i32], [20 x i32]* %33, i64 0, i64 2
%601 = load i32, i32* %600
%602 = load i32*, i32** %15
%603 = getelementptr inbounds i32, i32* %602, i64 2
store i32 %601, i32* %603
%604 = load void (i8*)*, void (i8*)** %17
%605 = load i32*, i32** %20
%606 = bitcast i32* %605 to i8*
store i32 1, i32* %9
br label %607
607: ; preds = %591, %585, %370, %214, %172, %131, %119, %95, %84, %70, %64, %58, %36
%608 = load i32, i32* %9
ret i32 %608
}

LLVM IR (-O2):
define i32 @symamd(i32 %0, i32* %1, i32* %2, i32* %3, double* %4, i32* %5, i8* (i64, i64)* nocapture %6, void (i8*)* nocapture %7) {
%9 = alloca [20 x double]
%10 = bitcast [20 x double]* %9 to i8*
%11 = alloca [20 x double]
%12 = alloca [20 x i32]
%13 = bitcast [20 x double]* %11 to i8*
%14 = bitcast [20 x i32]* %12 to i8*
%15 = icmp eq i32* %5, null
br i1 %15, label %455, label %16
16: ; preds = %8
%17 = getelementptr inbounds i32, i32* %5, i64 3
%18 = getelementptr inbounds i32, i32* %5, i64 4
%19 = bitcast i32* %5 to i8*
store i32 -1, i32* %18
%20 = getelementptr inbounds i32, i32* %5, i64 5
store i32 -1, i32* %20
%21 = icmp eq i32* %1, null
br i1 %21, label %22, label %23
22: ; preds = %16
store i32 -1, i32* %17
br label %455
23: ; preds = %16
%24 = icmp eq i32* %2, null
br i1 %24, label %25, label %26
25: ; preds = %23
store i32 -2, i32* %17
br label %455
26: ; preds = %23
%27 = icmp slt i32 %0, 0
br i1 %27, label %28, label %29
28: ; preds = %26
store i32 -4, i32* %17
store i32 %0, i32* %18
br label %455
29: ; preds = %26
%30 = zext i32 %0 to i64
%31 = getelementptr inbounds i32, i32* %2, i64 %30
%32 = load i32, i32* %31
%33 = icmp slt i32 %32, 0
br i1 %33, label %34, label %35
34: ; preds = %29
store i32 -5, i32* %17
store i32 %32, i32* %18
br label %455
35: ; preds = %29
%36 = load i32, i32* %2
%37 = icmp eq i32 %36, 0
br i1 %37, label %40, label %38
38: ; preds = %35
store i32 -6, i32* %17
%39 = load i32, i32* %2
store i32 %39, i32* %18
br label %455
40: ; preds = %35
%41 = icmp eq double* %4, null
br i1 %41, label %42, label %45
42: ; preds = %40
%43 = getelementptr inbounds [20 x double], [20 x double]* %11, i64 0, i64 0
%44 = call i32 @colamd_set_defaults(double* %43)
br label %45
45: ; preds = %42, %40
%46 = phi double* [ %4, %40 ], [ %43, %42 ]
%47 = bitcast double* %46 to i8*
%48 = add nuw i32 %0, 1
%49 = zext i32 %48 to i64
%50 = call i8* %6(i64 %49, i64 4)
%51 = bitcast i8* %50 to i32*
%52 = icmp eq i8* %50, null
br i1 %52, label %53, label %54
53: ; preds = %45
store i32 -10, i32* %17
br label %455
54: ; preds = %45
%55 = call i8* %6(i64 %49, i64 4)
%56 = bitcast i8* %55 to i32*
%57 = icmp eq i8* %55, null
br i1 %57, label %58, label %59
58: ; preds = %54
store i32 -10, i32* %17
br label %455
59: ; preds = %54
%60 = getelementptr inbounds i32, i32* %5, i64 6
store i32 0, i32* %60
%61 = icmp eq i32 %0, 0
br i1 %61, label %127, label %62
62: ; preds = %59
%63 = shl nuw nsw i64 %30, 2
%64 = load i32, i32* %2
br label %68
65: ; preds = %121, %76
%66 = phi i32 [ %73, %76 ], [ %124, %121 ]
%67 = icmp eq i64 %71, %30
br i1 %67, label %127, label %68
68: ; preds = %62, %65
%69 = phi i32 [ %64, %62 ], [ %66, %65 ]
%70 = phi i64 [ 0, %62 ], [ %71, %65 ]
%71 = add nuw nsw i64 %70, 1
%72 = getelementptr inbounds i32, i32* %2, i64 %71
%73 = load i32, i32* %72
%74 = sub nsw i32 %73, %69
%75 = icmp slt i32 %74, 0
br i1 %75, label %83, label %76
76: ; preds = %68
%77 = icmp sgt i32 %73, %69
br i1 %77, label %78, label %65
78: ; preds = %76
%79 = getelementptr inbounds i32, i32* %51, i64 %70
%80 = sext i32 %69 to i64
%81 = trunc i64 %70 to i32
%82 = trunc i64 %70 to i32
br label %85
83: ; preds = %68
%84 = trunc i64 %70 to i32
store i32 -8, i32* %17
store i32 %84, i32* %18
store i32 %74, i32* %20
br label %455
85: ; preds = %78, %121
%86 = phi i64 [ %80, %78 ], [ %123, %121 ]
%87 = phi i32 [ -1, %78 ], [ %89, %121 ]
%88 = getelementptr inbounds i32, i32* %1, i64 %86
%89 = load i32, i32* %88
%90 = icmp sgt i32 %89, -1
%91 = icmp slt i32 %89, %0
%92 = and i1 %90, %91
br i1 %92, label %95, label %93
93: ; preds = %85
%94 = trunc i64 %70 to i32
store i32 -9, i32* %17
store i32 %94, i32* %18
store i32 %89, i32* %20
store i32 %0, i32* %60
br label %455
95: ; preds = %85
%96 = icmp sgt i32 %89, %87
br i1 %96, label %97, label %103
97: ; preds = %95
%98 = zext i32 %89 to i64
%99 = getelementptr inbounds i32, i32* %56, i64 %98
%100 = load i32, i32* %99
%101 = zext i32 %100 to i64
%102 = icmp eq i64 %70, %101
br i1 %102, label %103, label %106
103: ; preds = %97, %95
store i32 1, i32* %17
store i32 %81, i32* %18
store i32 %89, i32* %20
%104 = load i32, i32* %60
%105 = add nsw i32 %104, 1
store i32 %105, i32* %60
br label %106
106: ; preds = %103, %97
%107 = zext i32 %89 to i64
%108 = icmp ult i64 %70, %107
%109 = zext i32 %89 to i64
br i1 %108, label %110, label %121
110: ; preds = %106
%111 = getelementptr inbounds i32, i32* %56, i64 %109
%112 = load i32, i32* %111
%113 = zext i32 %112 to i64
%114 = icmp eq i64 %70, %113
br i1 %114, label %121, label %115
115: ; preds = %110
%116 = getelementptr inbounds i32, i32* %51, i64 %109
%117 = load i32, i32* %116
%118 = add nsw i32 %117, 1
store i32 %118, i32* %116
%119 = load i32, i32* %79
%120 = add nsw i32 %119, 1
store i32 %120, i32* %79
br label %121
121: ; preds = %106, %115, %110
%122 = getelementptr inbounds i32, i32* %56, i64 %109
store i32 %82, i32* %122
%123 = add nsw i64 %86, 1
%124 = load i32, i32* %72
%125 = sext i32 %124 to i64
%126 = icmp slt i64 %123, %125
br i1 %126, label %85, label %65
127: ; preds = %65, %59
%128 = load i32, i32* %17
%129 = icmp eq i32 %128, 0
br i1 %129, label %130, label %131
130: ; preds = %127
br label %131
131: ; preds = %130, %127
store i32 0, i32* %3
%132 = icmp slt i32 %0, 1
br i1 %132, label %156, label %133
133: ; preds = %131
%134 = add nsw i64 %49, -1
%135 = add nsw i64 %49, -2
%136 = and i64 %134, 3
%137 = icmp ult i64 %135, 3
br i1 %137, label %140, label %138
138: ; preds = %133
%139 = and i64 %134, -4
br label %274
140: ; preds = %274, %133
%141 = phi i32 [ 0, %133 ], [ %296, %274 ]
%142 = phi i64 [ 1, %133 ], [ %298, %274 ]
%143 = icmp eq i64 %136, 0
br i1 %143, label %156, label %144
144: ; preds = %140, %144
%145 = phi i32 [ %151, %144 ], [ %141, %140 ]
%146 = phi i64 [ %153, %144 ], [ %142, %140 ]
%147 = phi i64 [ %154, %144 ], [ 0, %140 ]
%148 = add nsw i64 %146, -1
%149 = getelementptr inbounds i32, i32* %51, i64 %148
%150 = load i32, i32* %149
%151 = add nsw i32 %150, %145
%152 = getelementptr inbounds i32, i32* %3, i64 %146
store i32 %151, i32* %152
%153 = add nuw nsw i64 %146, 1
%154 = add i64 %147, 1
%155 = icmp eq i64 %154, %136
br i1 %155, label %156, label %144
156: ; preds = %140, %144, %131
br i1 %61, label %320, label %157
157: ; preds = %156
store i32 0, i32* %51
%158 = icmp eq i32 %0, 1
br i1 %158, label %320, label %159
159: ; preds = %157
%160 = add nsw i64 %30, -1
%161 = icmp ult i64 %160, 8
br i1 %161, label %255, label %162
162: ; preds = %159
%163 = getelementptr i8, i8* %50, i64 4
%164 = shl nuw nsw i64 %30, 2
%165 = getelementptr i8, i8* %50, i64 %164
%166 = getelementptr i32, i32* %3, i64 1
%167 = bitcast i32* %166 to i8*
%168 = getelementptr i32, i32* %3, i64 %30
%169 = bitcast i32* %168 to i8*
%170 = icmp ult i8* %163, %169
%171 = icmp ugt i8* %165, %167
%172 = and i1 %170, %171
br i1 %172, label %255, label %173
173: ; preds = %162
%174 = and i64 %160, -8
%175 = or i64 %174, 1
%176 = add nsw i64 %174, -8
%177 = lshr exact i64 %176, 3
%178 = add nuw nsw i64 %177, 1
%179 = and i64 %178, 3
%180 = icmp ult i64 %176, 24
br i1 %180, label %233, label %181
181: ; preds = %173
%182 = and i64 %178, 4611686018427387900
br label %183
183: ; preds = %183, %181
%184 = phi i64 [ 0, %181 ], [ %230, %183 ]
%185 = phi i64 [ 0, %181 ], [ %231, %183 ]
%186 = or i64 %184, 1
%187 = getelementptr inbounds i32, i32* %3, i64 %186
%188 = bitcast i32* %187 to <4 x i32>*
%189 = load <4 x i32>, <4 x i32>* %188
%190 = getelementptr inbounds i32, i32* %187, i64 4
%191 = bitcast i32* %190 to <4 x i32>*
%192 = load <4 x i32>, <4 x i32>* %191
%193 = getelementptr inbounds i32, i32* %51, i64 %186
%194 = bitcast i32* %193 to <4 x i32>*
store <4 x i32> %189, <4 x i32>* %194
%195 = getelementptr inbounds i32, i32* %193, i64 4
%196 = bitcast i32* %195 to <4 x i32>*
store <4 x i32> %192, <4 x i32>* %196
%197 = or i64 %184, 9
%198 = getelementptr inbounds i32, i32* %3, i64 %197
%199 = bitcast i32* %198 to <4 x i32>*
%200 = load <4 x i32>, <4 x i32>* %199
%201 = getelementptr inbounds i32, i32* %198, i64 4
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = getelementptr inbounds i32, i32* %51, i64 %197
%205 = bitcast i32* %204 to <4 x i32>*
store <4 x i32> %200, <4 x i32>* %205
%206 = getelementptr inbounds i32, i32* %204, i64 4
%207 = bitcast i32* %206 to <4 x i32>*
store <4 x i32> %203, <4 x i32>* %207
%208 = or i64 %184, 17
%209 = getelementptr inbounds i32, i32* %3, i64 %208
%210 = bitcast i32* %209 to <4 x i32>*
%211 = load <4 x i32>, <4 x i32>* %210
%212 = getelementptr inbounds i32, i32* %209, i64 4
%213 = bitcast i32* %212 to <4 x i32>*
%214 = load <4 x i32>, <4 x i32>* %213
%215 = getelementptr inbounds i32, i32* %51, i64 %208
%216 = bitcast i32* %215 to <4 x i32>*
store <4 x i32> %211, <4 x i32>* %216
%217 = getelementptr inbounds i32, i32* %215, i64 4
%218 = bitcast i32* %217 to <4 x i32>*
store <4 x i32> %214, <4 x i32>* %218
%219 = or i64 %184, 25
%220 = getelementptr inbounds i32, i32* %3, i64 %219
%221 = bitcast i32* %220 to <4 x i32>*
%222 = load <4 x i32>, <4 x i32>* %221
%223 = getelementptr inbounds i32, i32* %220, i64 4
%224 = bitcast i32* %223 to <4 x i32>*
%225 = load <4 x i32>, <4 x i32>* %224
%226 = getelementptr inbounds i32, i32* %51, i64 %219
%227 = bitcast i32* %226 to <4 x i32>*
store <4 x i32> %222, <4 x i32>* %227
%228 = getelementptr inbounds i32, i32* %226, i64 4
%229 = bitcast i32* %228 to <4 x i32>*
store <4 x i32> %225, <4 x i32>* %229
%230 = add nuw i64 %184, 32
%231 = add i64 %185, 4
%232 = icmp eq i64 %231, %182
br i1 %232, label %233, label %183
233: ; preds = %183, %173
%234 = phi i64 [ 0, %173 ], [ %230, %183 ]
%235 = icmp eq i64 %179, 0
br i1 %235, label %253, label %236
236: ; preds = %233, %236
%237 = phi i64 [ %250, %236 ], [ %234, %233 ]
%238 = phi i64 [ %251, %236 ], [ 0, %233 ]
%239 = or i64 %237, 1
%240 = getelementptr inbounds i32, i32* %3, i64 %239
%241 = bitcast i32* %240 to <4 x i32>*
%242 = load <4 x i32>, <4 x i32>* %241
%243 = getelementptr inbounds i32, i32* %240, i64 4
%244 = bitcast i32* %243 to <4 x i32>*
%245 = load <4 x i32>, <4 x i32>* %244
%246 = getelementptr inbounds i32, i32* %51, i64 %239
%247 = bitcast i32* %246 to <4 x i32>*
store <4 x i32> %242, <4 x i32>* %247
%248 = getelementptr inbounds i32, i32* %246, i64 4
%249 = bitcast i32* %248 to <4 x i32>*
store <4 x i32> %245, <4 x i32>* %249
%250 = add nuw i64 %237, 8
%251 = add i64 %238, 1
%252 = icmp eq i64 %251, %179
br i1 %252, label %253, label %236
253: ; preds = %236, %233
%254 = icmp eq i64 %160, %174
br i1 %254, label %320, label %255
255: ; preds = %162, %159, %253
%256 = phi i64 [ 1, %162 ], [ 1, %159 ], [ %175, %253 ]
%257 = sub nsw i64 %30, %256
%258 = xor i64 %256, -1
%259 = add nsw i64 %258, %30
%260 = and i64 %257, 3
%261 = icmp eq i64 %260, 0
br i1 %261, label %271, label %262
262: ; preds = %255, %262
%263 = phi i64 [ %268, %262 ], [ %256, %255 ]
%264 = phi i64 [ %269, %262 ], [ 0, %255 ]
%265 = getelementptr inbounds i32, i32* %3, i64 %263
%266 = load i32, i32* %265
%267 = getelementptr inbounds i32, i32* %51, i64 %263
store i32 %266, i32* %267
%268 = add nuw nsw i64 %263, 1
%269 = add i64 %264, 1
%270 = icmp eq i64 %269, %260
br i1 %270, label %271, label %262
271: ; preds = %262, %255
%272 = phi i64 [ %256, %255 ], [ %268, %262 ]
%273 = icmp ult i64 %259, 3
br i1 %273, label %320, label %301
274: ; preds = %274, %138
%275 = phi i32 [ 0, %138 ], [ %296, %274 ]
%276 = phi i64 [ 1, %138 ], [ %298, %274 ]
%277 = phi i64 [ 0, %138 ], [ %299, %274 ]
%278 = add nsw i64 %276, -1
%279 = getelementptr inbounds i32, i32* %51, i64 %278
%280 = load i32, i32* %279
%281 = add nsw i32 %280, %275
%282 = getelementptr inbounds i32, i32* %3, i64 %276
store i32 %281, i32* %282
%283 = add nuw nsw i64 %276, 1
%284 = getelementptr inbounds i32, i32* %51, i64 %276
%285 = load i32, i32* %284
%286 = add nsw i32 %285, %281
%287 = getelementptr inbounds i32, i32* %3, i64 %283
store i32 %286, i32* %287
%288 = add nuw nsw i64 %276, 2
%289 = getelementptr inbounds i32, i32* %51, i64 %283
%290 = load i32, i32* %289
%291 = add nsw i32 %290, %286
%292 = getelementptr inbounds i32, i32* %3, i64 %288
store i32 %291, i32* %292
%293 = add nuw nsw i64 %276, 3
%294 = getelementptr inbounds i32, i32* %51, i64 %288
%295 = load i32, i32* %294
%296 = add nsw i32 %295, %291
%297 = getelementptr inbounds i32, i32* %3, i64 %293
store i32 %296, i32* %297
%298 = add nuw nsw i64 %276, 4
%299 = add nuw i64 %277, 4
%300 = icmp eq i64 %299, %139
br i1 %300, label %140, label %274
301: ; preds = %271, %301
%302 = phi i64 [ %318, %301 ], [ %272, %271 ]
%303 = getelementptr inbounds i32, i32* %3, i64 %302
%304 = load i32, i32* %303
%305 = getelementptr inbounds i32, i32* %51, i64 %302
store i32 %304, i32* %305
%306 = add nuw nsw i64 %302, 1
%307 = getelementptr inbounds i32, i32* %3, i64 %306
%308 = load i32, i32* %307
%309 = getelementptr inbounds i32, i32* %51, i64 %306
store i32 %308, i32* %309
%310 = add nuw nsw i64 %302, 2
%311 = getelementptr inbounds i32, i32* %3, i64 %310
%312 = load i32, i32* %311
%313 = getelementptr inbounds i32, i32* %51, i64 %310
store i32 %312, i32* %313
%314 = add nuw nsw i64 %302, 3
%315 = getelementptr inbounds i32, i32* %3, i64 %314
%316 = load i32, i32* %315
%317 = getelementptr inbounds i32, i32* %51, i64 %314
store i32 %316, i32* %317
%318 = add nuw nsw i64 %302, 4
%319 = icmp eq i64 %318, %30
br i1 %319, label %320, label %301
320: ; preds = %271, %301, %157, %253, %156
%321 = getelementptr inbounds i32, i32* %3, i64 %30
%322 = load i32, i32* %321
%323 = sdiv i32 %322, 2
%324 = call i32 @colamd_recommended(i32 %322, i32 %323, i32 %0)
%325 = sext i32 %324 to i64
%326 = call i8* %6(i64 %325, i64 4)
%327 = bitcast i8* %326 to i32*
%328 = icmp eq i8* %326, null
br i1 %328, label %329, label %330
329: ; preds = %320
store i32 -10, i32* %17
br label %455
330: ; preds = %320
%331 = load i32, i32* %17
%332 = icmp eq i32 %331, 0
br i1 %332, label %334, label %333
333: ; preds = %330
br i1 %61, label %428, label %378
334: ; preds = %330
br i1 %61, label %429, label %335
335: ; preds = %334
%336 = load i32, i32* %2
br label %341
337: ; preds = %372, %341
%338 = phi i32 [ %347, %341 ], [ %373, %372 ]
%339 = phi i32 [ %344, %341 ], [ %374, %372 ]
%340 = icmp eq i64 %345, %30
br i1 %340, label %429, label %341
341: ; preds = %335, %337
%342 = phi i32 [ %336, %335 ], [ %338, %337 ]
%343 = phi i64 [ 0, %335 ], [ %345, %337 ]
%344 = phi i32 [ 0, %335 ], [ %339, %337 ]
%345 = add nuw nsw i64 %343, 1
%346 = getelementptr inbounds i32, i32* %2, i64 %345
%347 = load i32, i32* %346
%348 = icmp slt i32 %342, %347
br i1 %348, label %349, label %337
349: ; preds = %341
%350 = getelementptr inbounds i32, i32* %51, i64 %343
%351 = sext i32 %342 to i64
br label %352
352: ; preds = %349, %372
%353 = phi i32 [ %347, %349 ], [ %373, %372 ]
%354 = phi i64 [ %351, %349 ], [ %375, %372 ]
%355 = phi i32 [ %344, %349 ], [ %374, %372 ]
%356 = getelementptr inbounds i32, i32* %1, i64 %354
%357 = load i32, i32* %356
%358 = sext i32 %357 to i64
%359 = icmp slt i64 %343, %358
br i1 %359, label %360, label %372
360: ; preds = %352
%361 = getelementptr inbounds i32, i32* %51, i64 %358
%362 = load i32, i32* %361
%363 = add nsw i32 %362, 1
store i32 %363, i32* %361
%364 = sext i32 %362 to i64
%365 = getelementptr inbounds i32, i32* %327, i64 %364
store i32 %355, i32* %365
%366 = load i32, i32* %350
%367 = add nsw i32 %366, 1
store i32 %367, i32* %350
%368 = sext i32 %366 to i64
%369 = getelementptr inbounds i32, i32* %327, i64 %368
store i32 %355, i32* %369
%370 = add nsw i32 %355, 1
%371 = load i32, i32* %346
br label %372
372: ; preds = %352, %360
%373 = phi i32 [ %371, %360 ], [ %353, %352 ]
%374 = phi i32 [ %370, %360 ], [ %355, %352 ]
%375 = add nsw i64 %354, 1
%376 = sext i32 %373 to i64
%377 = icmp slt i64 %375, %376
br i1 %377, label %352, label %337
378: ; preds = %333
%379 = shl nuw nsw i64 %30, 2
%380 = load i32, i32* %2
br label %385
381: ; preds = %422, %385
%382 = phi i32 [ %391, %385 ], [ %423, %422 ]
%383 = phi i32 [ %388, %385 ], [ %424, %422 ]
%384 = icmp eq i64 %389, %30
br i1 %384, label %428, label %385
385: ; preds = %378, %381
%386 = phi i32 [ %380, %378 ], [ %382, %381 ]
%387 = phi i64 [ 0, %378 ], [ %389, %381 ]
%388 = phi i32 [ 0, %378 ], [ %383, %381 ]
%389 = add nuw nsw i64 %387, 1
%390 = getelementptr inbounds i32, i32* %2, i64 %389
%391 = load i32, i32* %390
%392 = icmp slt i32 %386, %391
br i1 %392, label %393, label %381
393: ; preds = %385
%394 = getelementptr inbounds i32, i32* %51, i64 %387
%395 = sext i32 %386 to i64
%396 = trunc i64 %387 to i32
br label %397
397: ; preds = %393, %422
%398 = phi i32 [ %391, %393 ], [ %423, %422 ]
%399 = phi i64 [ %395, %393 ], [ %425, %422 ]
%400 = phi i32 [ %388, %393 ], [ %424, %422 ]
%401 = getelementptr inbounds i32, i32* %1, i64 %399
%402 = load i32, i32* %401
%403 = sext i32 %402 to i64
%404 = icmp slt i64 %387, %403
br i1 %404, label %405, label %422
405: ; preds = %397
%406 = getelementptr inbounds i32, i32* %56, i64 %403
%407 = load i32, i32* %406
%408 = zext i32 %407 to i64
%409 = icmp eq i64 %387, %408
br i1 %409, label %422, label %410
410: ; preds = %405
%411 = getelementptr inbounds i32, i32* %51, i64 %403
%412 = load i32, i32* %411
%413 = add nsw i32 %412, 1
store i32 %413, i32* %411
%414 = sext i32 %412 to i64
%415 = getelementptr inbounds i32, i32* %327, i64 %414
store i32 %400, i32* %415
%416 = load i32, i32* %394
%417 = add nsw i32 %416, 1
store i32 %417, i32* %394
%418 = sext i32 %416 to i64
%419 = getelementptr inbounds i32, i32* %327, i64 %418
store i32 %400, i32* %419
%420 = add nsw i32 %400, 1
store i32 %396, i32* %406
%421 = load i32, i32* %390
br label %422
422: ; preds = %397, %405, %410
%423 = phi i32 [ %421, %410 ], [ %398, %405 ], [ %398, %397 ]
%424 = phi i32 [ %420, %410 ], [ %400, %405 ], [ %400, %397 ]
%425 = add nsw i64 %399, 1
%426 = sext i32 %423 to i64
%427 = icmp slt i64 %425, %426
br i1 %427, label %397, label %381
428: ; preds = %381, %333
br label %429
429: ; preds = %337, %334, %428
%430 = getelementptr inbounds [20 x double], [20 x double]* %9, i64 0, i64 0
store double 1.000000e+00, double* %430
%431 = add i32 %322, -2
%432 = icmp ult i32 %431, -3
%433 = icmp sgt i32 %323, %0
%434 = and i1 %432, %433
br i1 %434, label %435, label %441
435: ; preds = %429
%436 = load double, double* %46
%437 = sitofp i32 %0 to double
%438 = fmul double %436, %437
%439 = sitofp i32 %323 to double
%440 = fdiv double %438, %439
br label %441
441: ; preds = %429, %435
%442 = phi double [ %440, %435 ], [ 1.000000e+00, %429 ]
%443 = getelementptr inbounds [20 x double], [20 x double]* %9, i64 0, i64 1
store double %442, double* %443
%444 = getelementptr inbounds [20 x i32], [20 x i32]* %12, i64 0, i64 0
%445 = call i32 @colamd(i32 %323, i32 %0, i32 %324, i32* %327, i32* %3, double* %430, i32* %444)
%446 = icmp eq i32 %445, 0
br i1 %446, label %447, label %448
447: ; preds = %441
store i32 -999, i32* %17
br label %455
448: ; preds = %441
%449 = getelementptr inbounds [20 x i32], [20 x i32]* %12, i64 0, i64 1
%450 = load i32, i32* %449
store i32 %450, i32* %5
%451 = getelementptr inbounds i32, i32* %5, i64 1
store i32 %450, i32* %451
%452 = getelementptr inbounds [20 x i32], [20 x i32]* %12, i64 0, i64 2
%453 = load i32, i32* %452
%454 = getelementptr inbounds i32, i32* %5, i64 2
store i32 %453, i32* %454
br label %455
455: ; preds = %8, %448, %447, %329, %93, %83, %58, %53, %38, %34, %28, %25, %22
%456 = phi i32 [ 0, %28 ], [ 0, %34 ], [ 0, %38 ], [ 0, %83 ], [ 0, %93 ], [ 1, %448 ], [ 0, %447 ], [ 0, %329 ], [ 0, %58 ], [ 0, %53 ], [ 0, %25 ], [ 0, %22 ], [ 0, %8 ]
ret i32 %456
}