int matinv(n, mat, inv) const int n;
const double mat[];
double inv[];
{
  register int i, ij, ik, j, k, kj, pj;
  int itemp, mem, *mxl, *lxm, pivot;
  double colmax, *lu, *rowmax, dtemp;
  mem = n * sizeof(int);
  if ((mxl = (int *)malloc(mem)) == (int *)0)
    return 1;
  if ((lxm = (int *)malloc(mem)) == (int *)0) {
    free(mxl);
    return 1;
  }
  mem = n * sizeof(double);
  if ((rowmax = (double *)malloc(mem)) == (double *)0) {
    free(mxl);
    free(lxm);
    return 1;
  }
  mem *= n;
  if ((lu = (double *)malloc(mem)) == (double *)0) {
    free(mxl);
    free(lxm);
    free(rowmax);
    return 1;
  }
  for (i = 0, ij = 0; i < n; i++) {
    mxl[i] = i;
    rowmax[i] = 0.0;
    for (j = 0; j < n; j++, ij++) {
      dtemp = fabs(mat[ij]);
      if (dtemp > rowmax[i])
        rowmax[i] = dtemp;
      lu[ij] = mat[ij];
    }
    if (rowmax[i] == 0.0) {
      free(mxl);
      free(lxm);
      free(rowmax);
      free(lu);
      return 2;
    }
  }
  for (k = 0; k < n; k++) {
    colmax = fabs(lu[k * n + k]) / rowmax[k];
    pivot = k;
    for (i = k + 1; i < n; i++) {
      ik = i * n + k;
      dtemp = fabs(lu[ik]) / rowmax[i];
      if (dtemp > colmax) {
        colmax = dtemp;
        pivot = i;
      }
    }
    if (pivot > k) {
      for (j = 0, pj = pivot * n, kj = k * n; j < n; j++, pj++, kj++) {
        dtemp = lu[pj];
        lu[pj] = lu[kj];
        lu[kj] = dtemp;
      }
      dtemp = rowmax[pivot];
      rowmax[pivot] = rowmax[k];
      rowmax[k] = dtemp;
      itemp = mxl[pivot];
      mxl[pivot] = mxl[k];
      mxl[k] = itemp;
    }
    for (i = k + 1; i < n; i++) {
      ik = i * n + k;
      if (lu[ik] != 0.0) {
        lu[ik] /= lu[k * n + k];
        for (j = k + 1; j < n; j++) {
          lu[i * n + j] -= lu[ik] * lu[k * n + j];
        }
      }
    }
  }
  for (i = 0; i < n; i++) {
    lxm[mxl[i]] = i;
  }
  for (i = 0, ij = 0; i < n; i++) {
    for (j = 0; j < n; j++, ij++) {
      inv[ij] = 0.0;
    }
  }
  for (k = 0; k < n; k++) {
    inv[lxm[k] * n + k] = 1.0;
    for (i = lxm[k] + 1; i < n; i++) {
      for (j = lxm[k]; j < i; j++) {
        inv[i * n + k] -= lu[i * n + j] * inv[j * n + k];
      }
    }
    for (i = n - 1; i >= 0; i--) {
      for (j = i + 1; j < n; j++) {
        inv[i * n + k] -= lu[i * n + j] * inv[j * n + k];
      }
      inv[i * n + k] /= lu[i * n + i];
    }
  }
  free(mxl);
  free(lxm);
  free(rowmax);
  free(lu);
  return 0;
}


x86 assembly (clang, -O0):
<matinv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %eax,-0x3c(%rbp)
movslq -0x3c(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    1164 <matinv+0x44>
movl   $0x1,-0x4(%rbp)
jmp    18da <matinv+0x7ba>
movslq -0x3c(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmp    $0x0,%rax
jne    1190 <matinv+0x70>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    18da <matinv+0x7ba>
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,-0x3c(%rbp)
movslq -0x3c(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmp    $0x0,%rax
jne    11d0 <matinv+0xb0>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    18da <matinv+0x7ba>
mov    -0x8(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movslq -0x3c(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
jne    1218 <matinv+0xf8>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    18da <matinv+0x7ba>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    133e <matinv+0x21e>
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12db <matinv+0x1bb>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd99(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    12aa <matinv+0x18a>
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1257 <matinv+0x137>
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    132b <matinv+0x20b>
jp     132b <matinv+0x20b>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0x2,-0x4(%rbp)
jmp    18da <matinv+0x7ba>
jmp    1330 <matinv+0x210>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1226 <matinv+0x106>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1628 <matinv+0x508>
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xca2(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1409 <matinv+0x2e9>
mov    -0x1c(%rbp),%eax
imul   -0x8(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc50(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    13f6 <matinv+0x2d6>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    13fb <matinv+0x2db>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1393 <matinv+0x273>
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    150a <matinv+0x3ea>
movl   $0x0,-0x28(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    149a <matinv+0x37a>
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1430 <matinv+0x310>
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1615 <matinv+0x4f5>
mov    -0x1c(%rbp),%eax
imul   -0x8(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1551 <matinv+0x431>
jp     1551 <matinv+0x431>
jmp    1602 <matinv+0x4e2>
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15fd <matinv+0x4dd>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1586 <matinv+0x466>
jmp    1602 <matinv+0x4e2>
jmp    1607 <matinv+0x4e7>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1513 <matinv+0x3f3>
jmp    161a <matinv+0x4fa>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1345 <matinv+0x225>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    165f <matinv+0x53f>
mov    -0x1c(%rbp),%edx
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x1c(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    162f <matinv+0x50f>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16c6 <matinv+0x5a6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16b3 <matinv+0x593>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1680 <matinv+0x560>
jmp    16b8 <matinv+0x598>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    166d <matinv+0x54d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18af <matinv+0x78f>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x906(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17bd <matinv+0x69d>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    17aa <matinv+0x68a>
mov    -0x68(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    172a <matinv+0x60a>
jmp    17af <matinv+0x68f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1710 <matinv+0x5f0>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     189c <matinv+0x77c>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1859 <matinv+0x739>
mov    -0x68(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17d9 <matinv+0x6b9>
mov    -0x68(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    17c6 <matinv+0x6a6>
jmp    18a1 <matinv+0x781>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16cd <matinv+0x5ad>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matinv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %rdx,%r13
mov    %rsi,%r15
mov    %rdi,0x10(%rsp)
lea    0x0(,%rdi,4),%eax
movslq %eax,%rbp
mov    %rbp,%rdi
call   1060 <malloc@plt>
mov    $0x1,%r14d
test   %rax,%rax
je     1fb5 <matinv+0xe75>
mov    %rax,%rbx
mov    %rbp,%rdi
call   1060 <malloc@plt>
test   %rax,%rax
je     1ace <matinv+0x98e>
mov    %rax,%rbp
mov    %rbx,0x18(%rsp)
mov    0x10(%rsp),%r12
lea    0x0(,%r12,8),%ebx
movslq %ebx,%rdi
call   1060 <malloc@plt>
test   %rax,%rax
je     1adb <matinv+0x99b>
mov    %rax,0x40(%rsp)
imul   %r12d,%ebx
movslq %ebx,%rdi
call   1060 <malloc@plt>
mov    %rax,0x20(%rsp)
test   %rax,%rax
je     1af2 <matinv+0x9b2>
mov    %rbp,0x38(%rsp)
test   %r12d,%r12d
jle    1f8a <matinv+0xe4a>
mov    %r13,0x48(%rsp)
mov    %r12d,%eax
mov    %rax,(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x60(%rsp)
lea    -0x1(%r12),%eax
mov    %rax,0x50(%rsp)
add    $0x1,%rax
mov    %r12d,%ecx
mov    %rax,%r12
and    $0xfffffffe,%ecx
mov    %ecx,0x8(%rsp)
xor    %ebp,%ebp
xor    %r13d,%r13d
mov    0x18(%rsp),%rbx
mov    0x20(%rsp),%r14
nopw   0x0(%rax,%rax,1)
mov    %ebp,(%rbx,%rbp,4)
movslq %r13d,%r13
lea    (%r14,%r13,8),%rdi
lea    (%r15,%r13,8),%rsi
mov    0x60(%rsp),%rdx
call   1050 <memcpy@plt>
movapd 0xdb0(%rip),%xmm3
mov    %r13,%rax
xorpd  %xmm0,%xmm0
cmpq   $0x0,0x50(%rsp)
je     129a <matinv+0x15a>
xorpd  %xmm1,%xmm1
mov    0x8(%rsp),%ecx
mov    %r13,%rax
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm2
movsd  0x8(%r15,%rax,8),%xmm0
andpd  %xmm3,%xmm2
maxsd  %xmm1,%xmm2
andpd  %xmm3,%xmm0
maxsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
add    $0xfffffffe,%ecx
jne    1270 <matinv+0x130>
testb  $0x1,0x10(%rsp)
mov    0x40(%rsp),%rcx
movapd 0xd54(%rip),%xmm7
je     12c0 <matinv+0x180>
movsd  (%r15,%rax,8),%xmm1
andpd  %xmm7,%xmm1
maxsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
ucomisd 0xd53(%rip),%xmm0
jne    12d5 <matinv+0x195>
jnp    1b13 <matinv+0x9d3>
add    $0x1,%rbp
add    %r12,%r13
cmp    (%rsp),%rbp
jne    1230 <matinv+0xf0>
mov    0x10(%rsp),%r15
test   %r15d,%r15d
jle    1f8a <matinv+0xe4a>
mov    (%rsp),%r14
lea    0x10(,%r14,8),%rax
mov    %rax,0x120(%rsp)
lea    0x8(,%r14,8),%rax
mov    %rax,0x118(%rsp)
mov    %r14,%rax
shl    $0x4,%rax
mov    %rax,0x110(%rsp)
lea    -0x2(%r14),%rcx
mov    0x50(%rsp),%rdx
lea    0x8(,%rdx,8),%rax
mov    %rax,0x100(%rsp)
mov    0x20(%rsp),%r10
lea    (%r10,%rdx,8),%rax
add    $0x8,%rax
mov    %rax,0xf8(%rsp)
mov    %r12,0xf0(%rsp)
and    $0xfffffffffffffffc,%r12
mov    %r12,0x90(%rsp)
lea    -0x4(%r12),%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
lea    -0x1(%r14),%rax
mov    %rax,0x78(%rsp)
mov    %rdx,%rax
mov    %rdx,0xe0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xd8(%rsp)
mov    %r15d,%eax
neg    %eax
mov    %eax,0x8c(%rsp)
lea    0x0(,%r14,8),%rbx
lea    (%r10,%r14,8),%rdx
lea    0x8(,%r14,8),%rax
mov    %rax,0x128(%rsp)
xorpd  %xmm0,%xmm0
movapd 0xc3b(%rip),%xmm1
lea    0x30(%r10),%rsi
lea    0x8(%r10),%rax
mov    %rax,0x98(%rsp)
lea    0x20(%r10),%rax
mov    %rax,0xc0(%rsp)
lea    0x20(%r10,%r14,8),%rax
mov    %rax,0xa8(%rsp)
mov    $0x1,%eax
mov    %rax,0x30(%rsp)
xor    %eax,%eax
mov    %r10,%r12
mov    %rcx,0x108(%rsp)
mov    %rcx,0xa0(%rsp)
mov    %rsi,0xd0(%rsp)
mov    %rdx,0xb0(%rsp)
xor    %r13d,%r13d
mov    %rbx,0x70(%rsp)
jmp    14a9 <matinv+0x369>
nopw   0x0(%rax,%rax,1)
addq   $0x1,0x30(%rsp)
mov    0x140(%rsp),%r13
add    %r14,%r13
mov    0x128(%rsp),%rax
mov    0x148(%rsp),%rdx
add    %rax,%rdx
mov    0xb8(%rsp),%rsi
add    %rbx,%rsi
addq   $0xffffffffffffffff,0xa0(%rsp)
add    %rax,0xc0(%rsp)
add    %rax,0xa8(%rsp)
add    %rbx,0xb0(%rsp)
add    %rbx,%r12
mov    0xc8(%rsp),%rax
cmp    %r14,%rax
mov    0x10(%rsp),%r15
je     1b42 <matinv+0xa02>
mov    %rsi,0xb8(%rsp)
mov    %rax,%rcx
imul   %r15d,%eax
cltq
add    %rcx,%rax
mov    0x40(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm2
lea    0x1(%rcx),%rsi
cmp    %r14,%rsi
mov    %rcx,0x28(%rsp)
mov    %rdx,0x148(%rsp)
mov    %rax,0x80(%rsp)
jae    1540 <matinv+0x400>
movsd  (%r10,%rax,8),%xmm3
andpd  %xmm7,%xmm3
divsd  %xmm2,%xmm3
mov    %rdx,%rax
mov    0x30(%rsp),%rdx
mov    0x18(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm4
andpd  %xmm7,%xmm4
divsd  0x0(%rbp,%rdx,8),%xmm4
ucomisd %xmm3,%xmm4
cmova  %edx,%ecx
maxsd  %xmm3,%xmm4
add    $0x1,%rdx
add    %rbx,%rax
movapd %xmm4,%xmm3
cmp    %rdx,%r14
jne    1510 <matinv+0x3d0>
jmp    1545 <matinv+0x405>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%r8
mov    0x60(%rsp),%rax
mov    0x28(%rsp),%rdx
imul   %rdx,%rax
mov    %rax,0x58(%rsp)
movslq %ecx,%rax
cmp    %rax,%rdx
mov    %rsi,0xc8(%rsp)
jge    177f <matinv+0x63f>
imul   %r15d,%ecx
xor    %edx,%edx
movslq %ecx,%r11
cmpl   $0x3,0x50(%rsp)
jb     15b5 <matinv+0x475>
mov    0x100(%rsp),%rsi
mov    0x58(%rsp),%rcx
add    %rcx,%rsi
add    %r10,%rsi
lea    (%r10,%r11,8),%rdi
cmp    %rsi,%rdi
jae    1659 <matinv+0x519>
lea    (%r10,%rcx,1),%rsi
mov    0xf8(%rsp),%rdi
lea    (%rdi,%r11,8),%rdi
cmp    %rdi,%rsi
jae    1659 <matinv+0x519>
mov    %r13,%rsi
mov    %r15d,%edi
sub    %edx,%edi
test   $0x1,%dil
jne    15d0 <matinv+0x490>
mov    %edx,%r9d
jmp    15f4 <matinv+0x4b4>
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%r11,8),%xmm3
movsd  (%r10,%rsi,8),%xmm4
movsd  %xmm4,(%r10,%r11,8)
movsd  %xmm3,(%r10,%rsi,8)
lea    0x1(%rdx),%r9d
add    $0x1,%r11
add    $0x1,%rsi
not    %edx
cmp    0x8c(%rsp),%edx
je     1750 <matinv+0x610>
mov    0x98(%rsp),%rdi
lea    (%rdi,%rsi,8),%rdx
lea    (%rdi,%r11,8),%rcx
mov    %r15d,%esi
sub    %r9d,%esi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rdi,8),%xmm3
movsd  -0x8(%rdx,%rdi,8),%xmm4
movsd  %xmm4,-0x8(%rcx,%rdi,8)
movsd  %xmm3,-0x8(%rdx,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm3
movsd  (%rdx,%rdi,8),%xmm4
movsd  %xmm4,(%rcx,%rdi,8)
movsd  %xmm3,(%rdx,%rdi,8)
add    $0x2,%rdi
cmp    %edi,%esi
jne    1620 <matinv+0x4e0>
jmp    1750 <matinv+0x610>
cmpq   $0x0,0xe8(%rsp)
je     1ab9 <matinv+0x979>
mov    0xd0(%rsp),%rdx
lea    (%rdx,%r11,8),%rsi
mov    0xd8(%rsp),%rdi
xor    %edx,%edx
mov    0xb8(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rsi,%rdx,8),%xmm3
movups -0x20(%rsi,%rdx,8),%xmm4
movups -0x30(%rcx,%rdx,8),%xmm5
movups -0x20(%rcx,%rdx,8),%xmm6
movups %xmm5,-0x30(%rsi,%rdx,8)
movups %xmm6,-0x20(%rsi,%rdx,8)
movups %xmm3,-0x30(%rcx,%rdx,8)
movups %xmm4,-0x20(%rcx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm3
movupd (%rsi,%rdx,8),%xmm4
movupd -0x10(%rcx,%rdx,8),%xmm5
movupd (%rcx,%rdx,8),%xmm6
movupd %xmm5,-0x10(%rsi,%rdx,8)
movupd %xmm6,(%rsi,%rdx,8)
movupd %xmm3,-0x10(%rcx,%rdx,8)
movupd %xmm4,(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1690 <matinv+0x550>
testb  $0x1,0xe0(%rsp)
01
je     1733 <matinv+0x5f3>
lea    (%rdx,%r13,1),%rsi
add    %r11,%rdx
movupd (%r10,%rdx,8),%xmm3
movupd 0x10(%r10,%rdx,8),%xmm4
movupd (%r10,%rsi,8),%xmm5
movupd 0x10(%r10,%rsi,8),%xmm6
movupd %xmm5,(%r10,%rdx,8)
movupd %xmm6,0x10(%r10,%rdx,8)
movupd %xmm3,(%r10,%rsi,8)
movupd %xmm4,0x10(%r10,%rsi,8)
mov    0x90(%rsp),%rdx
cmp    %rdx,0xf0(%rsp)
jne    1aa5 <matinv+0x965>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm3
movsd  %xmm2,0x0(%rbp,%rax,8)
mov    0x28(%rsp),%rsi
movsd  %xmm3,0x0(%rbp,%rsi,8)
mov    (%r8,%rax,4),%ecx
mov    (%r8,%rsi,4),%edx
mov    %edx,(%r8,%rax,4)
mov    %ecx,(%r8,%rsi,4)
mov    0xc8(%rsp),%rsi
mov    %r13,0x140(%rsp)
cmp    %r14,%rsi
mov    0x28(%rsp),%rbp
jae    1440 <matinv+0x300>
mov    0x118(%rsp),%r9
mov    %r9,%rax
imul   %rbp,%rax
mov    0x60(%rsp),%r11
mov    0x58(%rsp),%rdi
lea    (%r11,%rdi,1),%rcx
mov    0xa0(%rsp),%r8
and    $0xfffffffffffffffc,%r8
mov    0x108(%rsp),%rsi
sub    %rbp,%rsi
mov    0x120(%rsp),%rdx
add    %rax,%rdx
mov    %rdx,0x178(%rsp)
add    0x110(%rsp),%rdi
mov    %rdi,0x58(%rsp)
lea    (%r11,%rax,1),%rdx
mov    %rdx,0x170(%rsp)
lea    (%r9,%rax,1),%rdx
mov    %rdx,0x168(%rsp)
add    %r10,%rax
add    $0x10,%rax
mov    %rax,0x160(%rsp)
add    %r10,%rcx
mov    %rcx,0x180(%rsp)
mov    %rbp,%rax
imul   %r14,%rax
mov    0x30(%rsp),%rcx
mov    %rax,0x150(%rsp)
lea    (%rcx,%rax,1),%r11
lea    0x1(%rcx),%rax
mov    %rax,0x8(%rsp)
mov    %rsi,0x68(%rsp)
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x138(%rsp)
lea    (%rcx,%rsi,1),%rax
add    $0x1,%rax
mov    %rax,0x130(%rsp)
mov    0xb0(%rsp),%rsi
mov    0xa8(%rsp),%rdx
xor    %eax,%eax
mov    %r11,0x158(%rsp)
jmp    189c <matinv+0x75c>
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x1,%rax
mov    0x70(%rsp),%rbx
add    %rbx,%rdx
add    %rbx,%rsi
cmp    %r14,%rcx
je     1440 <matinv+0x300>
mov    %rcx,%r15
imul   %r14,%r15
lea    (%r15,%rbp,1),%r13
movsd  (%r10,%r13,8),%xmm2
ucomisd %xmm0,%xmm2
jne    18b5 <matinv+0x775>
jnp    1880 <matinv+0x740>
mov    0x80(%rsp),%rdi
divsd  (%r10,%rdi,8),%xmm2
mov    0x30(%rsp),%rdi
add    %r15,%rdi
movsd  %xmm2,(%r10,%r13,8)
mulsd  (%r10,%r11,8),%xmm2
movsd  (%r10,%rdi,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%r10,%rdi,8)
cmp    %r14,0x8(%rsp)
je     1880 <matinv+0x740>
mov    0x8(%rsp),%rdi
cmpq   $0x4,0x68(%rsp)
jb     1a10 <matinv+0x8d0>
mov    0x60(%rsp),%rdi
imul   %rax,%rdi
mov    0x178(%rsp),%rbp
lea    (%rdi,%rbp,1),%r11
add    %r10,%r11
mov    0x58(%rsp),%rbp
add    %rdi,%rbp
add    %r10,%rbp
mov    0x170(%rsp),%rbx
lea    (%rbx,%rdi,1),%r9
add    %r10,%r9
add    0x168(%rsp),%rdi
add    %r10,%rdi
cmp    %rdi,%r11
setb   %r10b
cmp    %rbp,%r9
setb   %r14b
cmp    0x180(%rsp),%r11
mov    0x158(%rsp),%r11
setb   %bl
cmp    %rbp,0x160(%rsp)
setb   %r9b
mov    0x8(%rsp),%rdi
test   %r14b,%r10b
mov    (%rsp),%r14
mov    0x20(%rsp),%r10
jne    1a10 <matinv+0x8d0>
mov    0x8(%rsp),%rdi
and    %r9b,%bl
jne    1a10 <matinv+0x8d0>
movsd  (%r10,%r13,8),%xmm2
unpcklpd %xmm2,%xmm2
xorpd  %xmm1,%xmm2
xor    %edi,%edi
mov    0xc0(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rbp,%rdi,8),%xmm3
movupd 0x0(%rbp,%rdi,8),%xmm4
movupd -0x10(%rdx,%rdi,8),%xmm5
movupd (%rdx,%rdi,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,-0x10(%rdx,%rdi,8)
movupd %xmm4,(%rdx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r8
jne    19b0 <matinv+0x870>
mov    0x130(%rsp),%rdi
mov    0x138(%rsp),%rbp
cmp    %rbp,0x68(%rsp)
mov    0x28(%rsp),%rbp
je     1880 <matinv+0x740>
nopl   0x0(%rax,%rax,1)
mov    %r14d,%ebp
sub    %edi,%ebp
mov    %rdi,%rbx
test   $0x1,%bpl
je     1a4c <matinv+0x90c>
movsd  (%r10,%r13,8),%xmm2
mov    0x150(%rsp),%rbp
add    %rdi,%rbp
add    %rdi,%r15
mulsd  (%r10,%rbp,8),%xmm2
movsd  (%r10,%r15,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%r10,%r15,8)
lea    0x1(%rdi),%rbx
cmp    %rdi,0x78(%rsp)
mov    0x28(%rsp),%rbp
je     1880 <matinv+0x740>
nopl   0x0(%rax)
movsd  (%r10,%r13,8),%xmm2
mulsd  (%r12,%rbx,8),%xmm2
movsd  (%rsi,%rbx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rsi,%rbx,8),%xmm2
movsd  %xmm3,(%rsi,%rbx,8)
movsd  (%r10,%r13,8),%xmm3
mulsd  0x8(%r12,%rbx,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rsi,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r14
jne    1a60 <matinv+0x920>
jmp    1880 <matinv+0x740>
mov    0x90(%rsp),%rdx
lea    (%rdx,%r13,1),%rsi
add    %rdx,%r11
jmp    15b8 <matinv+0x478>
xor    %edx,%edx
testb  $0x1,0xe0(%rsp)
01
jne    16f8 <matinv+0x5b8>
jmp    1733 <matinv+0x5f3>
mov    %rbx,%rdi
call   1030 <free@plt>
jmp    1fb5 <matinv+0xe75>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
jmp    1fb5 <matinv+0xe75>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
jmp    1fb5 <matinv+0xe75>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    $0x2,%r14d
jmp    1fb5 <matinv+0xe75>
test   %r15d,%r15d
mov    0x50(%rsp),%r8
jle    1f8a <matinv+0xe4a>
mov    (%rsp),%rdx
mov    %edx,%eax
and    $0x3,%eax
cmpq   $0x3,0x78(%rsp)
jae    1b74 <matinv+0xa34>
xor    %ecx,%ecx
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%rsi
mov    0x38(%rsp),%rbx
jmp    1bc7 <matinv+0xa87>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
mov    0x18(%rsp),%rbp
mov    0x38(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq 0x0(%rbp,%rcx,4),%rsi
mov    %ecx,(%rbx,%rsi,4)
movslq 0x4(%rbp,%rcx,4),%rsi
lea    0x1(%rcx),%edi
mov    %edi,(%rbx,%rsi,4)
movslq 0x8(%rbp,%rcx,4),%rsi
lea    0x2(%rcx),%edi
mov    %edi,(%rbx,%rsi,4)
movslq 0xc(%rbp,%rcx,4),%rsi
lea    0x3(%rcx),%edi
mov    %edi,(%rbx,%rsi,4)
add    $0x4,%rcx
cmp    %rdx,%rcx
jne    1b90 <matinv+0xa50>
mov    0x10(%rsp),%rsi
test   %rax,%rax
je     1be2 <matinv+0xaa2>
nopl   0x0(%rax)
movslq 0x0(%rbp,%rcx,4),%rdx
mov    %ecx,(%rbx,%rdx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1bd0 <matinv+0xa90>
test   %esi,%esi
jle    1f8a <matinv+0xe4a>
mov    (%rsp),%rax
lea    0x0(,%rax,8),%r12
mov    %r8,%rbx
add    $0x1,%rbx
mov    %esi,%eax
and    $0x3,%eax
mov    %eax,0x8(%rsp)
cmp    $0x3,%r8d
jae    1c16 <matinv+0xad6>
xor    %r15d,%r15d
mov    0x48(%rsp),%r14
jmp    1c87 <matinv+0xb47>
mov    %esi,%r13d
and    $0xfffffffc,%r13d
xor    %r15d,%r15d
mov    0x48(%rsp),%r14
movslq %r15d,%rax
lea    (%r14,%rax,8),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
add    %rbx,%r15
movslq %r15d,%rax
lea    (%r14,%rax,8),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
add    %rbx,%r15
mov    %r12,%rbp
mov    %rbx,%r12
movslq %r15d,%rbx
lea    (%r14,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
add    %r12d,%ebx
movslq %ebx,%r15
mov    %r12,%rbx
mov    %rbp,%r12
lea    (%r14,%r15,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
add    %rbx,%r15
add    $0xfffffffc,%r13d
jne    1c25 <matinv+0xae5>
mov    0x8(%rsp),%ebp
test   %ebp,%ebp
je     1ca9 <matinv+0xb69>
nop
movslq %r15d,%r15
lea    (%r14,%r15,8),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
add    %rbx,%r15
add    $0xffffffff,%ebp
jne    1c90 <matinv+0xb50>
mov    0x10(%rsp),%r13
test   %r13d,%r13d
jle    1f8a <matinv+0xe4a>
mov    (%rsp),%rax
mov    %rax,%r15
shl    $0x4,%r15
lea    0x0(,%rax,8),%rdx
mov    0x78(%rsp),%rcx
imul   %rax,%rcx
mov    0x20(%rsp),%rax
lea    (%rax,%rcx,8),%rax
add    $0x8,%rax
mov    %rax,0x68(%rsp)
mov    %rdx,%r9
neg    %r9
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %r10d,%r10d
mov    %rdx,0x70(%rsp)
jmp    1d19 <matinv+0xbd9>
nopl   0x0(%rax)
add    $0x1,%r10
addq   $0x8,0x8(%rsp)
cmp    (%rsp),%r10
mov    0x70(%rsp),%rdx
je     1f8a <matinv+0xe4a>
mov    0x38(%rsp),%rax
mov    (%rax,%r10,4),%r12d
mov    %r12d,%eax
imul   %r13d,%eax
cltq
add    %r10,%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r14,%rax,8)
lea    0x1(%r12),%eax
cmp    %r13d,%eax
jge    1e70 <matinv+0xd30>
movslq %r12d,%rcx
movslq %eax,%rdi
mov    %rcx,%rsi
imul   (%rsp),%rsi
add    %r10,%rsi
mov    %rsi,0x80(%rsp)
mov    %rcx,0x30(%rsp)
add    $0x1,%rcx
mov    %rcx,0x28(%rsp)
mov    %eax,%r8d
mov    %rdx,%rcx
imul   %rdi,%rcx
add    0x98(%rsp),%rcx
xor    %r13d,%r13d
mov    %r12d,%eax
jmp    1dab <matinv+0xc6b>
nopl   0x0(%rax,%rax,1)
mov    %edi,%eax
add    $0x1,%rdi
add    $0x1,%r13d
add    $0x1,%r8
add    %rdx,%rcx
cmp    0x10(%rsp),%edi
je     1e70 <matinv+0xd30>
cmp    %eax,%r12d
mov    0x48(%rsp),%rsi
jg     1d90 <matinv+0xc50>
mov    %rdi,%rax
imul   (%rsp),%rax
lea    (%rax,%r10,1),%rbp
movsd  (%rsi,%rbp,8),%xmm0
test   $0x1,%r13b
jne    1e00 <matinv+0xcc0>
add    0x30(%rsp),%rax
mov    0x20(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm1
mov    0x80(%rsp),%rax
mulsd  (%rsi,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
mov    0x28(%rsp),%rbx
jmp    1e05 <matinv+0xcc5>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rbx
test   %r13d,%r13d
mov    0x48(%rsp),%rax
je     1d90 <matinv+0xc50>
mov    (%rsp),%r14
imul   %rbx,%r14
add    %r10,%r14
lea    0x1(%rbx),%rsi
imul   %rdx,%rsi
add    0x8(%rsp),%rsi
mov    %rax,%r11
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,8),%xmm1
mulsd  (%r11,%r14,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rbp,8)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  (%r11,%rsi,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x2,%rbx
add    %r15,%r11
cmp    %ebx,%r8d
jne    1e30 <matinv+0xcf0>
jmp    1d90 <matinv+0xc50>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    0x68(%rsp),%rdx
mov    (%rsp),%r8
mov    0x48(%rsp),%r14
mov    0x10(%rsp),%r13
jmp    1ec2 <matinv+0xd82>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%eax
imul   %r13d,%eax
cltq
add    %r8,%rax
movsd  (%r14,%rbp,8),%xmm0
mov    0x20(%rsp),%rsi
divsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
add    $0x1,%ecx
add    %r9,%rdx
cmp    $0x1,%r11
jle    1d00 <matinv+0xbc0>
mov    %r8,%r11
add    $0xffffffffffffffff,%r8
mov    %r8,%rax
mov    (%rsp),%rsi
imul   %rsi,%rax
lea    (%rax,%r10,1),%rbp
cmp    %rsi,%r11
jge    1e90 <matinv+0xd50>
movsd  (%r14,%rbp,8),%xmm0
test   $0x1,%cl
jne    1ef0 <matinv+0xdb0>
mov    %r11,%rdi
jmp    1f1c <matinv+0xddc>
nopl   (%rax)
add    %r11,%rax
mov    0x20(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm1
mov    %r11,%rax
imul   (%rsp),%rax
add    %r10,%rax
mulsd  (%r14,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
lea    0x1(%r11),%rdi
cmp    $0x1,%ecx
mov    (%rsp),%r12
je     1e90 <matinv+0xd50>
mov    %r12,%rbx
imul   %rdi,%rbx
add    %r10,%rbx
lea    0x1(%rdi),%rsi
imul   0x70(%rsp),%rsi
add    0x8(%rsp),%rsi
mov    %r14,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%rdi,8),%xmm1
mulsd  (%rax,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
movsd  (%rdx,%rdi,8),%xmm1
mulsd  (%rax,%rsi,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
add    $0x2,%rdi
add    %r15,%rax
cmp    %edi,%r12d
jne    1f50 <matinv+0xe10>
jmp    1e90 <matinv+0xd50>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
xor    %r14d,%r14d
mov    %r14d,%eax
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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