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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ exit(int);
float fabs(float);
int /*<<< orphan*/ free_ivector(int *, int, int);
int *ivector(int, int);
int /*<<< orphan*/ printf(char *);
void gaussj(float **a, int n, float **b, int m) {
  int *indxc, *indxr, *ipiv;
  int i, icol = 0, irow = 0, j, k, l, ll;
  float big, dum, pivinv, temp;
  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) {
            printf("gaussj: Singular Matrix-1");
            exit(1);
          }
        }
    ++(ipiv[icol]);
    if (irow != icol) {
      for (l = 1; l <= n; l++) {
        temp = (a[irow][l]);
        (a[irow][l]) = (a[icol][l]);
        (a[icol][l]) = temp;
      }
      for (l = 1; l <= m; l++) {
        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) {
      printf("gaussj: Singular Matrix-2");
      exit(1);
    }
    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;
      }
  }
  for (l = n; l >= 1; l--) {
    if (indxr[l] != indxc[l])
      for (k = 1; k <= n; k++) {
        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):
<gaussj>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1060 <ivector@plt>
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1060 <ivector@plt>
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1060 <ivector@plt>
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11d7 <gaussj+0x87>
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 <gaussj+0x5e>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1683 <gaussj+0x533>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12e8 <gaussj+0x198>
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     12d5 <gaussj+0x185>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12d0 <gaussj+0x180>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1290 <gaussj+0x140>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
ucomiss -0x58(%rbp),%xmm0
jb     128b <gaussj+0x13b>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    12bd <gaussj+0x16d>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    12b8 <gaussj+0x168>
lea    0xd67(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
jmp    12bd <gaussj+0x16d>
jmp    12c2 <gaussj+0x172>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    121e <gaussj+0xce>
jmp    12d5 <gaussj+0x185>
jmp    12da <gaussj+0x18a>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11f9 <gaussj+0xa9>
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     1408 <gaussj+0x2b8>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1384 <gaussj+0x234>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    130c <gaussj+0x1bc>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1403 <gaussj+0x2b3>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    138b <gaussj+0x23b>
jmp    1408 <gaussj+0x2b8>
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
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1466 <gaussj+0x316>
jp     1466 <gaussj+0x316>
lea    0xbd3(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb81(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  0xb54(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14f1 <gaussj+0x3a1>
movss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    14b8 <gaussj+0x368>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1531 <gaussj+0x3e1>
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    14f8 <gaussj+0x3a8>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1670 <gaussj+0x520>
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     165d <gaussj+0x50d>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     15ed <gaussj+0x49d>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x5c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%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    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1589 <gaussj+0x439>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1658 <gaussj+0x508>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x5c(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%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    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15f4 <gaussj+0x4a4>
jmp    165d <gaussj+0x50d>
jmp    1662 <gaussj+0x512>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1538 <gaussj+0x3e8>
jmp    1675 <gaussj+0x525>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11de <gaussj+0x8e>
mov    -0xc(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x1,-0x50(%rbp)
jl     1766 <gaussj+0x616>
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     1753 <gaussj+0x603>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     174e <gaussj+0x5fe>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%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
movss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16b6 <gaussj+0x566>
jmp    1753 <gaussj+0x603>
jmp    1758 <gaussj+0x608>
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
jmp    1689 <gaussj+0x539>
mov    -0x38(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_ivector@plt>
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_ivector@plt>
mov    -0x28(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_ivector@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussj>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %ecx,%r15d
mov    %rdx,0x48(%rsp)
mov    %esi,%r14d
mov    %rdi,%rbp
mov    $0x1,%edi
call   1060 <ivector@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1060 <ivector@plt>
mov    %rax,0x20(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1060 <ivector@plt>
mov    %rax,%rbx
test   %r14d,%r14d
jle    1b5d <gaussj+0xa0d>
mov    %rbx,%rdi
add    $0x4,%rdi
mov    %r14d,0x54(%rsp)
mov    %r14d,%r14d
lea    0x0(,%r14,4),%rdx
xor    %r12d,%r12d
xor    %esi,%esi
call   1040 <memset@plt>
lea    0x1(%r14),%rax
mov    %r15,%rcx
mov    %r15,0x98(%rsp)
add    $0x1,%r15d
lea    -0x1(%r15),%rcx
lea    -0x8(%r14),%rdx
mov    %rdx,0x80(%rsp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
lea    -0x9(%r15),%rdx
mov    %rdx,0x70(%rsp)
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r14d,%r13d
and    $0xfffffff8,%r13d
lea    0x1(%r13),%rdx
mov    %rdx,0x40(%rsp)
mov    %rsi,%rdx
mov    %rsi,0x78(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x60(%rsp)
mov    %r14,0x8(%rsp)
not    %r14
mov    %r14,0x90(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rcx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    0x1(%rsi),%rcx
mov    %rcx,0x30(%rsp)
mov    %rdi,%rcx
mov    %rdi,0x68(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x58(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x88(%rsp)
xorps  %xmm8,%xmm8
movss  0xd93(%rip),%xmm1
movaps 0xd7c(%rip),%xmm2
mov    $0x1,%r11d
xor    %r8d,%r8d
mov    %rsi,0x38(%rsp)
jmp    12b5 <gaussj+0x165>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa0(%rsp),%r11
add    $0x1,%r11
cmp    %rax,%r11
je     1a8f <gaussj+0x93f>
mov    $0x1,%edx
xorps  %xmm3,%xmm3
mov    0x98(%rsp),%r14
jmp    12d9 <gaussj+0x189>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %rax,%rdx
je     1330 <gaussj+0x1e0>
cmpl   $0x1,(%rbx,%rdx,4)
je     12d0 <gaussj+0x180>
mov    $0x1,%edi
jmp    1302 <gaussj+0x1b2>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x2,%ecx
jge    1ba2 <gaussj+0xa52>
add    $0x1,%rdi
cmp    %rdi,%rax
je     12d0 <gaussj+0x180>
mov    (%rbx,%rdi,4),%ecx
test   %ecx,%ecx
jne    12f0 <gaussj+0x1a0>
mov    0x0(%rbp,%rdx,8),%rcx
movss  (%rcx,%rdi,4),%xmm4
andps  %xmm2,%xmm4
ucomiss %xmm3,%xmm4
jb     12f9 <gaussj+0x1a9>
mov    %edx,%r8d
movaps %xmm4,%xmm3
mov    %edi,%r12d
jmp    12f9 <gaussj+0x1a9>
cs nopw 0x0(%rax,%rax,1)
movslq %r12d,%r10
addl   $0x1,(%rbx,%r10,4)
cmp    %r10d,%r8d
mov    %r10,0x18(%rsp)
je     1620 <gaussj+0x4d0>
movslq %r8d,%r9
mov    0x0(%rbp,%r9,8),%rdx
mov    0x0(%rbp,%r10,8),%rdi
mov    $0x1,%esi
cmpl   $0x8,0x8(%rsp)
jb     1450 <gaussj+0x300>
lea    0x4(%rdx),%r10
lea    (%rdi,%rax,4),%rcx
cmp    %rcx,%r10
mov    0x18(%rsp),%r10
jae    138b <gaussj+0x23b>
lea    (%rdx,%rax,4),%r10
lea    0x4(%rdi),%rcx
cmp    %r10,%rcx
mov    0x18(%rsp),%r10
jb     1450 <gaussj+0x300>
cmpq   $0x8,0x80(%rsp)
jae    139a <gaussj+0x24a>
xor    %esi,%esi
jmp    140a <gaussj+0x2ba>
mov    0x60(%rsp),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%rdx,%rsi,4),%xmm3
movups 0x14(%rdx,%rsi,4),%xmm4
movups 0x4(%rdi,%rsi,4),%xmm5
movups 0x14(%rdi,%rsi,4),%xmm6
movups %xmm5,0x4(%rdx,%rsi,4)
movups %xmm6,0x14(%rdx,%rsi,4)
movups %xmm3,0x4(%rdi,%rsi,4)
movups %xmm4,0x14(%rdi,%rsi,4)
movups 0x24(%rdx,%rsi,4),%xmm3
movups 0x34(%rdx,%rsi,4),%xmm4
movups 0x24(%rdi,%rsi,4),%xmm5
movups 0x34(%rdi,%rsi,4),%xmm6
movups %xmm5,0x24(%rdx,%rsi,4)
movups %xmm6,0x34(%rdx,%rsi,4)
movups %xmm3,0x24(%rdi,%rsi,4)
movups %xmm4,0x34(%rdi,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    13b0 <gaussj+0x260>
testb  $0x1,0x78(%rsp)
je     143d <gaussj+0x2ed>
shl    $0x2,%rsi
or     $0x4,%rsi
movups (%rdx,%rsi,1),%xmm3
movups 0x10(%rdx,%rsi,1),%xmm4
movups (%rdi,%rsi,1),%xmm5
movups 0x10(%rdi,%rsi,1),%xmm6
movups %xmm5,(%rdx,%rsi,1)
movups %xmm6,0x10(%rdx,%rsi,1)
movups %xmm3,(%rdi,%rsi,1)
movups %xmm4,0x10(%rdi,%rsi,1)
mov    0x40(%rsp),%rsi
cmp    %r13,0x8(%rsp)
je     14b5 <gaussj+0x365>
nopl   0x0(%rax)
mov    %rsi,%rcx
test   $0x1,%al
jne    146f <gaussj+0x31f>
movss  (%rdx,%rsi,4),%xmm3
movss  (%rdi,%rsi,4),%xmm4
movss  %xmm4,(%rdx,%rsi,4)
movss  %xmm3,(%rdi,%rsi,4)
lea    0x1(%rsi),%rcx
not    %rsi
cmp    0x90(%rsp),%rsi
je     14b5 <gaussj+0x365>
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm3
movss  (%rdi,%rcx,4),%xmm4
movss  %xmm4,(%rdx,%rcx,4)
movss  %xmm3,(%rdi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm3
movss  0x4(%rdi,%rcx,4),%xmm4
movss  %xmm4,0x4(%rdx,%rcx,4)
movss  %xmm3,0x4(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1480 <gaussj+0x330>
test   %r14d,%r14d
jle    1620 <gaussj+0x4d0>
mov    0x48(%rsp),%rcx
mov    (%rcx,%r9,8),%rdx
mov    (%rcx,%r10,8),%rdi
mov    $0x1,%esi
cmpq   $0x8,0x10(%rsp)
jb     15b0 <gaussj+0x460>
lea    0x4(%rdx),%r9
lea    (%rdi,%r15,4),%rcx
cmp    %rcx,%r9
jae    14fa <gaussj+0x3aa>
lea    (%rdx,%r15,4),%r9
lea    0x4(%rdi),%rcx
cmp    %r9,%rcx
jb     15b0 <gaussj+0x460>
cmpq   $0x8,0x70(%rsp)
jae    1506 <gaussj+0x3b6>
xor    %esi,%esi
jmp    156a <gaussj+0x41a>
mov    0x58(%rsp),%rcx
xor    %esi,%esi
nopl   (%rax)
movups 0x4(%rdx,%rsi,4),%xmm3
movups 0x14(%rdx,%rsi,4),%xmm4
movups 0x4(%rdi,%rsi,4),%xmm5
movups 0x14(%rdi,%rsi,4),%xmm6
movups %xmm5,0x4(%rdx,%rsi,4)
movups %xmm6,0x14(%rdx,%rsi,4)
movups %xmm3,0x4(%rdi,%rsi,4)
movups %xmm4,0x14(%rdi,%rsi,4)
movups 0x24(%rdx,%rsi,4),%xmm3
movups 0x34(%rdx,%rsi,4),%xmm4
movups 0x24(%rdi,%rsi,4),%xmm5
movups 0x34(%rdi,%rsi,4),%xmm6
movups %xmm5,0x24(%rdx,%rsi,4)
movups %xmm6,0x34(%rdx,%rsi,4)
movups %xmm3,0x24(%rdi,%rsi,4)
movups %xmm4,0x34(%rdi,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1510 <gaussj+0x3c0>
testb  $0x1,0x68(%rsp)
je     159d <gaussj+0x44d>
shl    $0x2,%rsi
or     $0x4,%rsi
movups (%rdx,%rsi,1),%xmm3
movups 0x10(%rdx,%rsi,1),%xmm4
movups (%rdi,%rsi,1),%xmm5
movups 0x10(%rdi,%rsi,1),%xmm6
movups %xmm5,(%rdx,%rsi,1)
movups %xmm6,0x10(%rdx,%rsi,1)
movups %xmm3,(%rdi,%rsi,1)
movups %xmm4,0x10(%rdi,%rsi,1)
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rcx
cmp    %rcx,0x10(%rsp)
je     1620 <gaussj+0x4d0>
xchg   %ax,%ax
mov    %rsi,%rcx
test   $0x1,%r15b
jne    15d1 <gaussj+0x481>
movss  (%rdx,%rsi,4),%xmm3
movss  (%rdi,%rsi,4),%xmm4
movss  %xmm4,(%rdx,%rsi,4)
movss  %xmm3,(%rdi,%rsi,4)
lea    0x1(%rsi),%rcx
not    %rsi
cmp    0x88(%rsp),%rsi
je     1620 <gaussj+0x4d0>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm3
movss  (%rdi,%rcx,4),%xmm4
movss  %xmm4,(%rdx,%rcx,4)
movss  %xmm3,(%rdi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm3
movss  0x4(%rdi,%rcx,4),%xmm4
movss  %xmm4,0x4(%rdx,%rcx,4)
movss  %xmm3,0x4(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    15e0 <gaussj+0x490>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%rcx
mov    %r8d,(%rcx,%r11,4)
mov    0x28(%rsp),%rcx
mov    %r11,0xa0(%rsp)
mov    %r10d,(%rcx,%r11,4)
mov    0x0(%rbp,%r10,8),%r11
movss  (%r11,%r10,4),%xmm4
ucomiss %xmm8,%xmm4
jne    1651 <gaussj+0x501>
jnp    1bb8 <gaussj+0xa68>
movaps %xmm1,%xmm3
divss  %xmm4,%xmm3
movl   $0x3f800000,(%r11,%r10,4)
3f
mov    $0x1,%ecx
cmpl   $0x8,0x8(%rsp)
jb     1720 <gaussj+0x5d0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x8,0x80(%rsp)
jae    1690 <gaussj+0x540>
xor    %edx,%edx
jmp    16e6 <gaussj+0x596>
cs nopw 0x0(%rax,%rax,1)
mov    0x60(%rsp),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x4(%r11,%rdx,4),%xmm5
movups 0x14(%r11,%rdx,4),%xmm6
movups 0x24(%r11,%rdx,4),%xmm7
movups 0x34(%r11,%rdx,4),%xmm0
mulps  %xmm4,%xmm5
mulps  %xmm4,%xmm6
movups %xmm5,0x4(%r11,%rdx,4)
movups %xmm6,0x14(%r11,%rdx,4)
mulps  %xmm4,%xmm7
mulps  %xmm4,%xmm0
movups %xmm7,0x24(%r11,%rdx,4)
movups %xmm0,0x34(%r11,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    16a0 <gaussj+0x550>
testb  $0x1,0x78(%rsp)
je     1711 <gaussj+0x5c1>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%r11,%rdx,1),%xmm0
movups 0x10(%r11,%rdx,1),%xmm5
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,(%r11,%rdx,1)
movups %xmm5,0x10(%r11,%rdx,1)
mov    0x40(%rsp),%rcx
cmp    %r13,0x8(%rsp)
je     1739 <gaussj+0x5e9>
nopl   (%rax)
movss  (%r11,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r11,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1720 <gaussj+0x5d0>
test   %r14d,%r14d
jle    1817 <gaussj+0x6c7>
mov    0x48(%rsp),%rcx
mov    (%rcx,%r10,8),%rdx
mov    $0x1,%ecx
cmpq   $0x8,0x10(%rsp)
jb     1800 <gaussj+0x6b0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x8,0x70(%rsp)
jae    176f <gaussj+0x61f>
xor    %esi,%esi
jmp    17be <gaussj+0x66e>
mov    0x58(%rsp),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups 0x4(%rdx,%rsi,4),%xmm0
movups 0x14(%rdx,%rsi,4),%xmm5
movups 0x24(%rdx,%rsi,4),%xmm6
movups 0x34(%rdx,%rsi,4),%xmm7
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,0x4(%rdx,%rsi,4)
movups %xmm5,0x14(%rdx,%rsi,4)
mulps  %xmm4,%xmm6
mulps  %xmm4,%xmm7
movups %xmm6,0x24(%rdx,%rsi,4)
movups %xmm7,0x34(%rdx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1780 <gaussj+0x630>
testb  $0x1,0x68(%rsp)
je     17e5 <gaussj+0x695>
shl    $0x2,%rsi
or     $0x4,%rsi
movups (%rdx,%rsi,1),%xmm0
movups 0x10(%rdx,%rsi,1),%xmm5
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,(%rdx,%rsi,1)
movups %xmm5,0x10(%rdx,%rsi,1)
mov    0x30(%rsp),%rcx
mov    0x38(%rsp),%rsi
cmp    %rsi,0x10(%rsp)
je     1817 <gaussj+0x6c7>
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1800 <gaussj+0x6b0>
mov    %r12d,%r9d
lea    0x4(%r11),%rcx
mov    %rcx,0xa8(%rsp)
lea    (%r11,%rax,4),%rcx
mov    %rcx,0xb0(%rsp)
mov    $0x1,%r14d
jmp    184d <gaussj+0x6fd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %rax,%r14
je     12a0 <gaussj+0x150>
cmp    %r9,%r14
je     1840 <gaussj+0x6f0>
mov    0x0(%rbp,%r14,8),%rdi
mov    0x18(%rsp),%rcx
movss  (%rdi,%rcx,4),%xmm3
movl   $0x0,(%rdi,%rcx,4)
mov    $0x1,%edx
cmpl   $0x8,0x8(%rsp)
jb     18f0 <gaussj+0x7a0>
lea    0x4(%rdi),%rcx
cmp    0xb0(%rsp),%rcx
jae    1894 <gaussj+0x744>
lea    (%rdi,%rax,4),%rcx
cmp    %rcx,0xa8(%rsp)
jb     18f0 <gaussj+0x7a0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
xor    %ecx,%ecx
nopl   (%rax)
movups 0x4(%r11,%rcx,4),%xmm0
movups 0x14(%r11,%rcx,4),%xmm5
movups 0x4(%rdi,%rcx,4),%xmm6
movups 0x14(%rdi,%rcx,4),%xmm7
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm6
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm7
movups %xmm6,0x4(%rdi,%rcx,4)
movups %xmm7,0x14(%rdi,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%r13
jne    18a0 <gaussj+0x750>
mov    0x40(%rsp),%rdx
cmp    %r13,0x8(%rsp)
je     195c <gaussj+0x80c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rsi
test   $0x1,%al
jne    1913 <gaussj+0x7c3>
movss  (%rdi,%rdx,4),%xmm0
movss  (%r11,%rdx,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,(%rdi,%rdx,4)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0x90(%rsp),%rdx
je     195c <gaussj+0x80c>
movss  (%r11,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  (%rdi,%rsi,4),%xmm4
subss  %xmm0,%xmm4
movss  0x4(%rdi,%rsi,4),%xmm0
movss  %xmm4,(%rdi,%rsi,4)
movss  0x4(%r11,%rsi,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,0x4(%rdi,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1920 <gaussj+0x7d0>
cmpl   $0x0,0x98(%rsp)
jle    1840 <gaussj+0x6f0>
mov    0x48(%rsp),%rcx
mov    0x18(%rsp),%rdx
mov    (%rcx,%rdx,8),%rdi
mov    (%rcx,%r14,8),%rdx
mov    $0x1,%r10d
cmpq   $0x8,0x10(%rsp)
jb     1a10 <gaussj+0x8c0>
lea    0x4(%rdx),%rcx
lea    (%rdi,%r15,4),%rsi
cmp    %rsi,%rcx
jae    19a8 <gaussj+0x858>
lea    (%rdx,%r15,4),%rcx
lea    0x4(%rdi),%rsi
cmp    %rcx,%rsi
jb     1a10 <gaussj+0x8c0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
xor    %ecx,%ecx
mov    0x38(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movups 0x4(%rdi,%rcx,4),%xmm0
movups 0x14(%rdi,%rcx,4),%xmm5
movups 0x4(%rdx,%rcx,4),%xmm6
movups 0x14(%rdx,%rcx,4),%xmm7
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm6
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm7
movups %xmm6,0x4(%rdx,%rcx,4)
movups %xmm7,0x14(%rdx,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    19c0 <gaussj+0x870>
mov    0x30(%rsp),%r10
cmp    %rsi,0x10(%rsp)
je     1840 <gaussj+0x6f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10,%rsi
test   $0x1,%r15b
jne    1a37 <gaussj+0x8e7>
movss  (%rdx,%r10,4),%xmm0
movss  (%rdi,%r10,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,(%rdx,%r10,4)
lea    0x1(%r10),%rsi
not    %r10
cmp    0x88(%rsp),%r10
je     1840 <gaussj+0x6f0>
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  (%rdx,%rsi,4),%xmm4
subss  %xmm0,%xmm4
movss  0x4(%rdx,%rsi,4),%xmm0
movss  %xmm4,(%rdx,%rsi,4)
movss  0x4(%rdi,%rsi,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r15
jne    1a50 <gaussj+0x900>
jmp    1840 <gaussj+0x6f0>
mov    0x54(%rsp),%r14d
test   %r14d,%r14d
jle    1b5d <gaussj+0xa0d>
mov    0x8(%rsp),%r8
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
neg    %r9
jmp    1ac1 <gaussj+0x971>
xchg   %ax,%ax
lea    -0x1(%r8),%rcx
cmp    $0x1,%r8
mov    %rcx,%r8
jle    1b5d <gaussj+0xa0d>
mov    0x20(%rsp),%rcx
movslq (%rcx,%r8,4),%rsi
mov    0x28(%rsp),%rcx
movslq (%rcx,%r8,4),%rdi
cmp    %edi,%esi
je     1ab0 <gaussj+0x960>
mov    $0x1,%edx
cmp    $0x2,%eax
je     1b34 <gaussj+0x9e4>
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rdx,8),%rcx
movss  (%rcx,%rsi,4),%xmm0
movss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  %xmm0,(%rcx,%rdi,4)
mov    0x8(%rbp,%rdx,8),%rcx
movss  (%rcx,%rsi,4),%xmm0
movss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  %xmm0,(%rcx,%rdi,4)
lea    (%r9,%rdx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdx
cmp    $0x1,%rcx
jne    1af0 <gaussj+0x9a0>
testb  $0x1,0x8(%rsp)
je     1ab0 <gaussj+0x960>
mov    0x0(%rbp,%rdx,8),%rcx
movss  (%rcx,%rsi,4),%xmm0
movss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  %xmm0,(%rcx,%rdi,4)
jmp    1ab0 <gaussj+0x960>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1050 <free_ivector@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1050 <free_ivector@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <free_ivector@plt>
lea    0x46b(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
lea    0x46f(%rip),%rdi
jmp    1ba9 <gaussj+0xa59>

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

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