void o_gaussj(a, n, b, m) double **a, **b;
int n, m;
{
  int bad = 0;
  int *indxc, *indxr, *ipiv;
  int i, icol, irow, j, k, l, ll, *ivector();
  double big, dum, pivinv;
  void nrerror(), free_ivector();
  icol = irow = 0;
  indxc = ivector(1, n);
  indxr = ivector(1, n);
  ipiv = ivector(1, n);
  for (j = 1; j <= n; j++)
    ipiv[j] = 0;
  for (i = 1; i <= n; i++) {
    big = 0.0;
    for (j = 1; j <= n; j++)
      if (ipiv[j] != 1)
        for (k = 1; k <= n; k++) {
          if (ipiv[k] == 0) {
            if (fabs(a[j][k]) >= big) {
              big = fabs(a[j][k]);
              irow = j;
              icol = k;
            }
          } else if (ipiv[k] > 1)
            nrerror("GAUSSJ: Singular Matrix-1");
        }
    if (icol < 1 || icol > n || irow < 1 || irow > n) {
      printf("\nBad Matrix %d %d %d", icol, irow, n);
      nrerror("GAUSSJ: Bad Matrix ");
      bad = 1;
    } else {
      ++(ipiv[icol]);
      if (irow != icol) {
        for (l = 1; l <= n; l++) {
          float temp = (a[irow][l]);
          (a[irow][l]) = (a[icol][l]);
          (a[icol][l]) = temp;
        }
        for (l = 1; l <= m; l++) {
          float temp = (b[irow][l]);
          (b[irow][l]) = (b[icol][l]);
          (b[icol][l]) = temp;
        }
      }
      indxr[i] = irow;
      indxc[i] = icol;
      if (a[icol][icol] == 0.0) {
        nrerror("GAUSSJ: Singular Matrix-2");
        bad = 2;
      } else {
        pivinv = 1.0 / a[icol][icol];
        a[icol][icol] = 1.0;
        for (l = 1; l <= n; l++)
          a[icol][l] *= pivinv;
        for (l = 1; l <= m; l++)
          b[icol][l] *= pivinv;
        for (ll = 1; ll <= n; ll++)
          if (ll != icol) {
            dum = a[ll][icol];
            a[ll][icol] = 0.0;
            for (l = 1; l <= n; l++)
              a[ll][l] -= a[icol][l] * dum;
            for (l = 1; l <= m; l++)
              b[ll][l] -= b[icol][l] * dum;
          }
      }
    }
  }
  if (!bad)
    for (l = n; l >= 1; l--) {
      if (indxr[l] != indxc[l])
        for (k = 1; k <= n; k++) {
          float temp = (a[k][indxr[l]]);
          (a[k][indxr[l]]) = (a[k][indxc[l]]);
          (a[k][indxc[l]]) = temp;
        };
    }
  free_ivector(ipiv, 1, n);
  free_ivector(indxr, 1, n);
  free_ivector(indxc, 1, n);
}


x86 assembly (clang, -O0):
<o_gaussj>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1060 <ivector@plt>
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1060 <ivector@plt>
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1060 <ivector@plt>
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11d7 <o_gaussj+0x97>
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11ae <o_gaussj+0x6e>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1705 <o_gaussj+0x5c5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12ed <o_gaussj+0x1ad>
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     12da <o_gaussj+0x19a>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12d5 <o_gaussj+0x195>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    129d <o_gaussj+0x15d>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdb8(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     1298 <o_gaussj+0x158>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd8d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    12c2 <o_gaussj+0x182>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    12bd <o_gaussj+0x17d>
lea    0xd6a(%rip),%rdi
mov    $0x0,%al
call   1030 <nrerror@plt>
jmp    12c2 <o_gaussj+0x182>
jmp    12c7 <o_gaussj+0x187>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    121e <o_gaussj+0xde>
jmp    12da <o_gaussj+0x19a>
jmp    12df <o_gaussj+0x19f>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11f9 <o_gaussj+0xb9>
cmpl   $0x1,-0x40(%rbp)
jl     1319 <o_gaussj+0x1d9>
mov    -0x40(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1319 <o_gaussj+0x1d9>
cmpl   $0x1,-0x44(%rbp)
jl     1319 <o_gaussj+0x1d9>
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    134a <o_gaussj+0x20a>
mov    -0x40(%rbp),%esi
mov    -0x44(%rbp),%edx
mov    -0xc(%rbp),%ecx
lea    0xd11(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xd18(%rip),%rdi
mov    $0x0,%al
call   1030 <nrerror@plt>
movl   $0x1,-0x20(%rbp)
jmp    16f2 <o_gaussj+0x5b2>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     147a <o_gaussj+0x33a>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13ee <o_gaussj+0x2ae>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    136e <o_gaussj+0x22e>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1475 <o_gaussj+0x335>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13f5 <o_gaussj+0x2b5>
jmp    147a <o_gaussj+0x33a>
mov    -0x44(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14d8 <o_gaussj+0x398>
jp     14d8 <o_gaussj+0x398>
lea    0xb9e(%rip),%rdi
mov    $0x0,%al
call   1030 <nrerror@plt>
movl   $0x2,-0x20(%rbp)
jmp    16ed <o_gaussj+0x5ad>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  0xb10(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  0xaee(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1557 <o_gaussj+0x417>
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    151e <o_gaussj+0x3de>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1597 <o_gaussj+0x457>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    155e <o_gaussj+0x41e>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     16e8 <o_gaussj+0x5a8>
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     16d5 <o_gaussj+0x595>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     165c <o_gaussj+0x51c>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%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    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15ef <o_gaussj+0x4af>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     16d0 <o_gaussj+0x590>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%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    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1663 <o_gaussj+0x523>
jmp    16d5 <o_gaussj+0x595>
jmp    16da <o_gaussj+0x59a>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    159e <o_gaussj+0x45e>
jmp    16ed <o_gaussj+0x5ad>
jmp    16f2 <o_gaussj+0x5b2>
jmp    16f7 <o_gaussj+0x5b7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11de <o_gaussj+0x9e>
cmpl   $0x0,-0x20(%rbp)
jne    17ff <o_gaussj+0x6bf>
mov    -0xc(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x1,-0x50(%rbp)
jl     17fa <o_gaussj+0x6ba>
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     17e7 <o_gaussj+0x6a7>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     17e2 <o_gaussj+0x6a2>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movslq -0x50(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movslq -0x50(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movslq -0x50(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movslq -0x50(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1742 <o_gaussj+0x602>
jmp    17e7 <o_gaussj+0x6a7>
jmp    17ec <o_gaussj+0x6ac>
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
jmp    1715 <o_gaussj+0x5d5>
jmp    17ff <o_gaussj+0x6bf>
mov    -0x38(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_ivector@plt>
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_ivector@plt>
mov    -0x28(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_ivector@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<o_gaussj>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %ecx,%r13d
mov    %rdx,0x50(%rsp)
mov    %esi,%r14d
mov    %rdi,%rbx
mov    $0x1,%edi
xor    %eax,%eax
call   1070 <ivector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %r14d,%esi
xor    %eax,%eax
call   1070 <ivector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %r14d,%esi
xor    %eax,%eax
call   1070 <ivector@plt>
mov    %rax,%rbp
mov    %r14d,(%rsp)
test   %r14d,%r14d
jle    1bd3 <o_gaussj+0xa83>
mov    %r12,0x60(%rsp)
mov    %r15,0x68(%rsp)
mov    %rbp,%rdi
add    $0x4,%rdi
mov    (%rsp),%r15d
lea    0x0(,%r15,4),%rdx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x1(%r15),%r14
mov    %r13,0x38(%rsp)
lea    0x1(%r13),%eax
lea    -0x1(%rax),%rcx
lea    -0x4(%r15),%rdx
mov    %rdx,0xb0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
lea    -0x5(%rax),%rsi
mov    %rsi,0xa0(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %r15d,%edi
and    $0xfffffffc,%edi
mov    %rdi,0x30(%rsp)
add    $0x1,%rdi
mov    %rdi,0x48(%rsp)
mov    %r15,0x10(%rsp)
not    %r15
mov    %r15,0x78(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rcx,%rdi
and    $0xfffffffffffffffc,%rdi
lea    0x1(%rdi),%rcx
mov    %rcx,0x40(%rsp)
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0x70(%rsp)
mov    %rdx,%rcx
mov    %rdx,0xa8(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x90(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x98(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x88(%rsp)
mov    $0x1,%ecx
mov    %rcx,0x58(%rsp)
movl   $0x0,0x24(%rsp)
movl   $0x0,0x4(%rsp)
xor    %r13d,%r13d
mov    %rax,0x8(%rsp)
mov    %rdi,0x28(%rsp)
jmp    12f5 <o_gaussj+0x1a5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0xd83(%rip),%rdi
mov    0x4(%rsp),%esi
mov    (%rsp),%ecx
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%r15d
lea    0xd7d(%rip),%rdi
xor    %eax,%eax
call   1030 <nrerror@plt>
mov    %r15d,0x24(%rsp)
mov    0x58(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,0x58(%rsp)
cmp    %r14,%rcx
je     1aef <o_gaussj+0x99f>
mov    $0x1,%r15d
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x80(%rsp)
jmp    131d <o_gaussj+0x1cd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    %r14,%r15
je     13a0 <o_gaussj+0x250>
cmpl   $0x1,0x0(%rbp,%r15,4)
je     1310 <o_gaussj+0x1c0>
mov    $0x1,%r12d
jmp    1339 <o_gaussj+0x1e9>
nopl   (%rax)
add    $0x1,%r12
cmp    %r12,%r14
je     1310 <o_gaussj+0x1c0>
mov    0x0(%rbp,%r12,4),%eax
test   %eax,%eax
je     1360 <o_gaussj+0x210>
cmp    $0x2,%eax
jl     1330 <o_gaussj+0x1e0>
lea    0xcd2(%rip),%rdi
xor    %eax,%eax
call   1030 <nrerror@plt>
jmp    1330 <o_gaussj+0x1e0>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%r15,8),%rax
movsd  (%rax,%r12,8),%xmm0
andpd  0xc8e(%rip),%xmm0
ucomisd 0x80(%rsp),%xmm0
jb     1330 <o_gaussj+0x1e0>
movsd  %xmm0,0x80(%rsp)
mov    %r15d,%r13d
mov    %r12d,%eax
mov    %r12d,0x4(%rsp)
jmp    1330 <o_gaussj+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,0x4(%rsp)
mov    %r13d,%edx
jle    12b0 <o_gaussj+0x160>
mov    0x4(%rsp),%eax
cmp    (%rsp),%eax
jg     12b0 <o_gaussj+0x160>
test   %edx,%edx
jle    12b0 <o_gaussj+0x160>
cmp    (%rsp),%edx
jg     12b0 <o_gaussj+0x160>
mov    0x4(%rsp),%eax
mov    %eax,%r10d
addl   $0x1,0x0(%rbp,%r10,4)
cmp    %eax,%edx
jne    13e6 <o_gaussj+0x296>
mov    (%rbx,%r10,8),%rcx
jmp    1640 <o_gaussj+0x4f0>
mov    %edx,%eax
mov    (%rbx,%rax,8),%r15
mov    (%rbx,%r10,8),%rcx
mov    $0x1,%eax
cmpl   $0x4,0x10(%rsp)
mov    0x38(%rsp),%r8
jae    1410 <o_gaussj+0x2c0>
mov    0x8(%rsp),%r9
mov    0x28(%rsp),%r11
jmp    149b <o_gaussj+0x34b>
lea    0x8(%r15),%rsi
lea    (%rcx,%r14,8),%rdi
cmp    %rdi,%rsi
mov    0x8(%rsp),%r9
mov    0x28(%rsp),%r11
jae    1434 <o_gaussj+0x2e4>
lea    (%r15,%r14,8),%rsi
lea    0x8(%rcx),%rdi
cmp    %rsi,%rdi
jb     149b <o_gaussj+0x34b>
xor    %eax,%eax
mov    0x30(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r15,%rax,8),%xmm0
movupd 0x18(%r15,%rax,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
movupd 0x8(%rcx,%rax,8),%xmm2
movupd 0x18(%rcx,%rax,8),%xmm3
movupd %xmm2,0x8(%r15,%rax,8)
movupd %xmm3,0x18(%r15,%rax,8)
cvtps2pd %xmm0,%xmm0
cvtps2pd %xmm1,%xmm1
movupd %xmm0,0x8(%rcx,%rax,8)
movupd %xmm1,0x18(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1440 <o_gaussj+0x2f0>
mov    0x48(%rsp),%rax
cmp    %rsi,0x10(%rsp)
je     1519 <o_gaussj+0x3c9>
mov    %rax,%rsi
test   $0x1,%r14b
jne    14c6 <o_gaussj+0x376>
movsd  (%r15,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
lea    0x1(%rax),%rsi
not    %rax
cmp    0x78(%rsp),%rax
je     1519 <o_gaussj+0x3c9>
movsd  (%r15,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%r15,%rsi,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  0x8(%r15,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  0x8(%rcx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%r15,%rsi,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rcx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r14
jne    14d0 <o_gaussj+0x380>
test   %r8d,%r8d
jle    1640 <o_gaussj+0x4f0>
movslq %edx,%rax
mov    0x50(%rsp),%rsi
mov    (%rsi,%rax,8),%r15
mov    (%rsi,%r10,8),%rsi
mov    $0x1,%eax
cmpq   $0x4,0x18(%rsp)
jb     15bb <o_gaussj+0x46b>
lea    0x8(%r15),%r8
lea    (%rsi,%r9,8),%rdi
cmp    %rdi,%r8
jae    1559 <o_gaussj+0x409>
lea    (%r15,%r9,8),%r8
lea    0x8(%rsi),%rdi
cmp    %r8,%rdi
jb     15bb <o_gaussj+0x46b>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r15,%rax,8),%xmm0
movupd 0x18(%r15,%rax,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
movupd 0x8(%rsi,%rax,8),%xmm2
movupd 0x18(%rsi,%rax,8),%xmm3
movupd %xmm2,0x8(%r15,%rax,8)
movupd %xmm3,0x18(%r15,%rax,8)
cvtps2pd %xmm0,%xmm0
cvtps2pd %xmm1,%xmm1
movupd %xmm0,0x8(%rsi,%rax,8)
movupd %xmm1,0x18(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    1560 <o_gaussj+0x410>
mov    0x40(%rsp),%rax
cmp    %r11,0x18(%rsp)
je     1640 <o_gaussj+0x4f0>
mov    %rax,%rdi
test   $0x1,%r9b
jne    15e6 <o_gaussj+0x496>
movsd  (%r15,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rsi,%rax,8)
lea    0x1(%rax),%rdi
not    %rax
cmp    0x70(%rsp),%rax
je     1640 <o_gaussj+0x4f0>
movsd  (%r15,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%r15,%rdi,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x8(%r15,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  0x8(%rsi,%rdi,8),%xmm1
movsd  %xmm1,0x8(%r15,%rdi,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    15f0 <o_gaussj+0x4a0>
nopl   0x0(%rax)
mov    0x60(%rsp),%rax
mov    0x58(%rsp),%rsi
mov    %edx,(%rax,%rsi,4)
mov    0x68(%rsp),%rax
mov    0x4(%rsp),%edx
mov    %edx,(%rax,%rsi,4)
movsd  (%rcx,%r10,8),%xmm1
mov    $0x2,%r15d
ucomisd 0x9ab(%rip),%xmm1
lea    0x9ef(%rip),%rdi
jne    167c <o_gaussj+0x52c>
jnp    12d2 <o_gaussj+0x182>
movsd  0x98c(%rip),%xmm0
divsd  %xmm1,%xmm0
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rcx,%r10,8)
mov    $0x1,%eax
cmpl   $0x4,0x10(%rsp)
mov    0x38(%rsp),%r15
jb     1770 <o_gaussj+0x620>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0xb0(%rsp)
jae    16c7 <o_gaussj+0x577>
xor    %edx,%edx
mov    0x30(%rsp),%rsi
jmp    172a <o_gaussj+0x5da>
mov    0x90(%rsp),%rax
xor    %edx,%edx
mov    0x30(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movupd 0x8(%rcx,%rdx,8),%xmm2
movupd 0x18(%rcx,%rdx,8),%xmm3
movupd 0x28(%rcx,%rdx,8),%xmm4
movupd 0x38(%rcx,%rdx,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x8(%rcx,%rdx,8)
movupd %xmm3,0x18(%rcx,%rdx,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x28(%rcx,%rdx,8)
movupd %xmm5,0x38(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    16e0 <o_gaussj+0x590>
testb  $0x1,0xa8(%rsp)
01
je     175a <o_gaussj+0x60a>
shl    $0x3,%rdx
or     $0x8,%rdx
movupd (%rcx,%rdx,1),%xmm2
movupd 0x10(%rcx,%rdx,1),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rcx,%rdx,1)
movupd %xmm3,0x10(%rcx,%rdx,1)
mov    0x48(%rsp),%rax
cmp    %rsi,0x10(%rsp)
je     1787 <o_gaussj+0x637>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1770 <o_gaussj+0x620>
test   %r15d,%r15d
mov    0x8(%rsp),%rsi
jle    1877 <o_gaussj+0x727>
mov    0x50(%rsp),%rax
mov    (%rax,%r10,8),%rdx
mov    $0x1,%eax
cmpq   $0x4,0x18(%rsp)
jb     1860 <o_gaussj+0x710>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0xa0(%rsp)
jae    17c6 <o_gaussj+0x676>
xor    %esi,%esi
jmp    181a <o_gaussj+0x6ca>
mov    0x88(%rsp),%rax
xor    %esi,%esi
movupd 0x8(%rdx,%rsi,8),%xmm2
movupd 0x18(%rdx,%rsi,8),%xmm3
movupd 0x28(%rdx,%rsi,8),%xmm4
movupd 0x38(%rdx,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x8(%rdx,%rsi,8)
movupd %xmm3,0x18(%rdx,%rsi,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x28(%rdx,%rsi,8)
movupd %xmm5,0x38(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    17d0 <o_gaussj+0x680>
testb  $0x1,0x98(%rsp)
01
je     184a <o_gaussj+0x6fa>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd (%rdx,%rsi,1),%xmm2
movupd 0x10(%rdx,%rsi,1),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rdx,%rsi,1)
movupd %xmm3,0x10(%rdx,%rsi,1)
mov    0x40(%rsp),%rax
mov    0x28(%rsp),%rsi
cmp    %rsi,0x18(%rsp)
mov    0x8(%rsp),%rsi
je     1877 <o_gaussj+0x727>
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1860 <o_gaussj+0x710>
lea    0x8(%rcx),%r8
lea    (%rcx,%r14,8),%r9
mov    $0x1,%r12d
jmp    189d <o_gaussj+0x74d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %r14,%r12
je     12de <o_gaussj+0x18e>
cmp    %r10,%r12
je     1890 <o_gaussj+0x740>
mov    (%rbx,%r12,8),%rdx
movsd  (%rdx,%r10,8),%xmm0
movq   $0x0,(%rdx,%r10,8)
mov    $0x1,%eax
cmpl   $0x4,0x10(%rsp)
jb     1940 <o_gaussj+0x7f0>
lea    0x8(%rdx),%rsi
cmp    %r9,%rsi
jae    18d6 <o_gaussj+0x786>
lea    (%rdx,%r14,8),%rsi
cmp    %rsi,%r8
jb     1940 <o_gaussj+0x7f0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
mov    0x30(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movupd 0x8(%rcx,%rax,8),%xmm2
movupd 0x18(%rcx,%rax,8),%xmm3
movupd 0x8(%rdx,%rax,8),%xmm4
movupd 0x18(%rdx,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x8(%rdx,%rax,8)
movupd %xmm5,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    18f0 <o_gaussj+0x7a0>
mov    0x48(%rsp),%rax
cmp    %rsi,0x10(%rsp)
je     19aa <o_gaussj+0x85a>
nopl   0x0(%rax)
mov    %rax,%rsi
test   $0x1,%r14b
jne    1964 <o_gaussj+0x814>
movsd  (%rdx,%rax,8),%xmm1
movsd  (%rcx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
lea    0x1(%rax),%rsi
not    %rax
cmp    0x78(%rsp),%rax
je     19aa <o_gaussj+0x85a>
xchg   %ax,%ax
movsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdx,%rsi,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm2,(%rdx,%rsi,8)
movsd  0x8(%rcx,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r14
jne    1970 <o_gaussj+0x820>
test   %r15d,%r15d
jle    1890 <o_gaussj+0x740>
mov    0x50(%rsp),%rax
mov    (%rax,%r10,8),%rdx
mov    (%rax,%r12,8),%rsi
mov    $0x1,%r11d
cmpq   $0x4,0x18(%rsp)
jae    19d8 <o_gaussj+0x888>
mov    0x8(%rsp),%rdi
jmp    1a70 <o_gaussj+0x920>
lea    0x8(%rsi),%r15
mov    0x8(%rsp),%rdi
lea    (%rdx,%rdi,8),%rax
cmp    %rax,%r15
mov    0x38(%rsp),%r15
jae    1a01 <o_gaussj+0x8b1>
lea    (%rsi,%rdi,8),%r15
lea    0x8(%rdx),%rax
cmp    %r15,%rax
mov    0x38(%rsp),%r15
jb     1a70 <o_gaussj+0x920>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
mov    0x28(%rsp),%rdi
movupd 0x8(%rdx,%rax,8),%xmm2
movupd 0x18(%rdx,%rax,8),%xmm3
movupd 0x8(%rsi,%rax,8),%xmm4
movupd 0x18(%rsi,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x8(%rsi,%rax,8)
movupd %xmm5,0x18(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1a10 <o_gaussj+0x8c0>
mov    0x40(%rsp),%r11
cmp    %rdi,0x18(%rsp)
mov    0x8(%rsp),%rdi
je     1890 <o_gaussj+0x740>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,%rax
test   $0x1,%dil
jne    1a97 <o_gaussj+0x947>
movsd  (%rsi,%r11,8),%xmm1
movsd  (%rdx,%r11,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%r11,8)
lea    0x1(%r11),%rax
not    %r11
cmp    0x70(%rsp),%r11
mov    0x8(%rsp),%rdi
je     1890 <o_gaussj+0x740>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rsi,%rax,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%rsi,%rax,8),%xmm1
movsd  %xmm2,(%rsi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1ab0 <o_gaussj+0x960>
jmp    1890 <o_gaussj+0x740>
cmpl   $0x0,(%rsp)
mov    0x68(%rsp),%r15
mov    0x60(%rsp),%r12
jle    1bd3 <o_gaussj+0xa83>
cmpl   $0x0,0x24(%rsp)
jne    1bd3 <o_gaussj+0xa83>
mov    0x10(%rsp),%r8
mov    %r8d,%eax
and    $0xfffffffe,%eax
neg    %rax
jmp    1b31 <o_gaussj+0x9e1>
xchg   %ax,%ax
lea    -0x1(%r8),%rcx
cmp    $0x1,%r8
mov    %rcx,%r8
jle    1bd3 <o_gaussj+0xa83>
movslq (%r12,%r8,4),%rdx
movslq (%r15,%r8,4),%rsi
cmp    %esi,%edx
je     1b20 <o_gaussj+0x9d0>
mov    $0x1,%edi
cmp    $0x2,%r14d
je     1ba3 <o_gaussj+0xa53>
mov    $0x1,%edi
nopl   (%rax)
mov    (%rbx,%rdi,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
mov    0x8(%rbx,%rdi,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
lea    (%rax,%rdi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdi
cmp    $0x1,%rcx
jne    1b50 <o_gaussj+0xa00>
testb  $0x1,0x10(%rsp)
je     1b20 <o_gaussj+0x9d0>
mov    (%rbx,%rdi,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
jmp    1b20 <o_gaussj+0x9d0>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    (%rsp),%ebx
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <free_ivector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <free_ivector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <free_ivector@plt>

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

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