#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, int);
int *ivector(int, int);
int gaussj_flg(float **a, int n, float **b, int m) {
  int *indxc, *indxr, *ipiv;
  int i, icol, irow, j, k, l, ll, status;
  float big, dum, pivinv, temp;
  float swap;
  status = 0;
  indxc = ivector(1, n);
  indxr = ivector(1, n);
  ipiv = ivector(1, n);
  for (j = 1; j <= n; j++)
    ipiv[j] = 0;
  for (i = 1; i <= n; i++) {
    big = 0.0;
    for (j = 1; j <= n; j++) {
      if (ipiv[j] != 1) {
        for (k = 1; k <= n; k++) {
          if (ipiv[k] == 0) {
            if (fabs(a[j][k]) >= big) {
              big = fabs(a[j][k]);
              irow = j;
              icol = k;
            }
          } else if (ipiv[k] > 1) {
            status = 1;
            goto FREE;
          }
        }
      }
    }
    ++(ipiv[icol]);
    if (irow != icol) {
      for (l = 1; l <= n; l++) {
        swap = a[irow][l];
        a[irow][l] = a[icol][l];
        a[icol][l] = swap;
      }
      for (l = 1; l <= m; l++) {
        swap = b[irow][l];
        b[irow][l] = b[icol][l];
        b[icol][l] = swap;
      }
    }
    indxr[i] = irow;
    indxc[i] = icol;
    if (a[icol][icol] == 0.0)
      return (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++) {
        swap = a[k][indxr[l]];
        a[k][indxr[l]] = a[k][indxc[l]];
        a[k][indxc[l]] = swap;
      }
    }
  }
FREE:
  free_ivector(ipiv, 1, n);
  free_ivector(indxr, 1, n);
  free_ivector(indxc, 1, n);
  return (status);
}


x86 assembly (clang, -O0):
<gaussj_flg>:
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   $0x0,-0x60(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1050 <ivector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1050 <ivector@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1050 <ivector@plt>
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11b3 <gaussj_flg+0x83>
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    118a <gaussj_flg+0x5a>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     164b <gaussj_flg+0x51b>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12ba <gaussj_flg+0x18a>
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     12a7 <gaussj_flg+0x177>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12a2 <gaussj_flg+0x172>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    126c <gaussj_flg+0x13c>
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 -0x64(%rbp),%xmm0
jb     1267 <gaussj_flg+0x137>
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,-0x64(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    128f <gaussj_flg+0x15f>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    128a <gaussj_flg+0x15a>
movl   $0x1,-0x60(%rbp)
jmp    1733 <gaussj_flg+0x603>
jmp    128f <gaussj_flg+0x15f>
jmp    1294 <gaussj_flg+0x164>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11fa <gaussj_flg+0xca>
jmp    12a7 <gaussj_flg+0x177>
jmp    12ac <gaussj_flg+0x17c>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11d5 <gaussj_flg+0xa5>
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     13da <gaussj_flg+0x2aa>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1356 <gaussj_flg+0x226>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%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  -0x74(%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    12de <gaussj_flg+0x1ae>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     13d5 <gaussj_flg+0x2a5>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%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  -0x74(%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    135d <gaussj_flg+0x22d>
jmp    13da <gaussj_flg+0x2aa>
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    142e <gaussj_flg+0x2fe>
jp     142e <gaussj_flg+0x2fe>
movl   $0x1,-0x4(%rbp)
jmp    176c <gaussj_flg+0x63c>
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  0xbb9(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  0xb8c(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14b9 <gaussj_flg+0x389>
movss  -0x6c(%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    1480 <gaussj_flg+0x350>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14f9 <gaussj_flg+0x3c9>
movss  -0x6c(%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    14c0 <gaussj_flg+0x390>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1638 <gaussj_flg+0x508>
mov    -0x5c(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     1625 <gaussj_flg+0x4f5>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%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   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     15b5 <gaussj_flg+0x485>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x68(%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    1551 <gaussj_flg+0x421>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1620 <gaussj_flg+0x4f0>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x68(%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    15bc <gaussj_flg+0x48c>
jmp    1625 <gaussj_flg+0x4f5>
jmp    162a <gaussj_flg+0x4fa>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1500 <gaussj_flg+0x3d0>
jmp    163d <gaussj_flg+0x50d>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11ba <gaussj_flg+0x8a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x1,-0x58(%rbp)
jl     172e <gaussj_flg+0x5fe>
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     171b <gaussj_flg+0x5eb>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1716 <gaussj_flg+0x5e6>
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    167e <gaussj_flg+0x54e>
jmp    171b <gaussj_flg+0x5eb>
jmp    1720 <gaussj_flg+0x5f0>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    1651 <gaussj_flg+0x521>
jmp    1733 <gaussj_flg+0x603>
mov    -0x40(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_ivector@plt>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_ivector@plt>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_ivector@plt>
mov    -0x60(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussj_flg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %ecx,%r14d
mov    %rdx,0x58(%rsp)
mov    %esi,%r13d
mov    %rdi,%r12
mov    $0x1,%edi
call   1050 <ivector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    %r13d,%esi
call   1050 <ivector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %r13d,%esi
call   1050 <ivector@plt>
mov    %rax,%rbp
test   %r13d,%r13d
jle    1ab3 <gaussj_flg+0x983>
mov    %rbx,0x10(%rsp)
mov    %r15,0x28(%rsp)
mov    %rbp,%rdi
add    $0x4,%rdi
mov    %r13d,%ebx
lea    0x0(,%rbx,4),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    %rbx,%rcx
lea    0x1(%rbx),%rax
lea    0x1(%r14),%r9d
lea    -0x1(%r9),%r10
lea    -0x8(%rbx),%r11
mov    %r11,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
lea    -0x9(%r9),%r8
mov    %r8,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %ecx,%r15d
and    $0xfffffff8,%r15d
lea    0x1(%r15),%rdx
mov    %rdx,0x50(%rsp)
mov    %rbx,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x78(%rsp)
mov    %rcx,%rdx
not    %rdx
mov    %rdx,0x90(%rsp)
mov    %r10,0x8(%rsp)
and    $0xfffffffffffffff8,%r10
lea    0x1(%r10),%rdx
mov    %rdx,0x40(%rsp)
mov    %rsi,%rdx
mov    %rsi,0x80(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x70(%rsp)
mov    %r9,%rdx
neg    %rdx
mov    %rdx,0x88(%rsp)
xorps  %xmm8,%xmm8
movss  0xdd1(%rip),%xmm1
movaps 0xdba(%rip),%xmm2
mov    $0x1,%edx
mov    %rdx,0x48(%rsp)
mov    %r14,0x60(%rsp)
mov    $0x1,%esi
xorps  %xmm3,%xmm3
jmp    1269 <gaussj_flg+0x139>
nop
add    $0x1,%rsi
cmp    %rax,%rsi
je     12b9 <gaussj_flg+0x189>
cmpl   $0x1,0x0(%rbp,%rsi,4)
je     1260 <gaussj_flg+0x130>
mov    $0x1,%edi
jmp    1292 <gaussj_flg+0x162>
nopw   0x0(%rax,%rax,1)
cmp    $0x1,%edx
jg     1aa1 <gaussj_flg+0x971>
add    $0x1,%rdi
cmp    %rdi,%rax
je     1260 <gaussj_flg+0x130>
mov    0x0(%rbp,%rdi,4),%edx
test   %edx,%edx
jne    1280 <gaussj_flg+0x150>
mov    (%r12,%rsi,8),%rdx
movss  (%rdx,%rdi,4),%xmm4
andps  %xmm2,%xmm4
ucomiss %xmm3,%xmm4
jb     1289 <gaussj_flg+0x159>
mov    %esi,%r14d
movaps %xmm4,%xmm3
mov    %edi,%edx
mov    %edi,0x4(%rsp)
jmp    1289 <gaussj_flg+0x159>
mov    %r8,0x38(%rsp)
mov    %rbx,0x30(%rsp)
movslq 0x4(%rsp),%rdx
addl   $0x1,0x0(%rbp,%rdx,4)
mov    %rdx,0x18(%rsp)
cmp    %edx,%r14d
mov    %rcx,0x20(%rsp)
mov    %r14d,(%rsp)
je     15a5 <gaussj_flg+0x475>
movslq %r14d,%r8
mov    (%r12,%r8,8),%rdi
mov    0x18(%rsp),%rdx
mov    (%r12,%rdx,8),%rsi
mov    $0x1,%ebx
cmp    $0x8,%ecx
jb     13d1 <gaussj_flg+0x2a1>
mov    %r11,%r14
lea    0x4(%rdi),%r11
lea    (%rsi,%rax,4),%rdx
cmp    %rdx,%r11
mov    %r14,%r11
jae    1329 <gaussj_flg+0x1f9>
lea    (%rdi,%rax,4),%r11
lea    0x4(%rsi),%rdx
cmp    %r11,%rdx
mov    %r14,%r11
jb     13d1 <gaussj_flg+0x2a1>
cmp    $0x8,%r11
jae    1333 <gaussj_flg+0x203>
xor    %edx,%edx
jmp    1394 <gaussj_flg+0x264>
mov    0x78(%rsp),%rbx
xor    %edx,%edx
movups 0x4(%rdi,%rdx,4),%xmm3
movups 0x14(%rdi,%rdx,4),%xmm4
movups 0x4(%rsi,%rdx,4),%xmm5
movups 0x14(%rsi,%rdx,4),%xmm6
movups %xmm5,0x4(%rdi,%rdx,4)
movups %xmm6,0x14(%rdi,%rdx,4)
movups %xmm3,0x4(%rsi,%rdx,4)
movups %xmm4,0x14(%rsi,%rdx,4)
movups 0x24(%rdi,%rdx,4),%xmm3
movups 0x34(%rdi,%rdx,4),%xmm4
movups 0x24(%rsi,%rdx,4),%xmm5
movups 0x34(%rsi,%rdx,4),%xmm6
movups %xmm5,0x24(%rdi,%rdx,4)
movups %xmm6,0x34(%rdi,%rdx,4)
movups %xmm3,0x24(%rsi,%rdx,4)
movups %xmm4,0x34(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbx
jne    133a <gaussj_flg+0x20a>
testb  $0x1,0x30(%rsp)
je     13c7 <gaussj_flg+0x297>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%rdi,%rdx,1),%xmm3
movups 0x10(%rdi,%rdx,1),%xmm4
movups (%rsi,%rdx,1),%xmm5
movups 0x10(%rsi,%rdx,1),%xmm6
movups %xmm5,(%rdi,%rdx,1)
movups %xmm6,0x10(%rdi,%rdx,1)
movups %xmm3,(%rsi,%rdx,1)
movups %xmm4,0x10(%rsi,%rdx,1)
mov    0x50(%rsp),%rbx
cmp    %r15,%rcx
je     1435 <gaussj_flg+0x305>
mov    %rbx,%rdx
test   $0x1,%al
jne    13f0 <gaussj_flg+0x2c0>
movss  (%rdi,%rbx,4),%xmm3
movss  (%rsi,%rbx,4),%xmm4
movss  %xmm4,(%rdi,%rbx,4)
movss  %xmm3,(%rsi,%rbx,4)
lea    0x1(%rbx),%rdx
not    %rbx
cmp    0x90(%rsp),%rbx
je     1435 <gaussj_flg+0x305>
nopl   (%rax)
movss  (%rdi,%rdx,4),%xmm3
movss  (%rsi,%rdx,4),%xmm4
movss  %xmm4,(%rdi,%rdx,4)
movss  %xmm3,(%rsi,%rdx,4)
movss  0x4(%rdi,%rdx,4),%xmm3
movss  0x4(%rsi,%rdx,4),%xmm4
movss  %xmm4,0x4(%rdi,%rdx,4)
movss  %xmm3,0x4(%rsi,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1400 <gaussj_flg+0x2d0>
cmpl   $0x0,0x60(%rsp)
mov    (%rsp),%r14d
jle    15a5 <gaussj_flg+0x475>
mov    0x58(%rsp),%rcx
mov    (%rcx,%r8,8),%rdi
mov    0x18(%rsp),%rdx
mov    (%rcx,%rdx,8),%rsi
mov    $0x1,%ebx
cmpq   $0x8,0x8(%rsp)
jb     1534 <gaussj_flg+0x404>
lea    0x4(%rdi),%r8
lea    (%rsi,%r9,4),%rdx
cmp    %rdx,%r8
jae    1485 <gaussj_flg+0x355>
lea    (%rdi,%r9,4),%r8
lea    0x4(%rsi),%rdx
cmp    %r8,%rdx
jb     1534 <gaussj_flg+0x404>
cmpq   $0x8,0x38(%rsp)
jae    1491 <gaussj_flg+0x361>
xor    %edx,%edx
jmp    14f2 <gaussj_flg+0x3c2>
mov    0x70(%rsp),%rbx
xor    %edx,%edx
movups 0x4(%rdi,%rdx,4),%xmm3
movups 0x14(%rdi,%rdx,4),%xmm4
movups 0x4(%rsi,%rdx,4),%xmm5
movups 0x14(%rsi,%rdx,4),%xmm6
movups %xmm5,0x4(%rdi,%rdx,4)
movups %xmm6,0x14(%rdi,%rdx,4)
movups %xmm3,0x4(%rsi,%rdx,4)
movups %xmm4,0x14(%rsi,%rdx,4)
movups 0x24(%rdi,%rdx,4),%xmm3
movups 0x34(%rdi,%rdx,4),%xmm4
movups 0x24(%rsi,%rdx,4),%xmm5
movups 0x34(%rsi,%rdx,4),%xmm6
movups %xmm5,0x24(%rdi,%rdx,4)
movups %xmm6,0x34(%rdi,%rdx,4)
movups %xmm3,0x24(%rsi,%rdx,4)
movups %xmm4,0x34(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbx
jne    1498 <gaussj_flg+0x368>
testb  $0x1,0x80(%rsp)
01
je     1528 <gaussj_flg+0x3f8>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%rdi,%rdx,1),%xmm3
movups 0x10(%rdi,%rdx,1),%xmm4
movups (%rsi,%rdx,1),%xmm5
movups 0x10(%rsi,%rdx,1),%xmm6
movups %xmm5,(%rdi,%rdx,1)
movups %xmm6,0x10(%rdi,%rdx,1)
movups %xmm3,(%rsi,%rdx,1)
movups %xmm4,0x10(%rsi,%rdx,1)
mov    0x40(%rsp),%rbx
cmp    %r10,0x8(%rsp)
je     15a5 <gaussj_flg+0x475>
mov    %rbx,%rdx
test   $0x1,%r9b
jne    1555 <gaussj_flg+0x425>
movss  (%rdi,%rbx,4),%xmm3
movss  (%rsi,%rbx,4),%xmm4
movss  %xmm4,(%rdi,%rbx,4)
movss  %xmm3,(%rsi,%rbx,4)
lea    0x1(%rbx),%rdx
not    %rbx
cmp    0x88(%rsp),%rbx
je     15a5 <gaussj_flg+0x475>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdi,%rdx,4),%xmm3
movss  (%rsi,%rdx,4),%xmm4
movss  %xmm4,(%rdi,%rdx,4)
movss  %xmm3,(%rsi,%rdx,4)
movss  0x4(%rdi,%rdx,4),%xmm3
movss  0x4(%rsi,%rdx,4),%xmm4
movss  %xmm4,0x4(%rdi,%rdx,4)
movss  %xmm3,0x4(%rsi,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r9
jne    1570 <gaussj_flg+0x440>
mov    %r13d,0x6c(%rsp)
mov    0x28(%rsp),%rcx
mov    0x48(%rsp),%rdx
mov    %r14d,(%rcx,%rdx,4)
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%rbx
mov    %ebx,(%rcx,%rdx,4)
mov    (%r12,%rbx,8),%r13
movss  0x0(%r13,%rbx,4),%xmm4
ucomiss %xmm8,%xmm4
jne    15dc <gaussj_flg+0x4ac>
jnp    1b9a <gaussj_flg+0xa6a>
movaps %xmm1,%xmm3
divss  %xmm4,%xmm3
movl   $0x3f800000,0x0(%r13,%rbx,4)
80 3f
mov    $0x1,%edx
mov    0x20(%rsp),%rcx
cmp    $0x8,%ecx
mov    0x38(%rsp),%r8
jb     16b0 <gaussj_flg+0x580>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmp    $0x8,%r11
mov    0x30(%rsp),%rdi
jae    161a <gaussj_flg+0x4ea>
xor    %edx,%edx
jmp    1676 <gaussj_flg+0x546>
mov    0x78(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%r13,%rdx,4),%xmm5
movups 0x14(%r13,%rdx,4),%xmm6
movups 0x24(%r13,%rdx,4),%xmm7
movups 0x34(%r13,%rdx,4),%xmm0
mulps  %xmm4,%xmm5
mulps  %xmm4,%xmm6
movups %xmm5,0x4(%r13,%rdx,4)
movups %xmm6,0x14(%r13,%rdx,4)
mulps  %xmm4,%xmm7
mulps  %xmm4,%xmm0
movups %xmm7,0x24(%r13,%rdx,4)
movups %xmm0,0x34(%r13,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1630 <gaussj_flg+0x500>
test   $0x1,%dil
je     16a2 <gaussj_flg+0x572>
shl    $0x2,%rdx
or     $0x4,%rdx
movups 0x0(%r13,%rdx,1),%xmm0
movups 0x10(%r13,%rdx,1),%xmm5
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm5,0x10(%r13,%rdx,1)
mov    0x50(%rsp),%rdx
cmp    %r15,%rcx
je     16cb <gaussj_flg+0x59b>
nopl   0x0(%rax)
movss  0x0(%r13,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    16b0 <gaussj_flg+0x580>
cmpl   $0x0,0x60(%rsp)
mov    0x4(%rsp),%edi
jle    17b7 <gaussj_flg+0x687>
mov    0x58(%rsp),%rcx
mov    (%rcx,%rbx,8),%rsi
mov    0x20(%rsp),%rcx
mov    $0x1,%edx
cmpq   $0x8,0x8(%rsp)
jb     17a0 <gaussj_flg+0x670>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmp    $0x8,%r8
jae    170a <gaussj_flg+0x5da>
xor    %edx,%edx
jmp    175e <gaussj_flg+0x62e>
mov    0x70(%rsp),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%rsi,%rdx,4),%xmm0
movups 0x14(%rsi,%rdx,4),%xmm5
movups 0x24(%rsi,%rdx,4),%xmm6
movups 0x34(%rsi,%rdx,4),%xmm7
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,0x4(%rsi,%rdx,4)
movups %xmm5,0x14(%rsi,%rdx,4)
mulps  %xmm4,%xmm6
mulps  %xmm4,%xmm7
movups %xmm6,0x24(%rsi,%rdx,4)
movups %xmm7,0x34(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1720 <gaussj_flg+0x5f0>
testb  $0x1,0x80(%rsp)
01
mov    0x4(%rsp),%edi
je     178c <gaussj_flg+0x65c>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%rsi,%rdx,1),%xmm0
movups 0x10(%rsi,%rdx,1),%xmm5
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,(%rsi,%rdx,1)
movups %xmm5,0x10(%rsi,%rdx,1)
mov    0x40(%rsp),%rdx
cmp    %r10,0x8(%rsp)
je     17b7 <gaussj_flg+0x687>
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r9
jne    17a0 <gaussj_flg+0x670>
mov    %r11,0x98(%rsp)
mov    %edi,%r8d
lea    0x4(%r13),%rdx
mov    %rdx,0xa0(%rsp)
lea    0x0(,%rax,4),%rdx
add    %r13,%rdx
mov    %rdx,0x20(%rsp)
mov    $0x1,%edi
jmp    17fd <gaussj_flg+0x6cd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %rax,%rdi
je     1a53 <gaussj_flg+0x923>
cmp    %r8,%rdi
je     17f0 <gaussj_flg+0x6c0>
mov    (%r12,%rdi,8),%rsi
mov    0x18(%rsp),%rdx
movss  (%rsi,%rdx,4),%xmm3
movl   $0x0,(%rsi,%rdx,4)
mov    $0x1,%ebx
cmp    $0x8,%ecx
jb     1890 <gaussj_flg+0x760>
lea    0x4(%rsi),%rdx
cmp    0x20(%rsp),%rdx
jae    183a <gaussj_flg+0x70a>
lea    (%rsi,%rax,4),%rdx
cmp    %rdx,0xa0(%rsp)
jb     1890 <gaussj_flg+0x760>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x4(%r13,%rdx,4),%xmm0
movups 0x14(%r13,%rdx,4),%xmm5
movups 0x4(%rsi,%rdx,4),%xmm6
movups 0x14(%rsi,%rdx,4),%xmm7
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm6
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm7
movups %xmm6,0x4(%rsi,%rdx,4)
movups %xmm7,0x14(%rsi,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%r15
jne    1850 <gaussj_flg+0x720>
mov    0x50(%rsp),%rbx
cmp    %r15,%rcx
je     190d <gaussj_flg+0x7dd>
nop
mov    %rbx,%rdx
test   $0x1,%al
jne    18b4 <gaussj_flg+0x784>
movss  (%rsi,%rbx,4),%xmm0
movss  0x0(%r13,%rbx,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,(%rsi,%rbx,4)
lea    0x1(%rbx),%rdx
not    %rbx
cmp    0x90(%rsp),%rbx
je     190d <gaussj_flg+0x7dd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  (%rsi,%rdx,4),%xmm4
subss  %xmm0,%xmm4
movss  0x4(%rsi,%rdx,4),%xmm0
movss  %xmm4,(%rsi,%rdx,4)
movss  0x4(%r13,%rdx,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,0x4(%rsi,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    18d0 <gaussj_flg+0x7a0>
cmpl   $0x0,0x60(%rsp)
jle    17f0 <gaussj_flg+0x6c0>
mov    %rcx,%r14
mov    0x58(%rsp),%rcx
mov    0x18(%rsp),%rdx
mov    (%rcx,%rdx,8),%rsi
mov    (%rcx,%rdi,8),%r11
mov    $0x1,%edx
cmpq   $0x8,0x8(%rsp)
jae    1946 <gaussj_flg+0x816>
mov    %r14,%rcx
mov    (%rsp),%r14d
jmp    19d0 <gaussj_flg+0x8a0>
lea    0x4(%r11),%rbx
mov    %r14,%rcx
lea    (%rsi,%r9,4),%r14
cmp    %r14,%rbx
mov    (%rsp),%r14d
jae    1971 <gaussj_flg+0x841>
lea    (%r11,%r9,4),%rbx
mov    %rcx,%r14
lea    0x4(%rsi),%rcx
cmp    %rbx,%rcx
mov    %r14,%rcx
mov    (%rsp),%r14d
jb     19d0 <gaussj_flg+0x8a0>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x4(%rsi,%rdx,4),%xmm0
movups 0x14(%rsi,%rdx,4),%xmm5
movups 0x4(%r11,%rdx,4),%xmm6
movups 0x14(%r11,%rdx,4),%xmm7
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm6
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm7
movups %xmm6,0x4(%r11,%rdx,4)
movups %xmm7,0x14(%r11,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%r10
jne    1980 <gaussj_flg+0x850>
mov    0x40(%rsp),%rdx
cmp    %r10,0x8(%rsp)
je     17f0 <gaussj_flg+0x6c0>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rbx
test   $0x1,%r9b
jne    19f6 <gaussj_flg+0x8c6>
movss  (%r11,%rdx,4),%xmm0
movss  (%rsi,%rdx,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,(%r11,%rdx,4)
lea    0x1(%rdx),%rbx
not    %rdx
cmp    0x88(%rsp),%rdx
je     17f0 <gaussj_flg+0x6c0>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rbx,4),%xmm0
mulss  %xmm3,%xmm0
movss  (%r11,%rbx,4),%xmm4
subss  %xmm0,%xmm4
movss  0x4(%r11,%rbx,4),%xmm0
movss  %xmm4,(%r11,%rbx,4)
movss  0x4(%rsi,%rbx,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm0
movss  %xmm0,0x4(%r11,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    1a10 <gaussj_flg+0x8e0>
jmp    17f0 <gaussj_flg+0x6c0>
mov    0x48(%rsp),%rdx
add    $0x1,%rdx
mov    %rdx,0x48(%rsp)
cmp    %rax,%rdx
mov    0x6c(%rsp),%r13d
mov    0x98(%rsp),%r11
mov    0x30(%rsp),%rbx
mov    0x38(%rsp),%r8
jne    1255 <gaussj_flg+0x125>
xor    %r14d,%r14d
test   %r13d,%r13d
jle    1aa7 <gaussj_flg+0x977>
mov    %rcx,%r9
mov    %rcx,%r8
and    $0xfffffffe,%ecx
neg    %rcx
mov    0x28(%rsp),%r15
mov    0x10(%rsp),%rbx
jmp    1b0d <gaussj_flg+0x9dd>
mov    $0x1,%r14d
mov    0x28(%rsp),%r15
mov    0x10(%rsp),%rbx
jmp    1ab6 <gaussj_flg+0x986>
xor    %r14d,%r14d
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %r13d,%edx
call   1040 <free_ivector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r13d,%edx
call   1040 <free_ivector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r13d,%edx
call   1040 <free_ivector@plt>
mov    %r14d,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r8),%rdx
cmp    $0x1,%r8
mov    %rdx,%r8
mov    0x10(%rsp),%rbx
jle    1ab6 <gaussj_flg+0x986>
movslq (%r15,%r8,4),%rsi
movslq (%rbx,%r8,4),%rdi
cmp    %edi,%esi
je     1afb <gaussj_flg+0x9cb>
mov    $0x1,%ebx
cmp    $0x2,%eax
je     1b73 <gaussj_flg+0xa43>
mov    $0x1,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rbx,8),%rdx
movss  (%rdx,%rsi,4),%xmm0
movss  (%rdx,%rdi,4),%xmm1
movss  %xmm1,(%rdx,%rsi,4)
movss  %xmm0,(%rdx,%rdi,4)
mov    0x8(%r12,%rbx,8),%rdx
movss  (%rdx,%rsi,4),%xmm0
movss  (%rdx,%rdi,4),%xmm1
movss  %xmm1,(%rdx,%rsi,4)
movss  %xmm0,(%rdx,%rdi,4)
lea    (%rcx,%rbx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbx
cmp    $0x1,%rdx
jne    1b30 <gaussj_flg+0xa00>
test   $0x1,%r9b
je     1afb <gaussj_flg+0x9cb>
mov    (%r12,%rbx,8),%rdx
movss  (%rdx,%rsi,4),%xmm0
movss  (%rdx,%rdi,4),%xmm1
movss  %xmm1,(%rdx,%rsi,4)
movss  %xmm0,(%rdx,%rdi,4)
jmp    1afb <gaussj_flg+0x9cb>
mov    $0x1,%r14d
jmp    1ae6 <gaussj_flg+0x9b6>

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

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