#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 */
double fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free_ivector(int *, int);
int *ivector(int, int);
int /*<<< orphan*/ stderr;
int gaussj(double **a, int n, double **b, int m) {
  int *indxc, *indxr, *ipiv, ier;
  int i, icol, irow, j, k, l, ll;
  double big, dum, pivinv;
  ier = 1;
  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) {
              fprintf(stderr, "GAUSSJ: Singular Matrix-1\n");
              ier = 0;
              goto out;
            }
          }
        }
    ++(ipiv[icol]);
    if (irow != icol) {
      for (l = 1; l <= n; l++) {
        double temp = (a[irow][l]);
        (a[irow][l]) = (a[icol][l]);
        (a[icol][l]) = temp;
      }
      for (l = 1; l <= m; l++) {
        double 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) {
      fprintf(stderr, "GAUSSJ: Singular Matrix-2\n");
      ier = 0;
      goto out;
    }
    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++) {
        double temp = (a[k][indxr[l]]);
        (a[k][indxr[l]]) = (a[k][indxc[l]]);
        (a[k][indxc[l]]) = temp;
      }
  }
out:
  free_ivector(ipiv, 1);
  free_ivector(indxr, 1);
  free_ivector(indxc, 1);
  return ier;
}


x86 assembly (clang, -O0):
<gaussj>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1050 <ivector@plt>
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1050 <ivector@plt>
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1050 <ivector@plt>
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11b3 <gaussj+0x83>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    118a <gaussj+0x5a>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1684 <gaussj+0x554>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12dc <gaussj+0x1ac>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     12c9 <gaussj+0x199>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12c4 <gaussj+0x194>
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1279 <gaussj+0x149>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xddc(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     1274 <gaussj+0x144>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdb1(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    12b1 <gaussj+0x181>
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    12ac <gaussj+0x17c>
mov    0x2d4e(%rip),%rax
mov    (%rax),%edi
lea    0xd85(%rip),%rsi
call   1030 <fprintf@plt>
movl   $0x0,-0x3c(%rbp)
jmp    1772 <gaussj+0x642>
jmp    12b1 <gaussj+0x181>
jmp    12b6 <gaussj+0x186>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11fa <gaussj+0xca>
jmp    12c9 <gaussj+0x199>
jmp    12ce <gaussj+0x19e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11d5 <gaussj+0xa5>
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     13fc <gaussj+0x2cc>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1378 <gaussj+0x248>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1300 <gaussj+0x1d0>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     13f7 <gaussj+0x2c7>
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    137f <gaussj+0x24f>
jmp    13fc <gaussj+0x2cc>
mov    -0x48(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1461 <gaussj+0x331>
jp     1461 <gaussj+0x331>
mov    0x2b99(%rip),%rax
mov    (%rax),%edi
lea    0xbeb(%rip),%rsi
call   1030 <fprintf@plt>
movl   $0x0,-0x3c(%rbp)
jmp    1772 <gaussj+0x642>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  0xb87(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  0xb65(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14e0 <gaussj+0x3b0>
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14a7 <gaussj+0x377>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1520 <gaussj+0x3f0>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14e7 <gaussj+0x3b7>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1671 <gaussj+0x541>
mov    -0x58(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     165e <gaussj+0x52e>
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     15e5 <gaussj+0x4b5>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1578 <gaussj+0x448>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1659 <gaussj+0x529>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    15ec <gaussj+0x4bc>
jmp    165e <gaussj+0x52e>
jmp    1663 <gaussj+0x533>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1527 <gaussj+0x3f7>
jmp    1676 <gaussj+0x546>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11ba <gaussj+0x8a>
mov    -0xc(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x1,-0x54(%rbp)
jl     176d <gaussj+0x63d>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x54(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     175a <gaussj+0x62a>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1755 <gaussj+0x625>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    16b7 <gaussj+0x587>
jmp    175a <gaussj+0x62a>
jmp    175f <gaussj+0x62f>
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    168a <gaussj+0x55a>
jmp    1772 <gaussj+0x642>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
call   1040 <free_ivector@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1040 <free_ivector@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
call   1040 <free_ivector@plt>
mov    -0x3c(%rbp),%eax
add    $0x90,%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,0x60(%rsp)
mov    %esi,%ebx
mov    %rdi,0xb0(%rsp)
mov    $0x1,%r13d
mov    $0x1,%edi
call   1060 <ivector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %ebx,%esi
call   1060 <ivector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %ebx,%esi
call   1060 <ivector@plt>
mov    %ebx,%ecx
mov    %rax,%rbx
test   %ecx,%ecx
jle    1b3c <gaussj+0x9fc>
mov    %r12,0x28(%rsp)
mov    %rbx,%rdi
add    $0x4,%rdi
mov    %ecx,0x6c(%rsp)
mov    %ecx,%ebp
lea    0x0(,%rbp,4),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
lea    0x1(%rbp),%rax
lea    0x1(%r15),%r8d
lea    -0x1(%r8),%r10
lea    -0x4(%rbp),%r9
mov    %r9,0xa8(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
lea    -0x5(%r8),%r11
mov    %r11,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %ebp,%r12d
and    $0xfffffffc,%r12d
lea    0x1(%r12),%rdx
mov    %rdx,0x50(%rsp)
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x78(%rsp)
mov    %rbp,(%rsp)
mov    %rbp,%rdx
not    %rdx
mov    %rdx,0x90(%rsp)
mov    %r10,0x10(%rsp)
and    $0xfffffffffffffffc,%r10
lea    0x1(%r10),%rdx
mov    %rdx,0x40(%rsp)
mov    %rsi,%rdx
mov    %rsi,0x80(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x70(%rsp)
mov    %r8,%rdx
neg    %rdx
mov    %rdx,0x88(%rsp)
xorpd  %xmm8,%xmm8
movsd  0xdb2(%rip),%xmm1
movapd 0xd9a(%rip),%xmm2
mov    $0x1,%edx
mov    %rdx,0x48(%rsp)
mov    %r15,0x30(%rsp)
mov    0xb0(%rsp),%r15
mov    %r14,0x58(%rsp)
mov    $0x1,%edx
xorpd  %xmm3,%xmm3
mov    0x1c(%rsp),%ecx
mov    0xc(%rsp),%ebp
jmp    12a9 <gaussj+0x169>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
cmp    %rax,%rdx
je     12f6 <gaussj+0x1b6>
cmpl   $0x1,(%rbx,%rdx,4)
je     12a0 <gaussj+0x160>
mov    $0x1,%esi
jmp    12d2 <gaussj+0x192>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x1,%edi
jg     1b1a <gaussj+0x9da>
add    $0x1,%rsi
cmp    %rsi,%rax
je     12a0 <gaussj+0x160>
mov    (%rbx,%rsi,4),%edi
test   %edi,%edi
jne    12c0 <gaussj+0x180>
mov    (%r15,%rdx,8),%rdi
movsd  (%rdi,%rsi,8),%xmm4
andpd  %xmm2,%xmm4
ucomisd %xmm3,%xmm4
jb     12c9 <gaussj+0x189>
movapd %xmm4,%xmm3
mov    %edx,%ebp
mov    %esi,%ecx
jmp    12c9 <gaussj+0x189>
mov    %r11,0x38(%rsp)
mov    %r9,0x20(%rsp)
mov    %ecx,0x1c(%rsp)
movslq %ecx,%rcx
addl   $0x1,(%rbx,%rcx,4)
mov    %ebp,0xc(%rsp)
cmp    %ecx,%ebp
mov    0xa8(%rsp),%r9
je     1605 <gaussj+0x4c5>
movslq 0xc(%rsp),%r14
mov    (%r15,%r14,8),%rsi
mov    (%r15,%rcx,8),%rdx
mov    $0x1,%ebp
cmpl   $0x4,(%rsp)
jb     1424 <gaussj+0x2e4>
mov    %r9,%r11
lea    0x8(%rsi),%r9
lea    (%rdx,%rax,8),%rdi
cmp    %rdi,%r9
mov    %r11,%r9
jae    1362 <gaussj+0x222>
lea    (%rsi,%rax,8),%r9
lea    0x8(%rdx),%rdi
cmp    %r9,%rdi
mov    %r11,%r9
jb     1424 <gaussj+0x2e4>
cmp    $0x4,%r9
jae    1371 <gaussj+0x231>
xor    %edi,%edi
mov    0x20(%rsp),%r11
jmp    13df <gaussj+0x29f>
mov    0x78(%rsp),%rbp
xor    %edi,%edi
mov    0x20(%rsp),%r11
movups 0x8(%rsi,%rdi,8),%xmm3
movups 0x18(%rsi,%rdi,8),%xmm4
movups 0x8(%rdx,%rdi,8),%xmm5
movups 0x18(%rdx,%rdi,8),%xmm6
movups %xmm5,0x8(%rsi,%rdi,8)
movups %xmm6,0x18(%rsi,%rdi,8)
movups %xmm3,0x8(%rdx,%rdi,8)
movups %xmm4,0x18(%rdx,%rdi,8)
movupd 0x28(%rsi,%rdi,8),%xmm3
movupd 0x38(%rsi,%rdi,8),%xmm4
movupd 0x28(%rdx,%rdi,8),%xmm5
movupd 0x38(%rdx,%rdi,8),%xmm6
movupd %xmm5,0x28(%rsi,%rdi,8)
movupd %xmm6,0x38(%rsi,%rdi,8)
movupd %xmm3,0x28(%rdx,%rdi,8)
movupd %xmm4,0x38(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    137d <gaussj+0x23d>
test   $0x1,%r11b
je     1419 <gaussj+0x2d9>
shl    $0x3,%rdi
or     $0x8,%rdi
movupd (%rsi,%rdi,1),%xmm3
movupd 0x10(%rsi,%rdi,1),%xmm4
movupd (%rdx,%rdi,1),%xmm5
movupd 0x10(%rdx,%rdi,1),%xmm6
movupd %xmm5,(%rsi,%rdi,1)
movupd %xmm6,0x10(%rsi,%rdi,1)
movupd %xmm3,(%rdx,%rdi,1)
movupd %xmm4,0x10(%rdx,%rdi,1)
mov    0x50(%rsp),%rbp
cmp    %r12,(%rsp)
je     1485 <gaussj+0x345>
mov    %rbp,%rdi
test   $0x1,%al
jne    1443 <gaussj+0x303>
movsd  (%rsi,%rbp,8),%xmm3
movsd  (%rdx,%rbp,8),%xmm4
movsd  %xmm4,(%rsi,%rbp,8)
movsd  %xmm3,(%rdx,%rbp,8)
lea    0x1(%rbp),%rdi
not    %rbp
cmp    0x90(%rsp),%rbp
je     1485 <gaussj+0x345>
movsd  (%rsi,%rdi,8),%xmm3
movsd  (%rdx,%rdi,8),%xmm4
movsd  %xmm4,(%rsi,%rdi,8)
movsd  %xmm3,(%rdx,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm3
movsd  0x8(%rdx,%rdi,8),%xmm4
movsd  %xmm4,0x8(%rsi,%rdi,8)
movsd  %xmm3,0x8(%rdx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rax
jne    1450 <gaussj+0x310>
cmpl   $0x0,0x30(%rsp)
jle    1605 <gaussj+0x4c5>
mov    0x60(%rsp),%rdx
mov    (%rdx,%r14,8),%rsi
mov    (%rdx,%rcx,8),%rdx
mov    $0x1,%ebp
cmpq   $0x4,0x10(%rsp)
jb     1594 <gaussj+0x454>
mov    %r9,%r13
lea    0x8(%rsi),%r9
lea    (%rdx,%r8,8),%rdi
cmp    %rdi,%r9
mov    %r13,%r9
jae    14d5 <gaussj+0x395>
lea    (%rsi,%r8,8),%r9
lea    0x8(%rdx),%rdi
cmp    %r9,%rdi
mov    %r13,%r9
jb     1594 <gaussj+0x454>
cmpq   $0x4,0x38(%rsp)
jae    14e1 <gaussj+0x3a1>
xor    %edi,%edi
jmp    154a <gaussj+0x40a>
mov    0x70(%rsp),%rbp
xor    %edi,%edi
movups 0x8(%rsi,%rdi,8),%xmm3
movups 0x18(%rsi,%rdi,8),%xmm4
movups 0x8(%rdx,%rdi,8),%xmm5
movups 0x18(%rdx,%rdi,8),%xmm6
movups %xmm5,0x8(%rsi,%rdi,8)
movups %xmm6,0x18(%rsi,%rdi,8)
movups %xmm3,0x8(%rdx,%rdi,8)
movups %xmm4,0x18(%rdx,%rdi,8)
movupd 0x28(%rsi,%rdi,8),%xmm3
movupd 0x38(%rsi,%rdi,8),%xmm4
movupd 0x28(%rdx,%rdi,8),%xmm5
movupd 0x38(%rdx,%rdi,8),%xmm6
movupd %xmm5,0x28(%rsi,%rdi,8)
movupd %xmm6,0x38(%rsi,%rdi,8)
movupd %xmm3,0x28(%rdx,%rdi,8)
movupd %xmm4,0x38(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    14e8 <gaussj+0x3a8>
testb  $0x1,0x80(%rsp)
01
je     1588 <gaussj+0x448>
shl    $0x3,%rdi
or     $0x8,%rdi
movupd (%rsi,%rdi,1),%xmm3
movupd 0x10(%rsi,%rdi,1),%xmm4
movupd (%rdx,%rdi,1),%xmm5
movupd 0x10(%rdx,%rdi,1),%xmm6
movupd %xmm5,(%rsi,%rdi,1)
movupd %xmm6,0x10(%rsi,%rdi,1)
movupd %xmm3,(%rdx,%rdi,1)
movupd %xmm4,0x10(%rdx,%rdi,1)
mov    0x40(%rsp),%rbp
cmp    %r10,0x10(%rsp)
je     1605 <gaussj+0x4c5>
mov    %rbp,%rdi
test   $0x1,%r8b
jne    15b5 <gaussj+0x475>
movsd  (%rsi,%rbp,8),%xmm3
movsd  (%rdx,%rbp,8),%xmm4
movsd  %xmm4,(%rsi,%rbp,8)
movsd  %xmm3,(%rdx,%rbp,8)
lea    0x1(%rbp),%rdi
not    %rbp
cmp    0x88(%rsp),%rbp
je     1605 <gaussj+0x4c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rdi,8),%xmm3
movsd  (%rdx,%rdi,8),%xmm4
movsd  %xmm4,(%rsi,%rdi,8)
movsd  %xmm3,(%rdx,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm3
movsd  0x8(%rdx,%rdi,8),%xmm4
movsd  %xmm4,0x8(%rsi,%rdi,8)
movsd  %xmm3,0x8(%rdx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r8
jne    15d0 <gaussj+0x490>
mov    0x28(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    %rcx,%rdi
mov    0xc(%rsp),%ecx
mov    %ecx,(%rdx,%rsi,4)
mov    %rdi,%rcx
mov    0x58(%rsp),%r14
mov    %ecx,(%r14,%rsi,4)
mov    (%r15,%rdi,8),%r13
movsd  0x0(%r13,%rdi,8),%xmm4
ucomisd %xmm8,%xmm4
jne    163d <gaussj+0x4fd>
jnp    1c0e <gaussj+0xace>
movapd %xmm1,%xmm3
divsd  %xmm4,%xmm3
movabs $0x3ff0000000000000,%rdx
mov    %rdx,0x0(%r13,%rcx,8)
mov    $0x1,%edx
cmpl   $0x4,(%rsp)
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%rbp
jb     1720 <gaussj+0x5e0>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmp    $0x4,%r9
mov    0x20(%rsp),%rdi
jae    1684 <gaussj+0x544>
xor    %edx,%edx
jmp    16e2 <gaussj+0x5a2>
mov    0x78(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r13,%rdx,8),%xmm5
movupd 0x18(%r13,%rdx,8),%xmm6
movupd 0x28(%r13,%rdx,8),%xmm7
movupd 0x38(%r13,%rdx,8),%xmm0
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,0x8(%r13,%rdx,8)
movupd %xmm6,0x18(%r13,%rdx,8)
mulpd  %xmm4,%xmm7
mulpd  %xmm4,%xmm0
movupd %xmm7,0x28(%r13,%rdx,8)
movupd %xmm0,0x38(%r13,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1690 <gaussj+0x550>
test   $0x1,%dil
je     1714 <gaussj+0x5d4>
shl    $0x3,%rdx
or     $0x8,%rdx
movupd 0x0(%r13,%rdx,1),%xmm0
movupd 0x10(%r13,%rdx,1),%xmm5
mulpd  %xmm4,%xmm0
mulpd  %xmm4,%xmm5
movupd %xmm0,0x0(%r13,%rdx,1)
movupd %xmm5,0x10(%r13,%rdx,1)
mov    0x50(%rsp),%rdx
cmp    %r12,(%rsp)
je     173b <gaussj+0x5fb>
nop
movsd  0x0(%r13,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1720 <gaussj+0x5e0>
test   %ebp,%ebp
jle    1827 <gaussj+0x6e7>
mov    0x60(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
mov    $0x1,%esi
cmpq   $0x4,0x10(%rsp)
jb     1810 <gaussj+0x6d0>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmp    $0x4,%r11
jae    176f <gaussj+0x62f>
xor    %esi,%esi
jmp    17ca <gaussj+0x68a>
mov    0x70(%rsp),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd 0x8(%rdx,%rsi,8),%xmm0
movupd 0x18(%rdx,%rsi,8),%xmm5
movupd 0x28(%rdx,%rsi,8),%xmm6
movupd 0x38(%rdx,%rsi,8),%xmm7
mulpd  %xmm4,%xmm0
mulpd  %xmm4,%xmm5
movupd %xmm0,0x8(%rdx,%rsi,8)
movupd %xmm5,0x18(%rdx,%rsi,8)
mulpd  %xmm4,%xmm6
mulpd  %xmm4,%xmm7
movupd %xmm6,0x28(%rdx,%rsi,8)
movupd %xmm7,0x38(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1780 <gaussj+0x640>
testb  $0x1,0x80(%rsp)
01
je     17fa <gaussj+0x6ba>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd (%rdx,%rsi,1),%xmm0
movupd 0x10(%rdx,%rsi,1),%xmm5
mulpd  %xmm4,%xmm0
mulpd  %xmm4,%xmm5
movupd %xmm0,(%rdx,%rsi,1)
movupd %xmm5,0x10(%rdx,%rsi,1)
mov    0x40(%rsp),%rsi
cmp    %r10,0x10(%rsp)
je     1827 <gaussj+0x6e7>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    1810 <gaussj+0x6d0>
mov    0x1c(%rsp),%r14d
lea    0x8(%r13),%rdx
mov    %rdx,0x98(%rsp)
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
mov    %rdx,0xa0(%rsp)
mov    $0x1,%r11d
jmp    186d <gaussj+0x72d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r11
cmp    %rax,%r11
je     1ad3 <gaussj+0x993>
cmp    %r14,%r11
je     1860 <gaussj+0x720>
mov    (%r15,%r11,8),%rdx
movsd  (%rdx,%rcx,8),%xmm3
movq   $0x0,(%rdx,%rcx,8)
mov    $0x1,%esi
cmpl   $0x4,(%rsp)
jae    18a0 <gaussj+0x760>
mov    0x30(%rsp),%rbp
jmp    1920 <gaussj+0x7e0>
nopl   0x0(%rax,%rax,1)
lea    0x8(%rdx),%rdi
cmp    0xa0(%rsp),%rdi
mov    0x30(%rsp),%rbp
jae    18c1 <gaussj+0x781>
lea    (%rdx,%rax,8),%rdi
cmp    %rdi,0x98(%rsp)
jb     1920 <gaussj+0x7e0>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r13,%rsi,8),%xmm0
movupd 0x18(%r13,%rsi,8),%xmm5
movupd 0x8(%rdx,%rsi,8),%xmm6
movupd 0x18(%rdx,%rsi,8),%xmm7
mulpd  %xmm4,%xmm0
subpd  %xmm0,%xmm6
mulpd  %xmm4,%xmm5
subpd  %xmm5,%xmm7
movupd %xmm6,0x8(%rdx,%rsi,8)
movupd %xmm7,0x18(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r12
jne    18d0 <gaussj+0x790>
mov    0x50(%rsp),%rsi
cmp    %r12,(%rsp)
je     199d <gaussj+0x85d>
xchg   %ax,%ax
mov    %rsi,%rdi
test   $0x1,%al
jne    1944 <gaussj+0x804>
movsd  (%rdx,%rsi,8),%xmm0
movsd  0x0(%r13,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
lea    0x1(%rsi),%rdi
not    %rsi
cmp    0x90(%rsp),%rsi
je     199d <gaussj+0x85d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rdi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  (%rdx,%rdi,8),%xmm4
subsd  %xmm0,%xmm4
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm4,(%rdx,%rdi,8)
movsd  0x8(%r13,%rdi,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%rdx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rax
jne    1960 <gaussj+0x820>
test   %ebp,%ebp
jle    1860 <gaussj+0x720>
mov    0x60(%rsp),%rsi
mov    (%rsi,%rcx,8),%rdx
mov    (%rsi,%r11,8),%r9
mov    $0x1,%edi
cmpq   $0x4,0x10(%rsp)
jb     1a50 <gaussj+0x910>
lea    0x8(%r9),%rsi
lea    (%rdx,%r8,8),%rbp
cmp    %rbp,%rsi
jae    19dd <gaussj+0x89d>
lea    (%r9,%r8,8),%rsi
lea    0x8(%rdx),%rbp
cmp    %rsi,%rbp
jb     1a50 <gaussj+0x910>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd 0x8(%rdx,%rsi,8),%xmm0
movupd 0x18(%rdx,%rsi,8),%xmm5
movupd 0x8(%r9,%rsi,8),%xmm6
movupd 0x18(%r9,%rsi,8),%xmm7
mulpd  %xmm4,%xmm0
subpd  %xmm0,%xmm6
mulpd  %xmm4,%xmm5
subpd  %xmm5,%xmm7
movupd %xmm6,0x8(%r9,%rsi,8)
movupd %xmm7,0x18(%r9,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    19f0 <gaussj+0x8b0>
mov    0x40(%rsp),%rdi
cmp    %r10,0x10(%rsp)
je     1860 <gaussj+0x720>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rsi
test   $0x1,%r8b
jne    1a76 <gaussj+0x936>
movsd  (%r9,%rdi,8),%xmm0
movsd  (%rdx,%rdi,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
movsd  %xmm0,(%r9,%rdi,8)
lea    0x1(%rdi),%rsi
not    %rdi
cmp    0x88(%rsp),%rdi
je     1860 <gaussj+0x720>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  (%r9,%rsi,8),%xmm4
subsd  %xmm0,%xmm4
movsd  0x8(%r9,%rsi,8),%xmm0
movsd  %xmm4,(%r9,%rsi,8)
movsd  0x8(%rdx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%r9,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r8
jne    1a90 <gaussj+0x950>
jmp    1860 <gaussj+0x720>
mov    0x48(%rsp),%rdx
add    $0x1,%rdx
mov    %rdx,0x48(%rsp)
cmp    %rax,%rdx
mov    0x58(%rsp),%r14
mov    $0x1,%r13d
mov    0x20(%rsp),%r9
mov    0x38(%rsp),%r11
jne    1282 <gaussj+0x142>
cmpl   $0x0,0x6c(%rsp)
jle    1b37 <gaussj+0x9f7>
mov    (%rsp),%r8
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
mov    0x28(%rsp),%r12
jmp    1b85 <gaussj+0xa45>
lea    0x4f7(%rip),%rsi
mov    0x58(%rsp),%r14
mov    0x24b3(%rip),%rax
mov    (%rax),%edi
call   1040 <fprintf@plt>
xor    %r13d,%r13d
mov    0x28(%rsp),%r12
mov    %rbx,%rdi
mov    $0x1,%esi
call   1050 <free_ivector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
call   1050 <free_ivector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
call   1050 <free_ivector@plt>
mov    %r13d,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r8),%rdx
cmp    $0x1,%r8
mov    %rdx,%r8
jle    1b3c <gaussj+0x9fc>
movslq (%r12,%r8,4),%rsi
movslq (%r14,%r8,4),%rdi
cmp    %edi,%esi
je     1b78 <gaussj+0xa38>
mov    $0x1,%edx
cmp    $0x2,%eax
je     1beb <gaussj+0xaab>
mov    $0x1,%edx
mov    (%r15,%rdx,8),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm0
movsd  0x0(%rbp,%rdi,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,8)
movsd  %xmm0,0x0(%rbp,%rdi,8)
mov    0x8(%r15,%rdx,8),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm0
movsd  0x0(%rbp,%rdi,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,8)
movsd  %xmm0,0x0(%rbp,%rdi,8)
lea    (%rcx,%rdx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdx
cmp    $0x1,%rbp
jne    1ba0 <gaussj+0xa60>
testb  $0x1,(%rsp)
je     1b78 <gaussj+0xa38>
mov    (%r15,%rdx,8),%rdx
movsd  (%rdx,%rsi,8),%xmm0
movsd  (%rdx,%rdi,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
movsd  %xmm0,(%rdx,%rdi,8)
jmp    1b78 <gaussj+0xa38>
lea    0x41e(%rip),%rsi
jmp    1b26 <gaussj+0x9e6>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [27 x i8] c"GAUSSJ: Singular Matrix-1\0A\00"
@.str.1 = [27 x i8] c"GAUSSJ: Singular Matrix-2\0A\00"
define i32 @gaussj(double** nocapture %0, i32 %1, double** 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 %678, 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, -5
%28 = lshr i64 %27, 2
%29 = add nuw nsw i64 %28, 1
%30 = add nsw i64 %18, -5
%31 = lshr i64 %30, 2
%32 = add nuw nsw i64 %31, 1
%33 = icmp ult i64 %26, 4
%34 = and i64 %26, -4
%35 = or i64 %34, 1
%36 = and i64 %29, 1
%37 = icmp ult i64 %27, 4
%38 = and i64 %29, 9223372036854775806
%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, 4
%45 = and i64 %25, -4
%46 = or i64 %45, 1
%47 = and i64 %32, 1
%48 = icmp ult i64 %30, 4
%49 = and i64 %32, 9223372036854775806
%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, 4
%56 = and i64 %24, -4
%57 = or i64 %56, 1
%58 = and i64 %29, 1
%59 = icmp ult i64 %27, 4
%60 = and i64 %29, 9223372036854775806
%61 = icmp eq i64 %58, 0
%62 = icmp eq i64 %24, %56
%63 = icmp ult i64 %23, 4
%64 = and i64 %23, -4
%65 = or i64 %64, 1
%66 = and i64 %32, 1
%67 = icmp ult i64 %30, 4
%68 = and i64 %32, 9223372036854775806
%69 = icmp eq i64 %66, 0
%70 = icmp eq i64 %23, %64
%71 = icmp ult i64 %22, 4
%72 = and i64 %22, -4
%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, 4
%79 = and i64 %21, -4
%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 ], [ %134, %630 ]
br label %97
89: ; preds = %630
%90 = icmp sgt i32 %1, 0
br i1 %90, label %91, label %678
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 i32 [ %88, %85 ], [ %134, %132 ]
%101 = phi double [ 0.000000e+00, %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 double*, double** %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 i32 [ %100, %105 ], [ %128, %126 ]
%112 = phi double [ %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 double*, double** %106
%118 = getelementptr inbounds double, double* %117, i64 %109
%119 = load double, double* %118
%120 = tail call double @llvm.fabs.f64(double %119)
%121 = fcmp ult double %120, %112
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 double [ %120, %122 ], [ %112, %116 ], [ %112, %124 ]
%128 = phi i32 [ %107, %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 double [ %101, %97 ], [ %127, %126 ]
%134 = phi i32 [ %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 %134, %135
br i1 %143, label %347, label %144
144: ; preds = %138
%145 = sext i32 %134 to i64
%146 = getelementptr inbounds double*, double** %0, i64 %145
%147 = load double*, double** %146
%148 = getelementptr inbounds double*, double** %0, i64 %139
%149 = load double*, double** %148
br i1 %33, label %220, label %150
150: ; preds = %144
%151 = getelementptr double, double* %147, i64 1
%152 = getelementptr double, double* %147, i64 %17
%153 = getelementptr double, double* %149, i64 1
%154 = getelementptr double, double* %149, i64 %17
%155 = icmp ult double* %151, %154
%156 = icmp ult double* %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 double, double* %147, i64 %162
%164 = bitcast double* %163 to <2 x double>*
%165 = load <2 x double>, <2 x double>* %164
%166 = getelementptr inbounds double, double* %163, i64 2
%167 = bitcast double* %166 to <2 x double>*
%168 = load <2 x double>, <2 x double>* %167
%169 = getelementptr inbounds double, double* %149, i64 %162
%170 = bitcast double* %169 to <2 x double>*
%171 = load <2 x double>, <2 x double>* %170
%172 = getelementptr inbounds double, double* %169, i64 2
%173 = bitcast double* %172 to <2 x double>*
%174 = load <2 x double>, <2 x double>* %173
%175 = bitcast double* %163 to <2 x double>*
store <2 x double> %171, <2 x double>* %175
%176 = bitcast double* %166 to <2 x double>*
store <2 x double> %174, <2 x double>* %176
%177 = bitcast double* %169 to <2 x double>*
store <2 x double> %165, <2 x double>* %177
%178 = bitcast double* %172 to <2 x double>*
store <2 x double> %168, <2 x double>* %178
%179 = or i64 %160, 5
%180 = getelementptr inbounds double, double* %147, i64 %179
%181 = bitcast double* %180 to <2 x double>*
%182 = load <2 x double>, <2 x double>* %181
%183 = getelementptr inbounds double, double* %180, i64 2
%184 = bitcast double* %183 to <2 x double>*
%185 = load <2 x double>, <2 x double>* %184
%186 = getelementptr inbounds double, double* %149, i64 %179
%187 = bitcast double* %186 to <2 x double>*
%188 = load <2 x double>, <2 x double>* %187
%189 = getelementptr inbounds double, double* %186, i64 2
%190 = bitcast double* %189 to <2 x double>*
%191 = load <2 x double>, <2 x double>* %190
%192 = bitcast double* %180 to <2 x double>*
store <2 x double> %188, <2 x double>* %192
%193 = bitcast double* %183 to <2 x double>*
store <2 x double> %191, <2 x double>* %193
%194 = bitcast double* %186 to <2 x double>*
store <2 x double> %182, <2 x double>* %194
%195 = bitcast double* %189 to <2 x double>*
store <2 x double> %185, <2 x double>* %195
%196 = add nuw i64 %160, 8
%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 double, double* %147, i64 %202
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = getelementptr inbounds double, double* %203, i64 2
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = getelementptr inbounds double, double* %149, i64 %202
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = getelementptr inbounds double, double* %209, i64 2
%213 = bitcast double* %212 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = bitcast double* %203 to <2 x double>*
store <2 x double> %211, <2 x double>* %215
%216 = bitcast double* %206 to <2 x double>*
store <2 x double> %214, <2 x double>* %216
%217 = bitcast double* %209 to <2 x double>*
store <2 x double> %205, <2 x double>* %217
%218 = bitcast double* %212 to <2 x double>*
store <2 x double> %208, <2 x double>* %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 double, double* %147, i64 %221
%225 = load double, double* %224
%226 = getelementptr inbounds double, double* %149, i64 %221
%227 = load double, double* %226
store double %227, double* %224
store double %225, double* %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 %134 to i64
%235 = getelementptr inbounds double*, double** %2, i64 %234
%236 = load double*, double** %235
%237 = getelementptr inbounds double*, double** %2, i64 %139
%238 = load double*, double** %237
br i1 %44, label %309, label %239
239: ; preds = %233
%240 = getelementptr double, double* %236, i64 1
%241 = getelementptr double, double* %236, i64 %18
%242 = getelementptr double, double* %238, i64 1
%243 = getelementptr double, double* %238, i64 %18
%244 = icmp ult double* %240, %243
%245 = icmp ult double* %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 double, double* %236, i64 %251
%253 = bitcast double* %252 to <2 x double>*
%254 = load <2 x double>, <2 x double>* %253
%255 = getelementptr inbounds double, double* %252, i64 2
%256 = bitcast double* %255 to <2 x double>*
%257 = load <2 x double>, <2 x double>* %256
%258 = getelementptr inbounds double, double* %238, i64 %251
%259 = bitcast double* %258 to <2 x double>*
%260 = load <2 x double>, <2 x double>* %259
%261 = getelementptr inbounds double, double* %258, i64 2
%262 = bitcast double* %261 to <2 x double>*
%263 = load <2 x double>, <2 x double>* %262
%264 = bitcast double* %252 to <2 x double>*
store <2 x double> %260, <2 x double>* %264
%265 = bitcast double* %255 to <2 x double>*
store <2 x double> %263, <2 x double>* %265
%266 = bitcast double* %258 to <2 x double>*
store <2 x double> %254, <2 x double>* %266
%267 = bitcast double* %261 to <2 x double>*
store <2 x double> %257, <2 x double>* %267
%268 = or i64 %249, 5
%269 = getelementptr inbounds double, double* %236, i64 %268
%270 = bitcast double* %269 to <2 x double>*
%271 = load <2 x double>, <2 x double>* %270
%272 = getelementptr inbounds double, double* %269, i64 2
%273 = bitcast double* %272 to <2 x double>*
%274 = load <2 x double>, <2 x double>* %273
%275 = getelementptr inbounds double, double* %238, i64 %268
%276 = bitcast double* %275 to <2 x double>*
%277 = load <2 x double>, <2 x double>* %276
%278 = getelementptr inbounds double, double* %275, i64 2
%279 = bitcast double* %278 to <2 x double>*
%280 = load <2 x double>, <2 x double>* %279
%281 = bitcast double* %269 to <2 x double>*
store <2 x double> %277, <2 x double>* %281
%282 = bitcast double* %272 to <2 x double>*
store <2 x double> %280, <2 x double>* %282
%283 = bitcast double* %275 to <2 x double>*
store <2 x double> %271, <2 x double>* %283
%284 = bitcast double* %278 to <2 x double>*
store <2 x double> %274, <2 x double>* %284
%285 = add nuw i64 %249, 8
%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 double, double* %236, i64 %291
%293 = bitcast double* %292 to <2 x double>*
%294 = load <2 x double>, <2 x double>* %293
%295 = getelementptr inbounds double, double* %292, i64 2
%296 = bitcast double* %295 to <2 x double>*
%297 = load <2 x double>, <2 x double>* %296
%298 = getelementptr inbounds double, double* %238, i64 %291
%299 = bitcast double* %298 to <2 x double>*
%300 = load <2 x double>, <2 x double>* %299
%301 = getelementptr inbounds double, double* %298, i64 2
%302 = bitcast double* %301 to <2 x double>*
%303 = load <2 x double>, <2 x double>* %302
%304 = bitcast double* %292 to <2 x double>*
store <2 x double> %300, <2 x double>* %304
%305 = bitcast double* %295 to <2 x double>*
store <2 x double> %303, <2 x double>* %305
%306 = bitcast double* %298 to <2 x double>*
store <2 x double> %294, <2 x double>* %306
%307 = bitcast double* %301 to <2 x double>*
store <2 x double> %297, <2 x double>* %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 double, double* %236, i64 %310
%314 = load double, double* %313
%315 = getelementptr inbounds double, double* %238, i64 %310
%316 = load double, double* %315
store double %316, double* %313
store double %314, double* %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 double, double* %147, i64 %322
%324 = load double, double* %323
%325 = getelementptr inbounds double, double* %149, i64 %322
%326 = load double, double* %325
store double %326, double* %323
store double %324, double* %325
%327 = add nuw nsw i64 %322, 1
%328 = getelementptr inbounds double, double* %147, i64 %327
%329 = load double, double* %328
%330 = getelementptr inbounds double, double* %149, i64 %327
%331 = load double, double* %330
store double %331, double* %328
store double %329, double* %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 double, double* %236, i64 %335
%337 = load double, double* %336
%338 = getelementptr inbounds double, double* %238, i64 %335
%339 = load double, double* %338
store double %339, double* %336
store double %337, double* %338
%340 = add nuw nsw i64 %335, 1
%341 = getelementptr inbounds double, double* %236, i64 %340
%342 = load double, double* %341
%343 = getelementptr inbounds double, double* %238, i64 %340
%344 = load double, double* %343
store double %344, double* %341
store double %342, double* %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 %134, i32* %348
%349 = getelementptr inbounds i32, i32* %5, i64 %86
store i32 %135, i32* %349
%350 = getelementptr inbounds double*, double** %0, i64 %139
%351 = load double*, double** %350
%352 = getelementptr inbounds double, double* %351, i64 %139
%353 = load double, double* %352
%354 = fcmp oeq double %353, 0.000000e+00
br i1 %354, label %674, label %355
355: ; preds = %347
%356 = fdiv double 1.000000e+00, %353
store double 1.000000e+00, double* %352
br i1 %55, label %405, label %357
357: ; preds = %355
%358 = insertelement <2 x double> poison, double %356, i64 0
%359 = shufflevector <2 x double> %358, <2 x double> poison, <2 x i32> zeroinitializer
%360 = insertelement <2 x double> poison, double %356, i64 0
%361 = shufflevector <2 x double> %360, <2 x double> poison, <2 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 double, double* %351, i64 %365
%367 = bitcast double* %366 to <2 x double>*
%368 = load <2 x double>, <2 x double>* %367
%369 = getelementptr inbounds double, double* %366, i64 2
%370 = bitcast double* %369 to <2 x double>*
%371 = load <2 x double>, <2 x double>* %370
%372 = fmul <2 x double> %359, %368
%373 = fmul <2 x double> %361, %371
%374 = bitcast double* %366 to <2 x double>*
store <2 x double> %372, <2 x double>* %374
%375 = bitcast double* %369 to <2 x double>*
store <2 x double> %373, <2 x double>* %375
%376 = or i64 %363, 5
%377 = getelementptr inbounds double, double* %351, i64 %376
%378 = bitcast double* %377 to <2 x double>*
%379 = load <2 x double>, <2 x double>* %378
%380 = getelementptr inbounds double, double* %377, i64 2
%381 = bitcast double* %380 to <2 x double>*
%382 = load <2 x double>, <2 x double>* %381
%383 = fmul <2 x double> %359, %379
%384 = fmul <2 x double> %361, %382
%385 = bitcast double* %377 to <2 x double>*
store <2 x double> %383, <2 x double>* %385
%386 = bitcast double* %380 to <2 x double>*
store <2 x double> %384, <2 x double>* %386
%387 = add nuw i64 %363, 8
%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 double, double* %351, i64 %393
%395 = bitcast double* %394 to <2 x double>*
%396 = load <2 x double>, <2 x double>* %395
%397 = getelementptr inbounds double, double* %394, i64 2
%398 = bitcast double* %397 to <2 x double>*
%399 = load <2 x double>, <2 x double>* %398
%400 = fmul <2 x double> %359, %396
%401 = fmul <2 x double> %361, %399
%402 = bitcast double* %394 to <2 x double>*
store <2 x double> %400, <2 x double>* %402
%403 = bitcast double* %397 to <2 x double>*
store <2 x double> %401, <2 x double>* %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 double*, double** %2, i64 %139
%410 = load double*, double** %409
br i1 %63, label %459, label %411
411: ; preds = %408
%412 = insertelement <2 x double> poison, double %356, i64 0
%413 = shufflevector <2 x double> %412, <2 x double> poison, <2 x i32> zeroinitializer
%414 = insertelement <2 x double> poison, double %356, i64 0
%415 = shufflevector <2 x double> %414, <2 x double> poison, <2 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 double, double* %410, i64 %419
%421 = bitcast double* %420 to <2 x double>*
%422 = load <2 x double>, <2 x double>* %421
%423 = getelementptr inbounds double, double* %420, i64 2
%424 = bitcast double* %423 to <2 x double>*
%425 = load <2 x double>, <2 x double>* %424
%426 = fmul <2 x double> %413, %422
%427 = fmul <2 x double> %415, %425
%428 = bitcast double* %420 to <2 x double>*
store <2 x double> %426, <2 x double>* %428
%429 = bitcast double* %423 to <2 x double>*
store <2 x double> %427, <2 x double>* %429
%430 = or i64 %417, 5
%431 = getelementptr inbounds double, double* %410, i64 %430
%432 = bitcast double* %431 to <2 x double>*
%433 = load <2 x double>, <2 x double>* %432
%434 = getelementptr inbounds double, double* %431, i64 2
%435 = bitcast double* %434 to <2 x double>*
%436 = load <2 x double>, <2 x double>* %435
%437 = fmul <2 x double> %413, %433
%438 = fmul <2 x double> %415, %436
%439 = bitcast double* %431 to <2 x double>*
store <2 x double> %437, <2 x double>* %439
%440 = bitcast double* %434 to <2 x double>*
store <2 x double> %438, <2 x double>* %440
%441 = add nuw i64 %417, 8
%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 double, double* %410, i64 %447
%449 = bitcast double* %448 to <2 x double>*
%450 = load <2 x double>, <2 x double>* %449
%451 = getelementptr inbounds double, double* %448, i64 2
%452 = bitcast double* %451 to <2 x double>*
%453 = load <2 x double>, <2 x double>* %452
%454 = fmul <2 x double> %413, %450
%455 = fmul <2 x double> %415, %453
%456 = bitcast double* %448 to <2 x double>*
store <2 x double> %454, <2 x double>* %456
%457 = bitcast double* %451 to <2 x double>*
store <2 x double> %455, <2 x double>* %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 double, double* %351, i64 %462
%464 = load double, double* %463
%465 = fmul double %356, %464
store double %465, double* %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 double*, double** %2, i64 %139
%470 = zext i32 %135 to i64
%471 = getelementptr double, double* %351, i64 1
%472 = getelementptr double, double* %351, i64 %17
br label %480
473: ; preds = %459, %473
%474 = phi i64 [ %478, %473 ], [ %460, %459 ]
%475 = getelementptr inbounds double, double* %410, i64 %474
%476 = load double, double* %475
%477 = fmul double %356, %476
store double %477, double* %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 double*, double** %0, i64 %481
%485 = load double*, double** %484
%486 = getelementptr inbounds double, double* %485, i64 %139
%487 = load double, double* %486
store double 0.000000e+00, double* %486
br i1 %71, label %523, label %488
488: ; preds = %483
%489 = getelementptr double, double* %485, i64 1
%490 = getelementptr double, double* %485, i64 %17
%491 = icmp ult double* %489, %472
%492 = icmp ult double* %471, %490
%493 = and i1 %491, %492
br i1 %493, label %523, label %494
494: ; preds = %488
%495 = insertelement <2 x double> poison, double %487, i64 0
%496 = shufflevector <2 x double> %495, <2 x double> poison, <2 x i32> zeroinitializer
%497 = insertelement <2 x double> poison, double %487, i64 0
%498 = shufflevector <2 x double> %497, <2 x double> poison, <2 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 double, double* %351, i64 %501
%503 = bitcast double* %502 to <2 x double>*
%504 = load <2 x double>, <2 x double>* %503
%505 = getelementptr inbounds double, double* %502, i64 2
%506 = bitcast double* %505 to <2 x double>*
%507 = load <2 x double>, <2 x double>* %506
%508 = getelementptr inbounds double, double* %485, i64 %501
%509 = bitcast double* %508 to <2 x double>*
%510 = load <2 x double>, <2 x double>* %509
%511 = getelementptr inbounds double, double* %508, i64 2
%512 = bitcast double* %511 to <2 x double>*
%513 = load <2 x double>, <2 x double>* %512
%514 = fneg <2 x double> %504
%515 = fneg <2 x double> %507
%516 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %514, <2 x double> %496, <2 x double> %510)
%517 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %515, <2 x double> %498, <2 x double> %513)
%518 = bitcast double* %508 to <2 x double>*
store <2 x double> %516, <2 x double>* %518
%519 = bitcast double* %511 to <2 x double>*
store <2 x double> %517, <2 x double>* %519
%520 = add nuw i64 %500, 4
%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 double, double* %351, i64 %524
%528 = load double, double* %527
%529 = getelementptr inbounds double, double* %485, i64 %524
%530 = load double, double* %529
%531 = fneg double %528
%532 = tail call double @llvm.fmuladd.f64(double %531, double %487, double %530)
store double %532, double* %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 double*, double** %469
%540 = getelementptr inbounds double*, double** %2, i64 %481
%541 = load double*, double** %540
br i1 %78, label %579, label %542
542: ; preds = %538
%543 = getelementptr double, double* %541, i64 1
%544 = getelementptr double, double* %541, i64 %18
%545 = getelementptr double, double* %539, i64 1
%546 = getelementptr double, double* %539, i64 %18
%547 = icmp ult double* %543, %546
%548 = icmp ult double* %545, %544
%549 = and i1 %547, %548
br i1 %549, label %579, label %550
550: ; preds = %542
%551 = insertelement <2 x double> poison, double %487, i64 0
%552 = shufflevector <2 x double> %551, <2 x double> poison, <2 x i32> zeroinitializer
%553 = insertelement <2 x double> poison, double %487, i64 0
%554 = shufflevector <2 x double> %553, <2 x double> poison, <2 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 double, double* %539, i64 %557
%559 = bitcast double* %558 to <2 x double>*
%560 = load <2 x double>, <2 x double>* %559
%561 = getelementptr inbounds double, double* %558, i64 2
%562 = bitcast double* %561 to <2 x double>*
%563 = load <2 x double>, <2 x double>* %562
%564 = getelementptr inbounds double, double* %541, i64 %557
%565 = bitcast double* %564 to <2 x double>*
%566 = load <2 x double>, <2 x double>* %565
%567 = getelementptr inbounds double, double* %564, i64 2
%568 = bitcast double* %567 to <2 x double>*
%569 = load <2 x double>, <2 x double>* %568
%570 = fneg <2 x double> %560
%571 = fneg <2 x double> %563
%572 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %570, <2 x double> %552, <2 x double> %566)
%573 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %571, <2 x double> %554, <2 x double> %569)
%574 = bitcast double* %564 to <2 x double>*
store <2 x double> %572, <2 x double>* %574
%575 = bitcast double* %567 to <2 x double>*
store <2 x double> %573, <2 x double>* %575
%576 = add nuw i64 %556, 4
%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 double, double* %539, i64 %580
%584 = load double, double* %583
%585 = getelementptr inbounds double, double* %541, i64 %580
%586 = load double, double* %585
%587 = fneg double %584
%588 = tail call double @llvm.fmuladd.f64(double %587, double %487, double %586)
store double %588, double* %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 double, double* %351, i64 %594
%596 = load double, double* %595
%597 = getelementptr inbounds double, double* %485, i64 %594
%598 = load double, double* %597
%599 = fneg double %596
%600 = tail call double @llvm.fmuladd.f64(double %599, double %487, double %598)
store double %600, double* %597
%601 = add nuw nsw i64 %594, 1
%602 = getelementptr inbounds double, double* %351, i64 %601
%603 = load double, double* %602
%604 = getelementptr inbounds double, double* %485, i64 %601
%605 = load double, double* %604
%606 = fneg double %603
%607 = tail call double @llvm.fmuladd.f64(double %606, double %487, double %605)
store double %607, double* %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 double, double* %539, i64 %611
%613 = load double, double* %612
%614 = getelementptr inbounds double, double* %541, i64 %611
%615 = load double, double* %614
%616 = fneg double %613
%617 = tail call double @llvm.fmuladd.f64(double %616, double %487, double %615)
store double %617, double* %614
%618 = add nuw nsw i64 %611, 1
%619 = getelementptr inbounds double, double* %539, i64 %618
%620 = load double, double* %619
%621 = getelementptr inbounds double, double* %541, i64 %618
%622 = load double, double* %621
%623 = fneg double %620
%624 = tail call double @llvm.fmuladd.f64(double %623, double %487, double %622)
store double %624, double* %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 double*, double** %0, i64 %644
%647 = load double*, double** %646
%648 = getelementptr inbounds double, double* %647, i64 %641
%649 = load double, double* %648
%650 = getelementptr inbounds double, double* %647, i64 %642
%651 = load double, double* %650
store double %651, double* %648
store double %649, double* %650
%652 = add nuw nsw i64 %644, 1
%653 = getelementptr inbounds double*, double** %0, i64 %652
%654 = load double*, double** %653
%655 = getelementptr inbounds double, double* %654, i64 %641
%656 = load double, double* %655
%657 = getelementptr inbounds double, double* %654, i64 %642
%658 = load double, double* %657
store double %658, double* %655
store double %656, double* %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 double*, double** %0, i64 %663
%666 = load double*, double** %665
%667 = getelementptr inbounds double, double* %666, i64 %641
%668 = load double, double* %667
%669 = getelementptr inbounds double, double* %666, i64 %642
%670 = load double, double* %669
store double %670, double* %667
store double %668, double* %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 %678
674: ; preds = %347, %124
%675 = phi i8* [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), %124 ], [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0), %347 ]
%676 = load i32, i32* @stderr
%677 = tail call i32 @fprintf(i32 %676, i8* %675)
br label %678
678: ; preds = %671, %674, %4, %89
%679 = phi i32 [ 1, %89 ], [ 1, %4 ], [ 0, %674 ], [ 1, %671 ]
%680 = tail call i32 @free_ivector(i32* %7, i32 1)
%681 = tail call i32 @free_ivector(i32* %6, i32 1)
%682 = tail call i32 @free_ivector(i32* %5, i32 1)
ret i32 %679
}