#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 gaussj(double *a, int n, double *b, int m) {
  int icol = 0, ipiv[64], irow = 0, i, j, k, l, indxc[64], indxr[64], ll;
  double pivinv, big, dum;
  if (n > 64)
    return (1);
  for (j = 0; j < n; ++j)
    ipiv[j] = 0;
  for (i = 0; i < n; ++i) {
    big = 0.0;
    for (j = 0; j < n; ++j)
      if (ipiv[j] != 1)
        for (k = 0; k < n; ++k) {
          if (ipiv[k] == 0) {
            if (fabs(a[j + k * n]) >= big) {
              big = fabs(a[j + k * n]);
              irow = j;
              icol = k;
            }
          } else if (ipiv[k] > 1)
            return (1);
        }
    ++ipiv[icol];
    if (irow != icol) {
      for (l = 0; l < n; ++l) {
        dum = a[irow + l * n];
        a[irow + l * n] = a[icol + l * n];
        a[icol + l * n] = dum;
      }
      for (l = 0; l < m; ++l) {
        dum = b[irow + l * n];
        b[irow + l * n] = b[icol + l * n];
        b[icol + l * n] = dum;
      }
    }
    indxr[i] = irow;
    indxc[i] = icol;
    if (a[icol + icol * n] == 0.0)
      return (1);
    pivinv = 1.0 / a[icol + icol * n];
    a[icol + icol * n] = 1.0;
    for (l = 0; l < n; ++l)
      a[icol + l * n] *= pivinv;
    for (l = 0; l < m; ++l)
      b[icol + l * n] *= pivinv;
    for (ll = 0; ll < n; ++ll)
      if (ll != icol) {
        dum = a[ll + icol * n];
        a[ll + icol * n] = 0.0;
        for (l = 0; l < n; ++l)
          a[ll + l * n] -= a[icol + l * n] * dum;
        for (l = 0; l < m; ++l)
          b[ll + l * n] -= b[icol + l * n] * dum;
      }
  }
  for (l = n - 1; l >= 0; --l)
    if (indxr[l] != indxc[l])
      for (k = 0; k < n; ++k) {
        dum = a[k + indxr[l] * n];
        a[k + indxr[l] * n] = a[k + indxc[l] * n];
        a[k + indxc[l] * n] = dum;
      }
  return (0);
}


x86 assembly (clang, -O0):
<gaussj>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2f0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x134(%rbp)
cmpl   $0x40,-0x14(%rbp)
jle    1140 <gaussj+0x40>
movl   $0x1,-0x4(%rbp)
jmp    18ac <gaussj+0x7ac>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    117f <gaussj+0x7f>
movslq -0x13c(%rbp),%rax
movl   $0x0,-0x130(%rbp,%rax,4)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    114a <gaussj+0x4a>
movl   $0x0,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1777 <gaussj+0x677>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12de <gaussj+0x1de>
movslq -0x13c(%rbp),%rax
cmpl   $0x1,-0x130(%rbp,%rax,4)
01
je     12c5 <gaussj+0x1c5>
movl   $0x0,-0x140(%rbp)
mov    -0x140(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12c0 <gaussj+0x1c0>
movslq -0x140(%rbp),%rax
cmpl   $0x0,-0x130(%rbp,%rax,4)
jne    1281 <gaussj+0x181>
mov    -0x10(%rbp),%rax
mov    -0x13c(%rbp),%ecx
mov    -0x140(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdec(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x368(%rbp),%xmm0
ff
jb     127c <gaussj+0x17c>
mov    -0x10(%rbp),%rax
mov    -0x13c(%rbp),%ecx
mov    -0x140(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdb5(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
mov    -0x13c(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x140(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    12a7 <gaussj+0x1a7>
movslq -0x140(%rbp),%rax
cmpl   $0x1,-0x130(%rbp,%rax,4)
01
jle    12a2 <gaussj+0x1a2>
movl   $0x1,-0x4(%rbp)
jmp    18ac <gaussj+0x7ac>
jmp    12a7 <gaussj+0x1a7>
jmp    12ac <gaussj+0x1ac>
mov    -0x140(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x140(%rbp)
jmp    11db <gaussj+0xdb>
jmp    12c5 <gaussj+0x1c5>
jmp    12ca <gaussj+0x1ca>
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    11ad <gaussj+0xad>
movslq -0x28(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x134(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1465 <gaussj+0x365>
movl   $0x0,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13b1 <gaussj+0x2b1>
mov    -0x10(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x370(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    130c <gaussj+0x20c>
movl   $0x0,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1460 <gaussj+0x360>
mov    -0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x370(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    13bb <gaussj+0x2bb>
jmp    1465 <gaussj+0x365>
mov    -0x134(%rbp),%ecx
movslq -0x138(%rbp),%rax
mov    %ecx,-0x350(%rbp,%rax,4)
mov    -0x28(%rbp),%ecx
movslq -0x138(%rbp),%rax
mov    %ecx,-0x250(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14c1 <gaussj+0x3c1>
jp     14c1 <gaussj+0x3c1>
movl   $0x1,-0x4(%rbp)
jmp    18ac <gaussj+0x7ac>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xb24(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x360(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xafc(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    155e <gaussj+0x45e>
movsd  -0x360(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    1513 <gaussj+0x413>
movl   $0x0,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15b3 <gaussj+0x4b3>
movsd  -0x360(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    1568 <gaussj+0x468>
movl   $0x0,-0x354(%rbp)
mov    -0x354(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    175e <gaussj+0x65e>
mov    -0x354(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1745 <gaussj+0x645>
mov    -0x10(%rbp),%rax
mov    -0x354(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x354(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16ae <gaussj+0x5ae>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x370(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
mov    -0x354(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%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    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    1626 <gaussj+0x526>
movl   $0x0,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1740 <gaussj+0x640>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x370(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x354(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%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    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    16b8 <gaussj+0x5b8>
jmp    1745 <gaussj+0x645>
jmp    174a <gaussj+0x64a>
mov    -0x354(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x354(%rbp)
jmp    15bd <gaussj+0x4bd>
jmp    1763 <gaussj+0x663>
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1189 <gaussj+0x89>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0x0,-0x144(%rbp)
jl     18a5 <gaussj+0x7a5>
movslq -0x144(%rbp),%rax
mov    -0x350(%rbp,%rax,4),%eax
movslq -0x144(%rbp),%rcx
cmp    -0x250(%rbp,%rcx,4),%eax
je     188c <gaussj+0x78c>
movl   $0x0,-0x140(%rbp)
mov    -0x140(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1887 <gaussj+0x787>
mov    -0x10(%rbp),%rax
mov    -0x140(%rbp),%ecx
movslq -0x144(%rbp),%rdx
mov    -0x350(%rbp,%rdx,4),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x140(%rbp),%ecx
movslq -0x144(%rbp),%rdx
mov    -0x250(%rbp,%rdx,4),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x140(%rbp),%ecx
movslq -0x144(%rbp),%rdx
mov    -0x350(%rbp,%rdx,4),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x370(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x140(%rbp),%ecx
movslq -0x144(%rbp),%rdx
mov    -0x250(%rbp,%rdx,4),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x140(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x140(%rbp)
jmp    17bc <gaussj+0x6bc>
jmp    188c <gaussj+0x78c>
jmp    1891 <gaussj+0x791>
mov    -0x144(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x144(%rbp)
jmp    1783 <gaussj+0x683>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussj>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x368,%rsp
mov    $0x1,%eax
cmp    $0x40,%esi
jg     168c <gaussj+0x57c>
mov    %esi,%r14d
test   %esi,%esi
jle    168a <gaussj+0x57a>
mov    %ecx,%r15d
mov    %rdi,%rbx
mov    %rdx,0x10(%rsp)
mov    %r14d,%r12d
lea    0x0(,%r12,4),%rdx
lea    0x60(%rsp),%rdi
xor    %eax,%eax
mov    %rax,0x48(%rsp)
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r15d,%r13d
lea    -0x1(%r12),%rdi
lea    -0x1(%r13),%rax
mov    %rax,0x20(%rsp)
mov    %r12d,%r10d
and    $0xfffffffe,%r10d
mov    %r13,0x28(%rsp)
and    $0xfffffffe,%r13d
lea    0x0(,%r12,8),%r8
mov    %r12,%rbp
shl    $0x4,%rbp
xorpd  %xmm0,%xmm0
movsd  0xe71(%rip),%xmm1
movapd 0xe59(%rip),%xmm2
xor    %r11d,%r11d
xor    %esi,%esi
mov    %rbx,0x8(%rsp)
mov    %rdi,0x50(%rsp)
mov    %rbx,%rcx
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
jmp    11dd <gaussj+0xcd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x8,%rcx
cmp    %r12,%rbx
je     1226 <gaussj+0x116>
cmpl   $0x1,0x60(%rsp,%rbx,4)
je     11d0 <gaussj+0xc0>
mov    %rcx,%rdx
xor    %eax,%eax
jmp    1205 <gaussj+0xf5>
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%edi
jg     1683 <gaussj+0x573>
add    $0x1,%rax
add    %r8,%rdx
cmp    %rax,%r12
je     11d0 <gaussj+0xc0>
mov    0x60(%rsp,%rax,4),%edi
test   %edi,%edi
jne    11f0 <gaussj+0xe0>
movsd  (%rdx),%xmm4
andpd  %xmm2,%xmm4
ucomisd %xmm3,%xmm4
jb     11f9 <gaussj+0xe9>
mov    %eax,%esi
mov    %ebx,%r11d
movapd %xmm4,%xmm3
jmp    11f9 <gaussj+0xe9>
mov    %rsi,0x40(%rsp)
movslq %esi,%r9
addl   $0x1,0x60(%rsp,%r9,4)
mov    %r11d,0x1c(%rsp)
cmp    %r9d,%r11d
mov    0x8(%rsp),%rbx
mov    0x50(%rsp),%rdi
je     1369 <gaussj+0x259>
movslq 0x1c(%rsp),%rsi
test   %rdi,%rdi
je     12a8 <gaussj+0x198>
lea    (%r12,%r9,1),%rcx
lea    (%r12,%rsi,1),%rbx
mov    0x8(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rsi,8),%xmm3
movsd  (%rdx,%r9,8),%xmm4
movsd  %xmm4,(%rdx,%rsi,8)
movsd  %xmm3,(%rdx,%r9,8)
movsd  (%rdx,%rbx,8),%xmm3
movsd  (%rdx,%rcx,8),%xmm4
movsd  %xmm4,(%rdx,%rbx,8)
movsd  %xmm3,(%rdx,%rcx,8)
add    $0x2,%rax
add    %rbp,%rdx
cmp    %rax,%r10
jne    1270 <gaussj+0x160>
jmp    12aa <gaussj+0x19a>
xor    %eax,%eax
test   $0x1,%r12b
mov    0x8(%rsp),%rbx
je     12d4 <gaussj+0x1c4>
imul   %r12,%rax
lea    (%rax,%rsi,1),%rcx
movsd  (%rbx,%rcx,8),%xmm3
add    %r9,%rax
movsd  (%rbx,%rax,8),%xmm4
movsd  %xmm4,(%rbx,%rcx,8)
movsd  %xmm3,(%rbx,%rax,8)
test   %r15d,%r15d
jle    1369 <gaussj+0x259>
cmpq   $0x0,0x20(%rsp)
je     1338 <gaussj+0x228>
lea    (%r12,%r9,1),%rcx
lea    (%r12,%rsi,1),%rbx
mov    0x10(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rsi,8),%xmm3
movsd  (%rdx,%r9,8),%xmm4
movsd  %xmm4,(%rdx,%rsi,8)
movsd  %xmm3,(%rdx,%r9,8)
movsd  (%rdx,%rbx,8),%xmm3
movsd  (%rdx,%rcx,8),%xmm4
movsd  %xmm4,(%rdx,%rbx,8)
movsd  %xmm3,(%rdx,%rcx,8)
add    $0x2,%rax
add    %rbp,%rdx
cmp    %rax,%r13
jne    1300 <gaussj+0x1f0>
jmp    133a <gaussj+0x22a>
xor    %eax,%eax
testb  $0x1,0x28(%rsp)
mov    0x8(%rsp),%rbx
je     1369 <gaussj+0x259>
imul   %r12,%rax
add    %rax,%rsi
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm3
add    %r9,%rax
movsd  (%rcx,%rax,8),%xmm4
movsd  %xmm4,(%rcx,%rsi,8)
movsd  %xmm3,(%rcx,%rax,8)
mov    0x48(%rsp),%rax
mov    0x1c(%rsp),%ecx
mov    %ecx,0x160(%rsp,%rax,4)
mov    0x40(%rsp),%rcx
mov    %ecx,0x260(%rsp,%rax,4)
mov    %ecx,%edx
imul   %r14d,%edx
lea    (%rdx,%rcx,1),%eax
cltq
movsd  (%rbx,%rax,8),%xmm4
ucomisd %xmm0,%xmm4
jne    13a1 <gaussj+0x291>
jnp    1683 <gaussj+0x573>
movapd %xmm1,%xmm3
divsd  %xmm4,%xmm3
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rbx,%rax,8)
test   %rdi,%rdi
je     13fc <gaussj+0x2ec>
lea    (%r12,%r9,1),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%r9,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%r9,8)
movsd  (%rbx,%rcx,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%rcx,8)
add    $0x2,%rax
add    %rbp,%rbx
cmp    %rax,%r10
jne    13d0 <gaussj+0x2c0>
jmp    13fe <gaussj+0x2ee>
xor    %eax,%eax
test   $0x1,%r12b
mov    0x8(%rsp),%rbx
je     141e <gaussj+0x30e>
imul   %r12,%rax
add    %r9,%rax
movsd  (%rbx,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%rax,8)
mov    %r14d,0x34(%rsp)
test   %r15d,%r15d
jle    1490 <gaussj+0x380>
cmpq   $0x0,0x20(%rsp)
je     146c <gaussj+0x35c>
lea    (%r12,%r9,1),%rcx
mov    0x10(%rsp),%rbx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%r9,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%r9,8)
movsd  (%rbx,%rcx,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%rcx,8)
add    $0x2,%rax
add    %rbp,%rbx
cmp    %rax,%r13
jne    1440 <gaussj+0x330>
jmp    146e <gaussj+0x35e>
xor    %eax,%eax
testb  $0x1,0x28(%rsp)
mov    0x8(%rsp),%rbx
je     1490 <gaussj+0x380>
imul   %r12,%rax
add    %r9,%rax
mov    0x10(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm3
movsd  %xmm3,(%rcx,%rax,8)
mov    %r15d,0x38(%rsp)
movslq %edx,%rax
mov    %rax,0x58(%rsp)
mov    0x40(%rsp),%esi
lea    (%r12,%r9,1),%r11
xor    %r15d,%r15d
mov    %r8,%rdx
xor    %r14d,%r14d
jmp    14c5 <gaussj+0x3b5>
add    $0x1,%r14
add    $0x8,%rdx
add    $0x8,%r15
cmp    %r12,%r14
je     1603 <gaussj+0x4f3>
cmp    %rsi,%r14
je     14b0 <gaussj+0x3a0>
mov    0x58(%rsp),%rax
add    %r14,%rax
movsd  (%rbx,%rax,8),%xmm3
movq   $0x0,(%rbx,%rax,8)
test   %rdi,%rdi
je     15bb <gaussj+0x4ab>
mov    %rbx,%rcx
xor    %eax,%eax
nopl   (%rax)
movsd  (%rcx,%r15,1),%xmm4
movsd  (%rcx,%r9,8),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rcx,%r15,1)
movsd  (%rcx,%rdx,1),%xmm4
movsd  (%rcx,%r11,8),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rcx,%rdx,1)
add    $0x2,%rax
add    %rbp,%rcx
cmp    %rax,%r10
jne    14f0 <gaussj+0x3e0>
test   $0x1,%r12b
je     1556 <gaussj+0x446>
imul   %r12,%rax
lea    (%rax,%r9,1),%rcx
add    %r14,%rax
movsd  (%rbx,%rax,8),%xmm4
movsd  (%rbx,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rbx,%rax,8)
cmpl   $0x0,0x38(%rsp)
jle    14b0 <gaussj+0x3a0>
cmpq   $0x0,0x20(%rsp)
je     15c9 <gaussj+0x4b9>
mov    0x10(%rsp),%rcx
xor    %eax,%eax
movsd  (%rcx,%r15,1),%xmm4
movsd  (%rcx,%r9,8),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rcx,%r15,1)
movsd  (%rcx,%rdx,1),%xmm4
movsd  (%rcx,%r11,8),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rcx,%rdx,1)
add    $0x2,%rax
add    %rbp,%rcx
cmp    %rax,%r13
jne    1570 <gaussj+0x460>
testb  $0x1,0x28(%rsp)
je     14b0 <gaussj+0x3a0>
jmp    15d6 <gaussj+0x4c6>
xor    %eax,%eax
test   $0x1,%r12b
jne    1534 <gaussj+0x424>
jmp    1556 <gaussj+0x446>
xor    %eax,%eax
testb  $0x1,0x28(%rsp)
je     14b0 <gaussj+0x3a0>
imul   %r12,%rax
lea    (%rax,%r9,1),%rcx
add    %r14,%rax
mov    0x10(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm4
mulsd  (%rdi,%rcx,8),%xmm3
subsd  %xmm3,%xmm4
movsd  %xmm4,(%rdi,%rax,8)
mov    0x50(%rsp),%rdi
jmp    14b0 <gaussj+0x3a0>
mov    0x48(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
cmp    %r12,%rcx
mov    0x34(%rsp),%r14d
mov    0x38(%rsp),%r15d
mov    0x1c(%rsp),%r11d
mov    0x40(%rsp),%rsi
jne    11b6 <gaussj+0xa6>
test   %r14d,%r14d
jle    168a <gaussj+0x57a>
lea    (%rbx,%r12,8),%r15
mov    %r12d,%eax
and    $0xfffffffe,%eax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x10(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %r12d,%r14d
and    $0xfffffffe,%r14d
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x20(%rsp)
mov    %r12,%r10
neg    %r10
lea    0x10(%rbx),%rax
mov    %rax,0x38(%rsp)
lea    0x8(%rbx),%r13
mov    %r12,%rdx
jmp    16a6 <gaussj+0x596>
mov    $0x1,%eax
jmp    168c <gaussj+0x57c>
xor    %eax,%eax
add    $0x368,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
cmp    $0x1,%rcx
jle    168c <gaussj+0x57c>
mov    %rdx,%rcx
add    $0xffffffffffffffff,%rdx
mov    %edx,%esi
mov    0x160(%rsp,%rsi,4),%eax
mov    0x260(%rsp,%rsi,4),%edi
cmp    %edi,%eax
je     169e <gaussj+0x58e>
mov    0x34(%rsp),%ebp
imul   %ebp,%eax
imul   %ebp,%edi
movslq %eax,%r11
movslq %edi,%rax
cmp    $0x2,%ebp
jb     170b <gaussj+0x5fb>
mov    0x8(%rsp),%rbp
lea    0x0(,%r11,8),%rdi
add    %rbp,%rdi
lea    (%r15,%rax,8),%rbx
cmp    %rbx,%rdi
jae    179a <gaussj+0x68a>
lea    (%r15,%r11,8),%rdi
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
cmp    %rdi,%rbx
jae    179a <gaussj+0x68a>
xor    %edi,%edi
mov    %rdi,%rbx
test   $0x1,%r12b
je     173e <gaussj+0x62e>
lea    (%rdi,%r11,1),%rbx
mov    0x8(%rsp),%rsi
movsd  (%rsi,%rbx,8),%xmm0
lea    (%rdi,%rax,1),%rbp
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbx,8)
movsd  %xmm0,(%rsi,%rbp,8)
mov    %rdi,%rbx
or     $0x1,%rbx
not    %rdi
cmp    %r10,%rdi
je     169e <gaussj+0x58e>
lea    0x0(,%rax,8),%rax
add    %r13,%rax
lea    0x0(,%r11,8),%rsi
add    %r13,%rsi
movsd  -0x8(%rsi,%rbx,8),%xmm0
movsd  -0x8(%rax,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rbx,8)
movsd  %xmm0,-0x8(%rax,%rbx,8)
movsd  (%rsi,%rbx,8),%xmm0
movsd  (%rax,%rbx,8),%xmm1
movsd  %xmm1,(%rsi,%rbx,8)
movsd  %xmm0,(%rax,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r12
jne    1760 <gaussj+0x650>
jmp    169e <gaussj+0x58e>
cmpq   $0x0,0x10(%rsp)
je     17ee <gaussj+0x6de>
mov    0x38(%rsp),%rsi
lea    (%rsi,%r11,8),%rdi
lea    (%rsi,%rax,8),%r8
mov    0x20(%rsp),%r9
xor    %ebx,%ebx
movups -0x10(%rdi,%rbx,8),%xmm0
movups -0x10(%r8,%rbx,8),%xmm1
movups %xmm1,-0x10(%rdi,%rbx,8)
movups %xmm0,-0x10(%r8,%rbx,8)
movupd (%rdi,%rbx,8),%xmm0
movupd (%r8,%rbx,8),%xmm1
movupd %xmm1,(%rdi,%rbx,8)
movupd %xmm0,(%r8,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%r9
jne    17b6 <gaussj+0x6a6>
jmp    17f0 <gaussj+0x6e0>
xor    %ebx,%ebx
testb  $0x1,0x28(%rsp)
je     181b <gaussj+0x70b>
lea    (%rbx,%r11,1),%rdi
mov    0x8(%rsp),%rbp
movupd 0x0(%rbp,%rdi,8),%xmm0
add    %rax,%rbx
movupd 0x0(%rbp,%rbx,8),%xmm1
movupd %xmm1,0x0(%rbp,%rdi,8)
movupd %xmm0,0x0(%rbp,%rbx,8)
mov    %r14,%rdi
cmp    %r12,%r14
je     169e <gaussj+0x58e>
jmp    170d <gaussj+0x5fd>

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

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