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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float fabs(float);
int /*<<< orphan*/ free_ivector(int *, int /*<<< orphan*/, int);
int *ivector(int /*<<< orphan*/, int);
int nrerror_return(char *);
int gaussj(float **a, int n, float **b, int m) {
  int *indxc, *indxr, *ipiv;
  int i, icol = -1, irow = -1, j, k, l, ll;
  float big, dum, pivinv;
  indxc = ivector(0, n - 1);
  indxr = ivector(0, n - 1);
  ipiv = ivector(0, n - 1);
  for (j = 0; j < n; j++)
    ipiv[j] = 0;
  for (i = 0; i < n; i++) {
    big = 0.0;
    for (j = 0; j < n; j++)
      if (ipiv[j] != 1)
        for (k = 0; 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)
            return (nrerror_return("GAUSSJ: Singular Matrix-1"));
        }
    ++(ipiv[icol]);
    if (irow != icol) {
      for (l = 0; l < n; l++) {
        float temp = (a[irow][l]);
        (a[irow][l]) = (a[icol][l]);
        (a[icol][l]) = temp;
      }
      for (l = 0; 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)
      return (nrerror_return("GAUSSJ: Singular Matrix-2"));
    pivinv = 1.0 / a[icol][icol];
    a[icol][icol] = 1.0;
    for (l = 0; l < n; l++)
      a[icol][l] *= pivinv;
    for (l = 0; l < m; l++)
      b[icol][l] *= pivinv;
    for (ll = 0; ll < n; ll++)
      if (ll != icol) {
        dum = a[ll][icol];
        a[ll][icol] = 0.0;
        for (l = 0; l < n; l++)
          a[ll][l] -= a[icol][l] * dum;
        for (l = 0; l < m; l++)
          b[ll][l] -= b[icol][l] * dum;
      }
  }
  for (l = n - 1; l >= 0; l--) {
    if (indxr[l] != indxc[l])
      for (k = 0; 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, 0, n - 1);
  free_ivector(indxr, 0, n - 1);
  free_ivector(indxc, 0, n - 1);
  return (0);
}


x86 assembly (clang, -O0):
<gaussj>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movl   $0xffffffff,-0x48(%rbp)
movl   $0xffffffff,-0x4c(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1060 <ivector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1060 <ivector@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1060 <ivector@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ca <gaussj+0x8a>
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11a1 <gaussj+0x61>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1672 <gaussj+0x532>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d9 <gaussj+0x199>
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     12c6 <gaussj+0x186>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12c1 <gaussj+0x181>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1283 <gaussj+0x143>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
ucomiss -0x60(%rbp),%xmm0
jb     127e <gaussj+0x13e>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    12ae <gaussj+0x16e>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    12a9 <gaussj+0x169>
lea    0xd74(%rip),%rdi
call   1040 <nrerror_return@plt>
mov    %eax,-0x4(%rbp)
jmp    1792 <gaussj+0x652>
jmp    12ae <gaussj+0x16e>
jmp    12b3 <gaussj+0x173>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1211 <gaussj+0xd1>
jmp    12c6 <gaussj+0x186>
jmp    12cb <gaussj+0x18b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11ec <gaussj+0xac>
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     13f9 <gaussj+0x2b9>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1375 <gaussj+0x235>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12fd <gaussj+0x1bd>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13f4 <gaussj+0x2b4>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    137c <gaussj+0x23c>
jmp    13f9 <gaussj+0x2b9>
mov    -0x4c(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1455 <gaussj+0x315>
jp     1455 <gaussj+0x315>
lea    0xbe2(%rip),%rdi
call   1040 <nrerror_return@plt>
mov    %eax,-0x4(%rbp)
jmp    1792 <gaussj+0x652>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb92(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  0xb65(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14e0 <gaussj+0x3a0>
movss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14a7 <gaussj+0x367>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1520 <gaussj+0x3e0>
movss  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14e7 <gaussj+0x3a7>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    165f <gaussj+0x51f>
mov    -0x5c(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     164c <gaussj+0x50c>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15dc <gaussj+0x49c>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x64(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1578 <gaussj+0x438>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1647 <gaussj+0x507>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x64(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15e3 <gaussj+0x4a3>
jmp    164c <gaussj+0x50c>
jmp    1651 <gaussj+0x511>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1527 <gaussj+0x3e7>
jmp    1664 <gaussj+0x524>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11d1 <gaussj+0x91>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x58(%rbp)
jl     1758 <gaussj+0x618>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     1745 <gaussj+0x605>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1740 <gaussj+0x600>
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    16a8 <gaussj+0x568>
jmp    1745 <gaussj+0x605>
jmp    174a <gaussj+0x60a>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    167b <gaussj+0x53b>
mov    -0x40(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <free_ivector@plt>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <free_ivector@plt>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <free_ivector@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussj>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %ecx,%r13d
mov    %rdx,0x58(%rsp)
mov    %esi,%ebx
mov    %rdi,0x10(%rsp)
lea    -0x1(%rbx),%ebp
xor    %edi,%edi
mov    %ebp,%esi
call   1060 <ivector@plt>
mov    %rax,%r12
xor    %edi,%edi
mov    %ebp,%esi
call   1060 <ivector@plt>
mov    %rax,%r14
xor    %edi,%edi
mov    %ebp,0x4(%rsp)
mov    %ebp,%esi
call   1060 <ivector@plt>
mov    %rax,%rbp
test   %ebx,%ebx
jle    1b82 <gaussj+0xa42>
mov    %r14,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %rbx,0x8(%rsp)
mov    %ebx,%r15d
lea    0x0(,%r15,4),%rdx
xor    %r12d,%r12d
mov    %rbp,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r13d,(%rsp)
mov    %r13d,%r9d
mov    %r15d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%r10
mov    %r10,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
lea    -0x1(%r15),%rsi
mov    %r9d,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x40(%rsp)
mov    %rdx,%rax
mov    %rdx,0x48(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x38(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x78(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x90(%rsp)
mov    $0xffffffff,%r8d
xorps  %xmm8,%xmm8
movss  0xdce(%rip),%xmm9
movaps 0xdb7(%rip),%xmm2
mov    $0xffffffff,%r11d
mov    0x10(%rsp),%r13
xor    %eax,%eax
xorps  %xmm3,%xmm3
jmp    1269 <gaussj+0x129>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r15,%rax
je     12b7 <gaussj+0x177>
cmpl   $0x1,0x0(%rbp,%rax,4)
je     1260 <gaussj+0x120>
xor    %edx,%edx
jmp    1292 <gaussj+0x152>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x2,%ecx
jge    1ac9 <gaussj+0x989>
add    $0x1,%rdx
cmp    %rdx,%r15
je     1260 <gaussj+0x120>
mov    0x0(%rbp,%rdx,4),%ecx
test   %ecx,%ecx
jne    1280 <gaussj+0x140>
mov    0x0(%r13,%rax,8),%rcx
movss  (%rcx,%rdx,4),%xmm4
andps  %xmm2,%xmm4
ucomiss %xmm3,%xmm4
jb     1289 <gaussj+0x149>
movaps %xmm4,%xmm3
mov    %eax,%r11d
mov    %edx,%r8d
jmp    1289 <gaussj+0x149>
mov    %rsi,0x60(%rsp)
movslq %r8d,%rax
addl   $0x1,0x0(%rbp,%rax,4)
mov    %rax,%r14
cmp    %eax,%r11d
mov    %rdi,0x18(%rsp)
je     155a <gaussj+0x41a>
movslq %r11d,%rax
mov    0x0(%r13,%rax,8),%rdx
mov    0x0(%r13,%r14,8),%rsi
cmpl   $0x8,0x8(%rsp)
jb     12fb <gaussj+0x1bb>
lea    (%rsi,%r15,4),%rcx
cmp    %rcx,%rdx
jae    136a <gaussj+0x22a>
lea    (%rdx,%r15,4),%rcx
cmp    %rcx,%rsi
jae    136a <gaussj+0x22a>
xor    %edi,%edi
mov    %rdi,%rcx
test   $0x1,%r15b
je     1321 <gaussj+0x1e1>
movss  (%rdx,%rdi,4),%xmm3
movss  (%rsi,%rdi,4),%xmm4
movss  %xmm4,(%rdx,%rdi,4)
movss  %xmm3,(%rsi,%rdi,4)
mov    %rdi,%rcx
or     $0x1,%rcx
cmp    %rdi,0x60(%rsp)
je     1411 <gaussj+0x2d1>
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm3
movss  (%rsi,%rcx,4),%xmm4
movss  %xmm4,(%rdx,%rcx,4)
movss  %xmm3,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm3
movss  0x4(%rsi,%rcx,4),%xmm4
movss  %xmm4,0x4(%rdx,%rcx,4)
movss  %xmm3,0x4(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    1330 <gaussj+0x1f0>
jmp    1411 <gaussj+0x2d1>
test   %r10,%r10
je     13d8 <gaussj+0x298>
mov    0x40(%rsp),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups (%rdx,%rdi,4),%xmm3
movups 0x10(%rdx,%rdi,4),%xmm4
movups (%rsi,%rdi,4),%xmm5
movups 0x10(%rsi,%rdi,4),%xmm6
movups %xmm5,(%rdx,%rdi,4)
movups %xmm6,0x10(%rdx,%rdi,4)
movups %xmm3,(%rsi,%rdi,4)
movups %xmm4,0x10(%rsi,%rdi,4)
movups 0x20(%rdx,%rdi,4),%xmm3
movups 0x30(%rdx,%rdi,4),%xmm4
movups 0x20(%rsi,%rdi,4),%xmm5
movups 0x30(%rsi,%rdi,4),%xmm6
movups %xmm5,0x20(%rdx,%rdi,4)
movups %xmm6,0x30(%rdx,%rdi,4)
movups %xmm3,0x20(%rsi,%rdi,4)
movups %xmm4,0x30(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1380 <gaussj+0x240>
jmp    13da <gaussj+0x29a>
xor    %edi,%edi
testb  $0x1,0x20(%rsp)
je     1405 <gaussj+0x2c5>
movups (%rdx,%rdi,4),%xmm3
movups 0x10(%rdx,%rdi,4),%xmm4
movups (%rsi,%rdi,4),%xmm5
movups 0x10(%rsi,%rdi,4),%xmm6
movups %xmm5,(%rdx,%rdi,4)
movups %xmm6,0x10(%rdx,%rdi,4)
movups %xmm3,(%rsi,%rdi,4)
movups %xmm4,0x10(%rsi,%rdi,4)
mov    %rbx,%rdi
cmp    %r15,%rbx
jne    12fd <gaussj+0x1bd>
cmpl   $0x0,(%rsp)
mov    0x18(%rsp),%rdi
jle    155a <gaussj+0x41a>
mov    0x58(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    %r14,%rdx
mov    (%rcx,%r14,8),%rdx
cmpl   $0x8,(%rsp)
jb     1448 <gaussj+0x308>
lea    (%rdx,%r9,4),%rcx
cmp    %rcx,%rax
jae    14ba <gaussj+0x37a>
lea    (%rax,%r9,4),%rcx
cmp    %rcx,%rdx
jae    14ba <gaussj+0x37a>
xor    %esi,%esi
mov    %rsi,%rcx
test   $0x1,%r9b
je     146e <gaussj+0x32e>
movss  (%rax,%rsi,4),%xmm3
movss  (%rdx,%rsi,4),%xmm4
movss  %xmm4,(%rax,%rsi,4)
movss  %xmm3,(%rdx,%rsi,4)
mov    %rsi,%rcx
or     $0x1,%rcx
not    %rsi
cmp    0x78(%rsp),%rsi
je     155a <gaussj+0x41a>
nopl   0x0(%rax)
movss  (%rax,%rcx,4),%xmm3
movss  (%rdx,%rcx,4),%xmm4
movss  %xmm4,(%rax,%rcx,4)
movss  %xmm3,(%rdx,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm3
movss  0x4(%rdx,%rcx,4),%xmm4
movss  %xmm4,0x4(%rax,%rcx,4)
movss  %xmm3,0x4(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1480 <gaussj+0x340>
jmp    155a <gaussj+0x41a>
cmpq   $0x0,0x50(%rsp)
je     1521 <gaussj+0x3e1>
mov    0x38(%rsp),%rcx
xor    %esi,%esi
movups (%rax,%rsi,4),%xmm3
movups 0x10(%rax,%rsi,4),%xmm4
movups (%rdx,%rsi,4),%xmm5
movups 0x10(%rdx,%rsi,4),%xmm6
movups %xmm5,(%rax,%rsi,4)
movups %xmm6,0x10(%rax,%rsi,4)
movups %xmm3,(%rdx,%rsi,4)
movups %xmm4,0x10(%rdx,%rsi,4)
movups 0x20(%rax,%rsi,4),%xmm3
movups 0x30(%rax,%rsi,4),%xmm4
movups 0x20(%rdx,%rsi,4),%xmm5
movups 0x30(%rdx,%rsi,4),%xmm6
movups %xmm5,0x20(%rax,%rsi,4)
movups %xmm6,0x30(%rax,%rsi,4)
movups %xmm3,0x20(%rdx,%rsi,4)
movups %xmm4,0x30(%rdx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    14c9 <gaussj+0x389>
jmp    1523 <gaussj+0x3e3>
xor    %esi,%esi
testb  $0x1,0x48(%rsp)
je     154e <gaussj+0x40e>
movups (%rax,%rsi,4),%xmm3
movups 0x10(%rax,%rsi,4),%xmm4
movups (%rdx,%rsi,4),%xmm5
movups 0x10(%rdx,%rsi,4),%xmm6
movups %xmm5,(%rax,%rsi,4)
movups %xmm6,0x10(%rax,%rsi,4)
movups %xmm3,(%rdx,%rsi,4)
movups %xmm4,0x10(%rdx,%rsi,4)
mov    %rdi,%rsi
cmp    %r9,%rdi
jne    144a <gaussj+0x30a>
mov    0x28(%rsp),%rax
mov    %r11d,(%rax,%r12,4)
mov    0x30(%rsp),%rax
mov    %r14,%rsi
mov    %esi,(%rax,%r12,4)
mov    0x0(%r13,%r14,8),%rax
movss  (%rax,%r14,4),%xmm4
ucomiss %xmm8,%xmm4
jne    1586 <gaussj+0x446>
jnp    1bbe <gaussj+0xa7e>
movaps %xmm9,%xmm3
divss  %xmm4,%xmm3
movl   $0x3f800000,(%rax,%rsi,4)
cmpl   $0x8,0x8(%rsp)
jae    15a3 <gaussj+0x463>
xor    %ecx,%ecx
jmp    1630 <gaussj+0x4f0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
test   %r10,%r10
je     15fe <gaussj+0x4be>
mov    0x40(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rdx,4),%xmm5
movups 0x10(%rax,%rdx,4),%xmm6
movups 0x20(%rax,%rdx,4),%xmm7
movups 0x30(%rax,%rdx,4),%xmm0
mulps  %xmm4,%xmm5
mulps  %xmm4,%xmm6
movups %xmm5,(%rax,%rdx,4)
movups %xmm6,0x10(%rax,%rdx,4)
mulps  %xmm4,%xmm7
mulps  %xmm4,%xmm0
movups %xmm7,0x20(%rax,%rdx,4)
movups %xmm0,0x30(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    15c0 <gaussj+0x480>
jmp    1600 <gaussj+0x4c0>
xor    %edx,%edx
testb  $0x1,0x20(%rsp)
je     161f <gaussj+0x4df>
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm5
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,(%rax,%rdx,4)
movups %xmm5,0x10(%rax,%rdx,4)
mov    %rbx,%rcx
cmp    %r15,%rbx
je     1647 <gaussj+0x507>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1630 <gaussj+0x4f0>
mov    %r10,0x68(%rsp)
cmpl   $0x0,(%rsp)
jle    1717 <gaussj+0x5d7>
mov    0x58(%rsp),%rcx
mov    (%rcx,%rsi,8),%rdx
cmpl   $0x8,(%rsp)
jae    166c <gaussj+0x52c>
xor    %ecx,%ecx
jmp    1700 <gaussj+0x5c0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x0,0x50(%rsp)
je     16ce <gaussj+0x58e>
mov    0x38(%rsp),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm5
movups 0x20(%rdx,%rsi,4),%xmm6
movups 0x30(%rdx,%rsi,4),%xmm7
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,(%rdx,%rsi,4)
movups %xmm5,0x10(%rdx,%rsi,4)
mulps  %xmm4,%xmm6
mulps  %xmm4,%xmm7
movups %xmm6,0x20(%rdx,%rsi,4)
movups %xmm7,0x30(%rdx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1690 <gaussj+0x550>
jmp    16d0 <gaussj+0x590>
xor    %esi,%esi
testb  $0x1,0x48(%rsp)
je     16ef <gaussj+0x5af>
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm5
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,(%rdx,%rsi,4)
movups %xmm5,0x10(%rdx,%rsi,4)
mov    %rdi,%rcx
cmp    %r9,%rdi
je     1717 <gaussj+0x5d7>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    1700 <gaussj+0x5c0>
mov    %rbx,0x70(%rsp)
mov    %r12,0x80(%rsp)
mov    %r8d,%r10d
lea    (%rax,%r15,4),%rcx
mov    %rcx,0x88(%rsp)
xor    %edx,%edx
mov    0x20(%rsp),%r12
jmp    174d <gaussj+0x60d>
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    %r15,%rdx
je     1a7b <gaussj+0x93b>
cmp    %r10,%rdx
je     1740 <gaussj+0x600>
mov    0x0(%r13,%rdx,8),%r13
mov    %r14,%rcx
movss  0x0(%r13,%r14,4),%xmm3
movl   $0x0,0x0(%r13,%r14,4)
cmpl   $0x8,0x8(%rsp)
jb     1793 <gaussj+0x653>
cmp    0x88(%rsp),%r13
jae    1825 <gaussj+0x6e5>
lea    0x0(,%r15,4),%rcx
add    %r13,%rcx
cmp    %rcx,%rax
jae    1825 <gaussj+0x6e5>
xor    %esi,%esi
mov    %rsi,%rcx
test   $0x1,%r15b
je     17c0 <gaussj+0x680>
movss  0x0(%r13,%rsi,4),%xmm0
movss  (%rax,%rsi,4),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rsi,4)
mov    %rsi,%rcx
or     $0x1,%rcx
not    %rsi
cmp    0x90(%rsp),%rsi
je     18f0 <gaussj+0x7b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
movss  0x0(%r13,%rcx,4),%xmm1
subss  %xmm0,%xmm1
movss  0x4(%r13,%rcx,4),%xmm0
movss  %xmm1,0x0(%r13,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%r13,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    17e0 <gaussj+0x6a0>
jmp    18f0 <gaussj+0x7b0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x0,0x68(%rsp)
je     1a5f <gaussj+0x91f>
mov    0x40(%rsp),%rdi
xor    %esi,%esi
nop
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm5
mulps  %xmm4,%xmm0
movups 0x0(%r13,%rsi,4),%xmm6
subps  %xmm0,%xmm6
movups 0x10(%r13,%rsi,4),%xmm0
movups 0x20(%r13,%rsi,4),%xmm7
movups 0x30(%r13,%rsi,4),%xmm1
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm0
movups %xmm6,0x0(%r13,%rsi,4)
movups %xmm0,0x10(%r13,%rsi,4)
movups 0x20(%rax,%rsi,4),%xmm0
movups 0x30(%rax,%rsi,4),%xmm5
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm7
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm1
movups %xmm7,0x20(%r13,%rsi,4)
movups %xmm1,0x30(%r13,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1840 <gaussj+0x700>
test   $0x1,%r12b
je     18d8 <gaussj+0x798>
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movups 0x0(%r13,%rsi,4),%xmm5
movups 0x10(%r13,%rsi,4),%xmm6
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm5
mulps  %xmm4,%xmm1
subps  %xmm1,%xmm6
movups %xmm5,0x0(%r13,%rsi,4)
movups %xmm6,0x10(%r13,%rsi,4)
mov    0x70(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r15,%rcx
jne    1795 <gaussj+0x655>
nopl   0x0(%rax)
mov    (%rsp),%ecx
test   %ecx,%ecx
mov    0x10(%rsp),%r13
jle    1740 <gaussj+0x600>
mov    0x58(%rsp),%rdi
mov    (%rdi,%r14,8),%rsi
mov    (%rdi,%rdx,8),%rdi
cmp    $0x8,%ecx
jb     1928 <gaussj+0x7e8>
lea    (%rsi,%r9,4),%rcx
cmp    %rcx,%rdi
jae    199f <gaussj+0x85f>
lea    (%rdi,%r9,4),%rcx
cmp    %rcx,%rsi
jae    199f <gaussj+0x85f>
xor    %ebx,%ebx
mov    %rbx,%rcx
test   $0x1,%r9b
je     1951 <gaussj+0x811>
movss  (%rdi,%rbx,4),%xmm0
movss  (%rsi,%rbx,4),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rbx,4)
mov    %rbx,%rcx
or     $0x1,%rcx
not    %rbx
cmp    0x78(%rsp),%rbx
je     1740 <gaussj+0x600>
nop
movss  (%rsi,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
movss  (%rdi,%rcx,4),%xmm1
subss  %xmm0,%xmm1
movss  0x4(%rdi,%rcx,4),%xmm0
movss  %xmm1,(%rdi,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1960 <gaussj+0x820>
jmp    1740 <gaussj+0x600>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x0,0x50(%rsp)
je     1a70 <gaussj+0x930>
mov    0x38(%rsp),%rcx
xor    %ebx,%ebx
nopl   0x0(%rax)
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
mulps  %xmm4,%xmm0
movups (%rdi,%rbx,4),%xmm5
subps  %xmm0,%xmm5
movups 0x10(%rdi,%rbx,4),%xmm0
movups 0x20(%rdi,%rbx,4),%xmm6
movups 0x30(%rdi,%rbx,4),%xmm7
mulps  %xmm4,%xmm1
subps  %xmm1,%xmm0
movups %xmm5,(%rdi,%rbx,4)
movups %xmm0,0x10(%rdi,%rbx,4)
movups 0x20(%rsi,%rbx,4),%xmm0
movups 0x30(%rsi,%rbx,4),%xmm1
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm6
mulps  %xmm4,%xmm1
subps  %xmm1,%xmm7
movups %xmm6,0x20(%rdi,%rbx,4)
movups %xmm7,0x30(%rdi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rcx
jne    19c0 <gaussj+0x880>
testb  $0x1,0x48(%rsp)
je     1a49 <gaussj+0x909>
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups (%rdi,%rbx,4),%xmm5
movups 0x10(%rdi,%rbx,4),%xmm6
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm5
mulps  %xmm4,%xmm1
subps  %xmm1,%xmm6
movups %xmm5,(%rdi,%rbx,4)
movups %xmm6,0x10(%rdi,%rbx,4)
mov    0x18(%rsp),%rcx
mov    %rcx,%rbx
cmp    %r9,%rcx
je     1740 <gaussj+0x600>
jmp    192a <gaussj+0x7ea>
xor    %esi,%esi
test   $0x1,%r12b
jne    18ab <gaussj+0x76b>
jmp    18d8 <gaussj+0x798>
xor    %ebx,%ebx
testb  $0x1,0x48(%rsp)
jne    1a22 <gaussj+0x8e2>
jmp    1a49 <gaussj+0x909>
mov    0x80(%rsp),%r12
add    $0x1,%r12
cmp    %r15,%r12
mov    0x70(%rsp),%rbx
mov    0x68(%rsp),%r10
mov    0x60(%rsp),%rsi
mov    0x18(%rsp),%rdi
jne    1254 <gaussj+0x114>
cmpl   $0x0,0x8(%rsp)
mov    0x30(%rsp),%r12
mov    0x28(%rsp),%r14
jle    1b82 <gaussj+0xa42>
mov    %rsi,%r8
mov    0x4(%rsp),%r9d
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
jmp    1b00 <gaussj+0x9c0>
lea    0x544(%rip),%rdi
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <nrerror_return@plt>
lea    -0x1(%r9),%rdx
test   %r9,%r9
mov    %rdx,%r9
mov    0x30(%rsp),%r12
mov    0x28(%rsp),%r14
jle    1b82 <gaussj+0xa42>
movslq (%r14,%r9,4),%rdx
movslq (%r12,%r9,4),%rsi
cmp    %esi,%edx
je     1ae6 <gaussj+0x9a6>
mov    %r8,%rdi
xor    %edi,%edi
test   %r8,%r8
je     1b5a <gaussj+0xa1a>
mov    0x10(%rsp),%rax
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rdi,8),%rbx
movss  (%rbx,%rdx,4),%xmm0
movss  (%rbx,%rsi,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
movss  %xmm0,(%rbx,%rsi,4)
mov    0x8(%rax,%rdi,8),%rbx
movss  (%rbx,%rdx,4),%xmm0
movss  (%rbx,%rsi,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
movss  %xmm0,(%rbx,%rsi,4)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1b20 <gaussj+0x9e0>
test   $0x1,%r15b
je     1ae6 <gaussj+0x9a6>
mov    0x10(%rsp),%rax
mov    (%rax,%rdi,8),%rdi
movss  (%rdi,%rdx,4),%xmm0
movss  (%rdi,%rsi,4),%xmm1
movss  %xmm1,(%rdi,%rdx,4)
movss  %xmm0,(%rdi,%rsi,4)
jmp    1ae6 <gaussj+0x9a6>
mov    %rbp,%rdi
xor    %esi,%esi
mov    0x4(%rsp),%ebx
mov    %ebx,%edx
call   1050 <free_ivector@plt>
mov    %r14,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1050 <free_ivector@plt>
mov    %r12,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1050 <free_ivector@plt>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x469(%rip),%rdi
jmp    1ad0 <gaussj+0x990>

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

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