#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 *dvector(int /*<<< orphan*/, int);
double fabs(double);
int /*<<< orphan*/ free_dvector(double *, int /*<<< orphan*/, int);
int lu_decomp(double **a, int n, int *pivx, double *rip) {
  int i, j;
  double *rscale, RSCALE[10];
  if (n <= 10)
    rscale = RSCALE;
  else
    rscale = dvector(0, n - 1);
  for (i = 0; i < n; i++) {
    double big;
    for (big = 0.0, j = 0; j < n; j++) {
      double temp;
      temp = fabs(a[i][j]);
      if (temp > big)
        big = temp;
    }
    if (fabs(big) <= 2.2250738585072014e-308) {
      if (rscale != RSCALE)
        free_dvector(rscale, 0, n - 1);
      return 1;
    }
    rscale[i] = 1.0 / big;
  }
  for (*rip = 1.0, j = 0; j < n; j++) {
    double big;
    int k, bigi = 0;
    for (i = 0; i < j; i++) {
      double sum;
      sum = a[i][j];
      for (k = 0; k < i; k++)
        sum -= a[i][k] * a[k][j];
      a[i][j] = sum;
    }
    for (big = 0.0, i = j; i < n; i++) {
      double sum, temp;
      sum = a[i][j];
      for (k = 0; k < j; k++)
        sum -= a[i][k] * a[k][j];
      a[i][j] = sum;
      temp = rscale[i] * fabs(sum);
      if (temp >= big) {
        big = temp;
        bigi = i;
      }
    }
    if (j != bigi) {
      {
        double *temp;
        temp = a[bigi];
        a[bigi] = a[j];
        a[j] = temp;
      }
      *rip = -(*rip);
      rscale[bigi] = rscale[j];
    }
    pivx[j] = bigi;
    if (fabs(a[j][j]) <= 2.2250738585072014e-308) {
      if (rscale != RSCALE)
        free_dvector(rscale, 0, n - 1);
      return 1;
    }
    if (j != (n - 1)) {
      double temp;
      temp = 1.0 / a[j][j];
      for (i = j + 1; i < n; i++)
        a[i][j] *= temp;
    }
  }
  if (rscale != RSCALE)
    free_dvector(rscale, 0, n - 1);
  return 0;
}


x86 assembly (clang, -O0):
<lu_decomp>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
cmpl   $0xa,-0x14(%rbp)
jg     1154 <lu_decomp+0x34>
lea    -0x90(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1165 <lu_decomp+0x45>
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1030 <dvector@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1278 <lu_decomp+0x158>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11f7 <lu_decomp+0xd7>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe5e(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jbe    11e4 <lu_decomp+0xc4>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
jmp    11e9 <lu_decomp+0xc9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118a <lu_decomp+0x6a>
movsd  -0x98(%rbp),%xmm1
ff
movaps 0xe0a(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xdf6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     124d <lu_decomp+0x12d>
mov    -0x38(%rbp),%rax
lea    -0x90(%rbp),%rcx
cmp    %rcx,%rax
je     1241 <lu_decomp+0x121>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1040 <free_dvector@plt>
movl   $0x1,-0x4(%rbp)
jmp    16a7 <lu_decomp+0x587>
movsd  0xdab(%rip),%xmm0
divsd  -0x98(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116c <lu_decomp+0x4c>
mov    -0x28(%rbp),%rax
movsd  0xd7c(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    167b <lu_decomp+0x55b>
movl   $0x0,-0xb0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    138c <lu_decomp+0x26c>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1361 <lu_decomp+0x241>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    12df <lu_decomp+0x1bf>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ac <lu_decomp+0x18c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14dd <lu_decomp+0x3bd>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1452 <lu_decomp+0x332>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    13d0 <lu_decomp+0x2b0>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xc0(%rbp),%xmm1
ff
movaps 0xb85(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd -0xa8(%rbp),%xmm0
ff
jb     14ca <lu_decomp+0x3aa>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
jmp    14cf <lu_decomp+0x3af>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    139d <lu_decomp+0x27d>
mov    -0x30(%rbp),%eax
cmp    -0xb0(%rbp),%eax
je     1574 <lu_decomp+0x454>
mov    -0x10(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xa6f(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xa5b(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     15e8 <lu_decomp+0x4c8>
mov    -0x38(%rbp),%rax
lea    -0x90(%rbp),%rcx
cmp    %rcx,%rax
je     15dc <lu_decomp+0x4bc>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1040 <free_dvector@plt>
movl   $0x1,-0x4(%rbp)
jmp    16a7 <lu_decomp+0x587>
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1668 <lu_decomp+0x548>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  0x9ef(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1663 <lu_decomp+0x543>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1627 <lu_decomp+0x507>
jmp    1668 <lu_decomp+0x548>
jmp    166d <lu_decomp+0x54d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    128f <lu_decomp+0x16f>
mov    -0x38(%rbp),%rax
lea    -0x90(%rbp),%rcx
cmp    %rcx,%rax
je     16a0 <lu_decomp+0x580>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1040 <free_dvector@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lu_decomp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r14
mov    %rdx,0x8(%rsp)
mov    %esi,%r12d
mov    %rdi,%r15
cmp    $0xb,%esi
jge    1151 <lu_decomp+0x31>
test   %r12d,%r12d
jle    14f5 <lu_decomp+0x3d5>
lea    0x10(%rsp),%rax
jmp    115d <lu_decomp+0x3d>
lea    -0x1(%r12),%esi
xor    %edi,%edi
call   1030 <dvector@plt>
mov    %r12d,%r11d
lea    -0x1(%r11),%r8
mov    %r11d,%esi
and    $0x3,%esi
mov    %r11d,%edi
and    $0xfffffffc,%edi
xor    %edx,%edx
movapd 0xe86(%rip),%xmm0
movsd  0xe9e(%rip),%xmm1
movsd  0xe9d(%rip),%xmm8
movapd 0xe6d(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rdx,8),%rcx
cmp    $0x3,%r8
jae    11c0 <lu_decomp+0xa0>
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    1214 <lu_decomp+0xf4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm5,%xmm5
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm6
movsd  0x8(%rcx,%rbp,8),%xmm7
movsd  0x10(%rcx,%rbp,8),%xmm2
movsd  0x18(%rcx,%rbp,8),%xmm4
andpd  %xmm3,%xmm6
maxsd  %xmm5,%xmm6
andpd  %xmm3,%xmm7
maxsd  %xmm6,%xmm7
andpd  %xmm3,%xmm2
maxsd  %xmm7,%xmm2
andpd  %xmm3,%xmm4
maxsd  %xmm2,%xmm4
add    $0x4,%rbp
movapd %xmm4,%xmm5
cmp    %rbp,%rdi
jne    11d0 <lu_decomp+0xb0>
movapd %xmm4,%xmm5
test   %rsi,%rsi
je     124a <lu_decomp+0x12a>
lea    (%rcx,%rbp,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rbp,8),%xmm5
andpd  %xmm0,%xmm5
maxsd  %xmm4,%xmm5
add    $0x1,%rbp
movapd %xmm5,%xmm4
cmp    %rbp,%rsi
jne    1230 <lu_decomp+0x110>
movapd %xmm5,%xmm2
andpd  %xmm0,%xmm2
ucomisd %xmm2,%xmm1
jae    14e0 <lu_decomp+0x3c0>
movapd %xmm8,%xmm2
divsd  %xmm5,%xmm2
movsd  %xmm2,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %r11,%rdx
jne    11a0 <lu_decomp+0x80>
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r14)
movslq %r12d,%rcx
mov    %rcx,(%rsp)
add    $0xffffffff,%r12d
xor    %edx,%edx
movapd 0xd77(%rip),%xmm3
mov    %r11,%r9
mov    %r15,%r10
jmp    12cb <lu_decomp+0x1ab>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    %rdx,%rcx
add    $0x8,%r10
add    $0xffffffffffffffff,%r9
mov    %rcx,%rdx
cmp    %r11,%rcx
je     1506 <lu_decomp+0x3e6>
test   %rdx,%rdx
je     1370 <lu_decomp+0x250>
xor    %r13d,%r13d
jmp    12f2 <lu_decomp+0x1d2>
nopl   0x0(%rax)
movsd  %xmm4,(%rsi,%rdx,8)
add    $0x1,%r13
cmp    %rdx,%r13
je     1370 <lu_decomp+0x250>
mov    (%r15,%r13,8),%rsi
movsd  (%rsi,%rdx,8),%xmm4
test   %r13,%r13
je     12e0 <lu_decomp+0x1c0>
cmp    $0x1,%r13
jne    1310 <lu_decomp+0x1f0>
xor    %edi,%edi
jmp    1351 <lu_decomp+0x231>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
movsd  (%rsi,%rdi,8),%xmm2
movsd  0x8(%rsi,%rdi,8),%xmm5
mov    (%r15,%rdi,8),%rbp
mov    0x8(%r15,%rdi,8),%r8
mulsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  (%r8,%rdx,8),%xmm5
subsd  %xmm2,%xmm4
subsd  %xmm5,%xmm4
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1320 <lu_decomp+0x200>
test   $0x1,%r13b
je     12e0 <lu_decomp+0x1c0>
movsd  (%rsi,%rdi,8),%xmm2
mov    (%r15,%rdi,8),%rcx
mulsd  (%rcx,%rdx,8),%xmm2
subsd  %xmm2,%xmm4
jmp    12e0 <lu_decomp+0x1c0>
xchg   %ax,%ax
mov    %rdx,%r8
and    $0xfffffffffffffffe,%r8
xorpd  %xmm4,%xmm4
xor    %r13d,%r13d
mov    %rdx,%rcx
jmp    13cc <lu_decomp+0x2ac>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm5,(%rsi,%rdx,8)
andpd  %xmm0,%xmm5
mulsd  (%rax,%rcx,8),%xmm5
ucomisd %xmm4,%xmm5
movapd %xmm4,%xmm2
cmpnlesd %xmm5,%xmm2
movapd %xmm2,%xmm6
andnpd %xmm5,%xmm6
andpd  %xmm4,%xmm2
orpd   %xmm6,%xmm2
cmovae %ecx,%r13d
add    $0x1,%rcx
movapd %xmm2,%xmm4
cmp    %r11,%rcx
je     1440 <lu_decomp+0x320>
mov    (%r15,%rcx,8),%rsi
movsd  (%rsi,%rdx,8),%xmm5
test   %rdx,%rdx
je     1390 <lu_decomp+0x270>
xor    %ebp,%ebp
cmp    $0x1,%rdx
je     141f <lu_decomp+0x2ff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rbp,8),%xmm2
movsd  0x8(%rsi,%rbp,8),%xmm6
mov    (%r15,%rbp,8),%rbx
mov    0x8(%r15,%rbp,8),%rdi
mulsd  (%rbx,%rdx,8),%xmm2
mulsd  (%rdi,%rdx,8),%xmm6
subsd  %xmm2,%xmm5
subsd  %xmm6,%xmm5
add    $0x2,%rbp
cmp    %rbp,%r8
jne    13f0 <lu_decomp+0x2d0>
test   $0x1,%dl
je     1390 <lu_decomp+0x270>
movsd  (%rsi,%rbp,8),%xmm2
mov    (%r15,%rbp,8),%rdi
mulsd  (%rdi,%rdx,8),%xmm2
subsd  %xmm2,%xmm5
jmp    1390 <lu_decomp+0x270>
nop
mov    %r13d,%ecx
cmp    %rcx,%rdx
jne    1450 <lu_decomp+0x330>
mov    (%r15,%rdx,8),%rcx
jmp    147b <lu_decomp+0x35b>
xchg   %ax,%ax
movslq %r13d,%rsi
mov    (%r15,%rsi,8),%rcx
mov    (%r15,%rdx,8),%rdi
mov    %rdi,(%r15,%rsi,8)
mov    %rcx,(%r15,%rdx,8)
movsd  (%r14),%xmm2
xorpd  %xmm3,%xmm2
movlpd %xmm2,(%r14)
movsd  (%rax,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rsi,8)
mov    0x8(%rsp),%rsi
mov    %r13d,(%rsi,%rdx,4)
movsd  (%rcx,%rdx,8),%xmm4
movapd %xmm4,%xmm2
andpd  %xmm0,%xmm2
ucomisd %xmm2,%xmm1
jae    1514 <lu_decomp+0x3f4>
cmp    %r12,%rdx
je     12b0 <lu_decomp+0x190>
lea    0x1(%rdx),%rcx
cmp    (%rsp),%rcx
jge    12b7 <lu_decomp+0x197>
movapd %xmm8,%xmm5
divsd  %xmm4,%xmm5
mov    $0x1,%esi
nopl   0x0(%rax)
mov    (%r10,%rsi,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
mulsd  %xmm5,%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    14c0 <lu_decomp+0x3a0>
jmp    12b7 <lu_decomp+0x197>
mov    $0x1,%ebx
lea    0x10(%rsp),%rcx
cmp    %rcx,%rax
je     1530 <lu_decomp+0x410>
add    $0xffffffff,%r12d
jmp    1523 <lu_decomp+0x403>
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r14)
xor    %ebx,%ebx
jmp    1530 <lu_decomp+0x410>
lea    0x10(%rsp),%rcx
xor    %ebx,%ebx
cmp    %rcx,%rax
jne    1523 <lu_decomp+0x403>
jmp    1530 <lu_decomp+0x410>
mov    $0x1,%ebx
lea    0x10(%rsp),%rcx
cmp    %rcx,%rax
je     1530 <lu_decomp+0x410>
mov    %rax,%rdi
xor    %esi,%esi
mov    %r12d,%edx
call   1040 <free_dvector@plt>
mov    %ebx,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @lu_decomp(double** %0, i32 %1, i32* %2, double* %3) {
%5 = alloca i32
%6 = alloca double**
%7 = alloca i32
%8 = alloca i32*
%9 = alloca double*
%10 = alloca i32
%11 = alloca i32
%12 = alloca double*
%13 = alloca [10 x double]
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca i32
%18 = alloca i32
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double*
%23 = alloca double
store double** %0, double*** %6
store i32 %1, i32* %7
store i32* %2, i32** %8
store double* %3, double** %9
%24 = load i32, i32* %7
%25 = icmp sle i32 %24, 10
br i1 %25, label %26, label %28
26: ; preds = %4
%27 = getelementptr inbounds [10 x double], [10 x double]* %13, i64 0, i64 0
store double* %27, double** %12
br label %32
28: ; preds = %4
%29 = load i32, i32* %7
%30 = sub nsw i32 %29, 1
%31 = call double* @dvector(i32 0, i32 %30)
store double* %31, double** %12
br label %32
32: ; preds = %28, %26
store i32 0, i32* %10
br label %33
33: ; preds = %83, %32
%34 = load i32, i32* %10
%35 = load i32, i32* %7
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %86
37: ; preds = %33
store double 0.000000e+00, double* %14
store i32 0, i32* %11
br label %38
38: ; preds = %59, %37
%39 = load i32, i32* %11
%40 = load i32, i32* %7
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %62
42: ; preds = %38
%43 = load double**, double*** %6
%44 = load i32, i32* %10
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double*, double** %43, i64 %45
%47 = load double*, double** %46
%48 = load i32, i32* %11
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double, double* %47, i64 %49
%51 = load double, double* %50
%52 = call double @llvm.fabs.f64(double %51)
store double %52, double* %15
%53 = load double, double* %15
%54 = load double, double* %14
%55 = fcmp ogt double %53, %54
br i1 %55, label %56, label %58
56: ; preds = %42
%57 = load double, double* %15
store double %57, double* %14
br label %58
58: ; preds = %56, %42
br label %59
59: ; preds = %58
%60 = load i32, i32* %11
%61 = add nsw i32 %60, 1
store i32 %61, i32* %11
br label %38
62: ; preds = %38
%63 = load double, double* %14
%64 = call double @llvm.fabs.f64(double %63)
%65 = fcmp ole double %64, 0x10000000000000
br i1 %65, label %66, label %76
66: ; preds = %62
%67 = load double*, double** %12
%68 = getelementptr inbounds [10 x double], [10 x double]* %13, i64 0, i64 0
%69 = icmp ne double* %67, %68
br i1 %69, label %70, label %75
70: ; preds = %66
%71 = load double*, double** %12
%72 = load i32, i32* %7
%73 = sub nsw i32 %72, 1
%74 = call i32 @free_dvector(double* %71, i32 0, i32 %73)
br label %75
75: ; preds = %70, %66
store i32 1, i32* %5
br label %338
76: ; preds = %62
%77 = load double, double* %14
%78 = fdiv double 1.000000e+00, %77
%79 = load double*, double** %12
%80 = load i32, i32* %10
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
store double %78, double* %82
br label %83
83: ; preds = %76
%84 = load i32, i32* %10
%85 = add nsw i32 %84, 1
store i32 %85, i32* %10
br label %33
86: ; preds = %33
%87 = load double*, double** %9
store double 1.000000e+00, double* %87
store i32 0, i32* %11
br label %88
88: ; preds = %325, %86
%89 = load i32, i32* %11
%90 = load i32, i32* %7
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %328
92: ; preds = %88
store i32 0, i32* %18
store i32 0, i32* %10
br label %93
93: ; preds = %146, %92
%94 = load i32, i32* %10
%95 = load i32, i32* %11
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %149
97: ; preds = %93
%98 = load double**, double*** %6
%99 = load i32, i32* %10
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double*, double** %98, i64 %100
%102 = load double*, double** %101
%103 = load i32, i32* %11
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %102, i64 %104
%106 = load double, double* %105
store double %106, double* %19
store i32 0, i32* %17
br label %107
107: ; preds = %133, %97
%108 = load i32, i32* %17
%109 = load i32, i32* %10
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %136
111: ; preds = %107
%112 = load double**, double*** %6
%113 = load i32, i32* %10
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double*, double** %112, i64 %114
%116 = load double*, double** %115
%117 = load i32, i32* %17
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %116, i64 %118
%120 = load double, double* %119
%121 = load double**, double*** %6
%122 = load i32, i32* %17
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double*, double** %121, i64 %123
%125 = load double*, double** %124
%126 = load i32, i32* %11
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = load double, double* %19
%131 = fneg double %120
%132 = call double @llvm.fmuladd.f64(double %131, double %129, double %130)
store double %132, double* %19
br label %133
133: ; preds = %111
%134 = load i32, i32* %17
%135 = add nsw i32 %134, 1
store i32 %135, i32* %17
br label %107
136: ; preds = %107
%137 = load double, double* %19
%138 = load double**, double*** %6
%139 = load i32, i32* %10
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double*, double** %138, i64 %140
%142 = load double*, double** %141
%143 = load i32, i32* %11
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds double, double* %142, i64 %144
store double %137, double* %145
br label %146
146: ; preds = %136
%147 = load i32, i32* %10
%148 = add nsw i32 %147, 1
store i32 %148, i32* %10
br label %93
149: ; preds = %93
store double 0.000000e+00, double* %16
%150 = load i32, i32* %11
store i32 %150, i32* %10
br label %151
151: ; preds = %219, %149
%152 = load i32, i32* %10
%153 = load i32, i32* %7
%154 = icmp slt i32 %152, %153
br i1 %154, label %155, label %222
155: ; preds = %151
%156 = load double**, double*** %6
%157 = load i32, i32* %10
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double*, double** %156, i64 %158
%160 = load double*, double** %159
%161 = load i32, i32* %11
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
%164 = load double, double* %163
store double %164, double* %20
store i32 0, i32* %17
br label %165
165: ; preds = %191, %155
%166 = load i32, i32* %17
%167 = load i32, i32* %11
%168 = icmp slt i32 %166, %167
br i1 %168, label %169, label %194
169: ; preds = %165
%170 = load double**, double*** %6
%171 = load i32, i32* %10
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double*, double** %170, i64 %172
%174 = load double*, double** %173
%175 = load i32, i32* %17
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %174, i64 %176
%178 = load double, double* %177
%179 = load double**, double*** %6
%180 = load i32, i32* %17
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double*, double** %179, i64 %181
%183 = load double*, double** %182
%184 = load i32, i32* %11
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
%187 = load double, double* %186
%188 = load double, double* %20
%189 = fneg double %178
%190 = call double @llvm.fmuladd.f64(double %189, double %187, double %188)
store double %190, double* %20
br label %191
191: ; preds = %169
%192 = load i32, i32* %17
%193 = add nsw i32 %192, 1
store i32 %193, i32* %17
br label %165
194: ; preds = %165
%195 = load double, double* %20
%196 = load double**, double*** %6
%197 = load i32, i32* %10
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double*, double** %196, i64 %198
%200 = load double*, double** %199
%201 = load i32, i32* %11
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
store double %195, double* %203
%204 = load double*, double** %12
%205 = load i32, i32* %10
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %204, i64 %206
%208 = load double, double* %207
%209 = load double, double* %20
%210 = call double @llvm.fabs.f64(double %209)
%211 = fmul double %208, %210
store double %211, double* %21
%212 = load double, double* %21
%213 = load double, double* %16
%214 = fcmp oge double %212, %213
br i1 %214, label %215, label %218
215: ; preds = %194
%216 = load double, double* %21
store double %216, double* %16
%217 = load i32, i32* %10
store i32 %217, i32* %18
br label %218
218: ; preds = %215, %194
br label %219
219: ; preds = %218
%220 = load i32, i32* %10
%221 = add nsw i32 %220, 1
store i32 %221, i32* %10
br label %151
222: ; preds = %151
%223 = load i32, i32* %11
%224 = load i32, i32* %18
%225 = icmp ne i32 %223, %224
br i1 %225, label %226, label %259
226: ; preds = %222
%227 = load double**, double*** %6
%228 = load i32, i32* %18
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double*, double** %227, i64 %229
%231 = load double*, double** %230
store double* %231, double** %22
%232 = load double**, double*** %6
%233 = load i32, i32* %11
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double*, double** %232, i64 %234
%236 = load double*, double** %235
%237 = load double**, double*** %6
%238 = load i32, i32* %18
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds double*, double** %237, i64 %239
store double* %236, double** %240
%241 = load double*, double** %22
%242 = load double**, double*** %6
%243 = load i32, i32* %11
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double*, double** %242, i64 %244
store double* %241, double** %245
%246 = load double*, double** %9
%247 = load double, double* %246
%248 = fneg double %247
%249 = load double*, double** %9
store double %248, double* %249
%250 = load double*, double** %12
%251 = load i32, i32* %11
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = load double*, double** %12
%256 = load i32, i32* %18
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %255, i64 %257
store double %254, double* %258
br label %259
259: ; preds = %226, %222
%260 = load i32, i32* %18
%261 = load i32*, i32** %8
%262 = load i32, i32* %11
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %261, i64 %263
store i32 %260, i32* %264
%265 = load double**, double*** %6
%266 = load i32, i32* %11
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double*, double** %265, i64 %267
%269 = load double*, double** %268
%270 = load i32, i32* %11
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds double, double* %269, i64 %271
%273 = load double, double* %272
%274 = call double @llvm.fabs.f64(double %273)
%275 = fcmp ole double %274, 0x10000000000000
br i1 %275, label %276, label %286
276: ; preds = %259
%277 = load double*, double** %12
%278 = getelementptr inbounds [10 x double], [10 x double]* %13, i64 0, i64 0
%279 = icmp ne double* %277, %278
br i1 %279, label %280, label %285
280: ; preds = %276
%281 = load double*, double** %12
%282 = load i32, i32* %7
%283 = sub nsw i32 %282, 1
%284 = call i32 @free_dvector(double* %281, i32 0, i32 %283)
br label %285
285: ; preds = %280, %276
store i32 1, i32* %5
br label %338
286: ; preds = %259
%287 = load i32, i32* %11
%288 = load i32, i32* %7
%289 = sub nsw i32 %288, 1
%290 = icmp ne i32 %287, %289
br i1 %290, label %291, label %324
291: ; preds = %286
%292 = load double**, double*** %6
%293 = load i32, i32* %11
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double*, double** %292, i64 %294
%296 = load double*, double** %295
%297 = load i32, i32* %11
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %296, i64 %298
%300 = load double, double* %299
%301 = fdiv double 1.000000e+00, %300
store double %301, double* %23
%302 = load i32, i32* %11
%303 = add nsw i32 %302, 1
store i32 %303, i32* %10
br label %304
304: ; preds = %320, %291
%305 = load i32, i32* %10
%306 = load i32, i32* %7
%307 = icmp slt i32 %305, %306
br i1 %307, label %308, label %323
308: ; preds = %304
%309 = load double, double* %23
%310 = load double**, double*** %6
%311 = load i32, i32* %10
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double*, double** %310, i64 %312
%314 = load double*, double** %313
%315 = load i32, i32* %11
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %314, i64 %316
%318 = load double, double* %317
%319 = fmul double %318, %309
store double %319, double* %317
br label %320
320: ; preds = %308
%321 = load i32, i32* %10
%322 = add nsw i32 %321, 1
store i32 %322, i32* %10
br label %304
323: ; preds = %304
br label %324
324: ; preds = %323, %286
br label %325
325: ; preds = %324
%326 = load i32, i32* %11
%327 = add nsw i32 %326, 1
store i32 %327, i32* %11
br label %88
328: ; preds = %88
%329 = load double*, double** %12
%330 = getelementptr inbounds [10 x double], [10 x double]* %13, i64 0, i64 0
%331 = icmp ne double* %329, %330
br i1 %331, label %332, label %337
332: ; preds = %328
%333 = load double*, double** %12
%334 = load i32, i32* %7
%335 = sub nsw i32 %334, 1
%336 = call i32 @free_dvector(double* %333, i32 0, i32 %335)
br label %337
337: ; preds = %332, %328
store i32 0, i32* %5
br label %338
338: ; preds = %337, %285, %75
%339 = load i32, i32* %5
ret i32 %339
}

LLVM IR (-O2):
define i32 @lu_decomp(double** nocapture %0, i32 %1, i32* nocapture writeonly %2, double* nocapture %3) {
%5 = alloca [10 x double]
%6 = bitcast [10 x double]* %5 to i8*
%7 = icmp slt i32 %1, 11
br i1 %7, label %11, label %8
8: ; preds = %4
%9 = add nsw i32 %1, -1
%10 = tail call double* @dvector(i32 0, i32 %9)
br label %15
11: ; preds = %4
%12 = getelementptr inbounds [10 x double], [10 x double]* %5, i64 0, i64 0
%13 = icmp sgt i32 %1, 0
br i1 %13, label %15, label %14
14: ; preds = %11
store double 1.000000e+00, double* %3
br label %270
15: ; preds = %8, %11
%16 = phi double* [ %10, %8 ], [ %12, %11 ]
%17 = zext i32 %1 to i64
%18 = add nsw i64 %17, -1
%19 = and i64 %17, 3
%20 = icmp ult i64 %18, 3
%21 = and i64 %17, 4294967292
%22 = icmp eq i64 %19, 0
br label %23
23: ; preds = %83, %15
%24 = phi i64 [ 0, %15 ], [ %86, %83 ]
%25 = getelementptr inbounds double*, double** %0, i64 %24
%26 = load double*, double** %25
br i1 %20, label %57, label %27
27: ; preds = %23, %27
%28 = phi i64 [ %54, %27 ], [ 0, %23 ]
%29 = phi double [ %53, %27 ], [ 0.000000e+00, %23 ]
%30 = phi i64 [ %55, %27 ], [ 0, %23 ]
%31 = getelementptr inbounds double, double* %26, i64 %28
%32 = load double, double* %31
%33 = tail call double @llvm.fabs.f64(double %32)
%34 = fcmp ogt double %33, %29
%35 = select i1 %34, double %33, double %29
%36 = or i64 %28, 1
%37 = getelementptr inbounds double, double* %26, i64 %36
%38 = load double, double* %37
%39 = tail call double @llvm.fabs.f64(double %38)
%40 = fcmp ogt double %39, %35
%41 = select i1 %40, double %39, double %35
%42 = or i64 %28, 2
%43 = getelementptr inbounds double, double* %26, i64 %42
%44 = load double, double* %43
%45 = tail call double @llvm.fabs.f64(double %44)
%46 = fcmp ogt double %45, %41
%47 = select i1 %46, double %45, double %41
%48 = or i64 %28, 3
%49 = getelementptr inbounds double, double* %26, i64 %48
%50 = load double, double* %49
%51 = tail call double @llvm.fabs.f64(double %50)
%52 = fcmp ogt double %51, %47
%53 = select i1 %52, double %51, double %47
%54 = add nuw nsw i64 %28, 4
%55 = add i64 %30, 4
%56 = icmp eq i64 %55, %21
br i1 %56, label %57, label %27
57: ; preds = %27, %23
%58 = phi double [ undef, %23 ], [ %53, %27 ]
%59 = phi i64 [ 0, %23 ], [ %54, %27 ]
%60 = phi double [ 0.000000e+00, %23 ], [ %53, %27 ]
br i1 %22, label %73, label %61
61: ; preds = %57, %61
%62 = phi i64 [ %70, %61 ], [ %59, %57 ]
%63 = phi double [ %69, %61 ], [ %60, %57 ]
%64 = phi i64 [ %71, %61 ], [ 0, %57 ]
%65 = getelementptr inbounds double, double* %26, i64 %62
%66 = load double, double* %65
%67 = tail call double @llvm.fabs.f64(double %66)
%68 = fcmp ogt double %67, %63
%69 = select i1 %68, double %67, double %63
%70 = add nuw nsw i64 %62, 1
%71 = add i64 %64, 1
%72 = icmp eq i64 %71, %19
br i1 %72, label %73, label %61
73: ; preds = %61, %57
%74 = phi double [ %58, %57 ], [ %69, %61 ]
%75 = tail call double @llvm.fabs.f64(double %74)
%76 = fcmp ugt double %75, 0x10000000000000
br i1 %76, label %83, label %77
77: ; preds = %73
%78 = getelementptr inbounds [10 x double], [10 x double]* %5, i64 0, i64 0
%79 = icmp eq double* %16, %78
br i1 %79, label %270, label %80
80: ; preds = %77
%81 = add nsw i32 %1, -1
%82 = call i32 @free_dvector(double* %16, i32 0, i32 %81)
br label %270
83: ; preds = %73
%84 = fdiv double 1.000000e+00, %74
%85 = getelementptr inbounds double, double* %16, i64 %24
store double %84, double* %85
%86 = add nuw nsw i64 %24, 1
%87 = icmp eq i64 %86, %17
br i1 %87, label %88, label %23
88: ; preds = %83
store double 1.000000e+00, double* %3
%89 = add nsw i32 %1, -1
%90 = sext i32 %1 to i64
%91 = zext i32 %89 to i64
%92 = zext i32 %1 to i64
br label %93
93: ; preds = %88, %260
%94 = phi i64 [ 1, %88 ], [ %262, %260 ]
%95 = phi i64 [ 0, %88 ], [ %261, %260 ]
%96 = icmp eq i64 %95, 0
br i1 %96, label %151, label %97
97: ; preds = %93, %147
%98 = phi i64 [ %149, %147 ], [ 0, %93 ]
%99 = getelementptr inbounds double*, double** %0, i64 %98
%100 = load double*, double** %99
%101 = getelementptr inbounds double, double* %100, i64 %95
%102 = load double, double* %101
%103 = icmp eq i64 %98, 0
br i1 %103, label %147, label %104
104: ; preds = %97
%105 = and i64 %98, 1
%106 = icmp eq i64 %98, 1
br i1 %106, label %133, label %107
107: ; preds = %104
%108 = and i64 %98, 9223372036854775806
br label %109
109: ; preds = %109, %107
%110 = phi i64 [ 0, %107 ], [ %130, %109 ]
%111 = phi double [ %102, %107 ], [ %129, %109 ]
%112 = phi i64 [ 0, %107 ], [ %131, %109 ]
%113 = getelementptr inbounds double, double* %100, i64 %110
%114 = load double, double* %113
%115 = getelementptr inbounds double*, double** %0, i64 %110
%116 = load double*, double** %115
%117 = getelementptr inbounds double, double* %116, i64 %95
%118 = load double, double* %117
%119 = fneg double %114
%120 = tail call double @llvm.fmuladd.f64(double %119, double %118, double %111)
%121 = or i64 %110, 1
%122 = getelementptr inbounds double, double* %100, i64 %121
%123 = load double, double* %122
%124 = getelementptr inbounds double*, double** %0, i64 %121
%125 = load double*, double** %124
%126 = getelementptr inbounds double, double* %125, i64 %95
%127 = load double, double* %126
%128 = fneg double %123
%129 = tail call double @llvm.fmuladd.f64(double %128, double %127, double %120)
%130 = add nuw nsw i64 %110, 2
%131 = add i64 %112, 2
%132 = icmp eq i64 %131, %108
br i1 %132, label %133, label %109
133: ; preds = %109, %104
%134 = phi double [ undef, %104 ], [ %129, %109 ]
%135 = phi i64 [ 0, %104 ], [ %130, %109 ]
%136 = phi double [ %102, %104 ], [ %129, %109 ]
%137 = icmp eq i64 %105, 0
br i1 %137, label %147, label %138
138: ; preds = %133
%139 = getelementptr inbounds double, double* %100, i64 %135
%140 = load double, double* %139
%141 = getelementptr inbounds double*, double** %0, i64 %135
%142 = load double*, double** %141
%143 = getelementptr inbounds double, double* %142, i64 %95
%144 = load double, double* %143
%145 = fneg double %140
%146 = tail call double @llvm.fmuladd.f64(double %145, double %144, double %136)
br label %147
147: ; preds = %138, %133, %97
%148 = phi double [ %102, %97 ], [ %134, %133 ], [ %146, %138 ]
store double %148, double* %101
%149 = add nuw nsw i64 %98, 1
%150 = icmp eq i64 %149, %95
br i1 %150, label %151, label %97
151: ; preds = %147, %93
%152 = and i64 %95, 1
%153 = icmp eq i64 %95, 1
%154 = and i64 %95, -2
%155 = icmp eq i64 %152, 0
br label %156
156: ; preds = %151, %202
%157 = phi i64 [ %212, %202 ], [ %95, %151 ]
%158 = phi i32 [ %211, %202 ], [ 0, %151 ]
%159 = phi double [ %209, %202 ], [ 0.000000e+00, %151 ]
%160 = getelementptr inbounds double*, double** %0, i64 %157
%161 = load double*, double** %160
%162 = getelementptr inbounds double, double* %161, i64 %95
%163 = load double, double* %162
br i1 %96, label %202, label %164
164: ; preds = %156
br i1 %153, label %189, label %165
165: ; preds = %164, %165
%166 = phi i64 [ %186, %165 ], [ 0, %164 ]
%167 = phi double [ %185, %165 ], [ %163, %164 ]
%168 = phi i64 [ %187, %165 ], [ 0, %164 ]
%169 = getelementptr inbounds double, double* %161, i64 %166
%170 = load double, double* %169
%171 = getelementptr inbounds double*, double** %0, i64 %166
%172 = load double*, double** %171
%173 = getelementptr inbounds double, double* %172, i64 %95
%174 = load double, double* %173
%175 = fneg double %170
%176 = tail call double @llvm.fmuladd.f64(double %175, double %174, double %167)
%177 = or i64 %166, 1
%178 = getelementptr inbounds double, double* %161, i64 %177
%179 = load double, double* %178
%180 = getelementptr inbounds double*, double** %0, i64 %177
%181 = load double*, double** %180
%182 = getelementptr inbounds double, double* %181, i64 %95
%183 = load double, double* %182
%184 = fneg double %179
%185 = tail call double @llvm.fmuladd.f64(double %184, double %183, double %176)
%186 = add nuw nsw i64 %166, 2
%187 = add i64 %168, 2
%188 = icmp eq i64 %187, %154
br i1 %188, label %189, label %165
189: ; preds = %165, %164
%190 = phi double [ undef, %164 ], [ %185, %165 ]
%191 = phi i64 [ 0, %164 ], [ %186, %165 ]
%192 = phi double [ %163, %164 ], [ %185, %165 ]
br i1 %155, label %202, label %193
193: ; preds = %189
%194 = getelementptr inbounds double, double* %161, i64 %191
%195 = load double, double* %194
%196 = getelementptr inbounds double*, double** %0, i64 %191
%197 = load double*, double** %196
%198 = getelementptr inbounds double, double* %197, i64 %95
%199 = load double, double* %198
%200 = fneg double %195
%201 = tail call double @llvm.fmuladd.f64(double %200, double %199, double %192)
br label %202
202: ; preds = %193, %189, %156
%203 = phi double [ %163, %156 ], [ %190, %189 ], [ %201, %193 ]
store double %203, double* %162
%204 = getelementptr inbounds double, double* %16, i64 %157
%205 = load double, double* %204
%206 = tail call double @llvm.fabs.f64(double %203)
%207 = fmul double %206, %205
%208 = fcmp ult double %207, %159
%209 = select i1 %208, double %159, double %207
%210 = trunc i64 %157 to i32
%211 = select i1 %208, i32 %158, i32 %210
%212 = add nuw nsw i64 %157, 1
%213 = icmp eq i64 %212, %92
br i1 %213, label %214, label %156
214: ; preds = %202
%215 = zext i32 %211 to i64
%216 = icmp eq i64 %95, %215
br i1 %216, label %217, label %220
217: ; preds = %214
%218 = getelementptr inbounds double*, double** %0, i64 %95
%219 = load double*, double** %218
br label %231
220: ; preds = %214
%221 = sext i32 %211 to i64
%222 = getelementptr inbounds double*, double** %0, i64 %221
%223 = load double*, double** %222
%224 = getelementptr inbounds double*, double** %0, i64 %95
%225 = load double*, double** %224
store double* %225, double** %222
store double* %223, double** %224
%226 = load double, double* %3
%227 = fneg double %226
store double %227, double* %3
%228 = getelementptr inbounds double, double* %16, i64 %95
%229 = load double, double* %228
%230 = getelementptr inbounds double, double* %16, i64 %221
store double %229, double* %230
br label %231
231: ; preds = %217, %220
%232 = phi double* [ %219, %217 ], [ %223, %220 ]
%233 = getelementptr inbounds i32, i32* %2, i64 %95
store i32 %211, i32* %233
%234 = getelementptr inbounds double, double* %232, i64 %95
%235 = load double, double* %234
%236 = tail call double @llvm.fabs.f64(double %235)
%237 = fcmp ugt double %236, 0x10000000000000
br i1 %237, label %243, label %238
238: ; preds = %231
%239 = getelementptr inbounds [10 x double], [10 x double]* %5, i64 0, i64 0
%240 = icmp eq double* %16, %239
br i1 %240, label %270, label %241
241: ; preds = %238
%242 = call i32 @free_dvector(double* %16, i32 0, i32 %89)
br label %270
243: ; preds = %231
%244 = icmp eq i64 %95, %91
br i1 %244, label %245, label %247
245: ; preds = %243
%246 = add nuw nsw i64 %95, 1
br label %260
247: ; preds = %243
%248 = fdiv double 1.000000e+00, %235
%249 = add nuw nsw i64 %95, 1
%250 = icmp slt i64 %249, %90
br i1 %250, label %251, label %260
251: ; preds = %247, %251
%252 = phi i64 [ %258, %251 ], [ %94, %247 ]
%253 = getelementptr inbounds double*, double** %0, i64 %252
%254 = load double*, double** %253
%255 = getelementptr inbounds double, double* %254, i64 %95
%256 = load double, double* %255
%257 = fmul double %248, %256
store double %257, double* %255
%258 = add nuw nsw i64 %252, 1
%259 = icmp eq i64 %258, %92
br i1 %259, label %260, label %251
260: ; preds = %251, %247, %245
%261 = phi i64 [ %246, %245 ], [ %249, %247 ], [ %249, %251 ]
%262 = add nuw nsw i64 %94, 1
%263 = icmp eq i64 %261, %92
br i1 %263, label %264, label %93
264: ; preds = %260
%265 = getelementptr inbounds [10 x double], [10 x double]* %5, i64 0, i64 0
%266 = icmp eq double* %16, %265
br i1 %266, label %270, label %267
267: ; preds = %264
%268 = add nsw i32 %1, -1
%269 = call i32 @free_dvector(double* %16, i32 0, i32 %268)
br label %270
270: ; preds = %14, %241, %238, %80, %77, %264, %267
%271 = phi i32 [ 0, %267 ], [ 0, %264 ], [ 1, %77 ], [ 1, %80 ], [ 1, %238 ], [ 1, %241 ], [ 0, %14 ]
ret i32 %271
}