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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ NUMERICS_ERROR(char *);
double *dvector(int /*<<< orphan*/, int);
double fabs(double);
int /*<<< orphan*/ free_dvector(double *, int /*<<< orphan*/);
int ludcmp(double **m, int n, int *indx, double *d) {
  int i, imax, j, k;
  double big, dum, sum, temp;
  double *vv = dvector(0, n - 1);
  *d = 1.0;
  for (i = 0; i < n; i++) {
    big = 0.0;
    for (j = 0; j < n; j++) {
      if ((temp = fabs(m[i][j])) > big) {
        big = temp;
      }
    }
    if (big == 0.0) {
      free_dvector(vv, 0);
      NUMERICS_ERROR("ludcmp Singular Matrix");
      return 0;
    }
    vv[i] = 1.0 / big;
  }
  for (j = 0; j < n; j++) {
    for (i = 0; i < j; i++) {
      sum = m[i][j];
      for (k = 0; k < i; k++) {
        sum -= m[i][k] * m[k][j];
      }
      m[i][j] = sum;
    }
    big = 0.0;
    for (i = j; i < n; i++) {
      sum = m[i][j];
      for (k = 0; k < j; k++) {
        sum -= m[i][k] * m[k][j];
      }
      m[i][j] = sum;
      if ((dum = vv[i] * fabs(sum)) >= big) {
        big = dum;
        imax = i;
      }
    }
    if (j != imax) {
      for (k = 0; k < n; k++) {
        dum = m[imax][k];
        m[imax][k] = m[j][k];
        m[j][k] = dum;
      }
      *d = -(*d);
      vv[imax] = vv[j];
    }
    *(indx + j) = imax;
    if (m[j][j] == 0.0) {
      m[j][j] = 1.0E-37;
    }
    if (j != n - 1) {
      dum = 1.0 / (m[j][j]);
      for (i = j + 1; i < n; i++) {
        m[i][j] *= dum;
      }
    }
  }
  free_dvector(vv, 0);
  return 1;
}


x86 assembly (clang, -O0):
<ludcmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1040 <dvector@plt>
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movsd  0xe9c(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1246 <ludcmp+0x116>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11e3 <ludcmp+0xb3>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe5e(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
ucomisd -0x40(%rbp),%xmm0
jbe    11d0 <ludcmp+0xa0>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11d5 <ludcmp+0xa5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118a <ludcmp+0x5a>
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    121e <ludcmp+0xee>
jp     121e <ludcmp+0xee>
mov    -0x60(%rbp),%rdi
xor    %esi,%esi
call   1050 <free_dvector@plt>
lea    0xe13(%rip),%rdi
call   1030 <NUMERICS_ERROR@plt>
movl   $0x0,-0x4(%rbp)
jmp    15f6 <ludcmp+0x4c6>
movsd  0xdda(%rip),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116f <ludcmp+0x3f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15e4 <ludcmp+0x4b4>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1322 <ludcmp+0x1f2>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12fa <ludcmp+0x1ca>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    128d <ludcmp+0x15d>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1260 <ludcmp+0x130>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1438 <ludcmp+0x308>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13ca <ludcmp+0x29a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    135d <ludcmp+0x22d>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm1
movaps 0xc13(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
ucomisd -0x40(%rbp),%xmm0
jb     1425 <ludcmp+0x2f5>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    142a <ludcmp+0x2fa>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1330 <ludcmp+0x200>
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1504 <ludcmp+0x3d4>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14c3 <ludcmp+0x393>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    144b <ludcmp+0x31b>
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    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1557 <ludcmp+0x427>
jp     1557 <ludcmp+0x427>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  0xab6(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     15d1 <ludcmp+0x4a1>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  0xa80(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15cc <ludcmp+0x49c>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1593 <ludcmp+0x463>
jmp    15d1 <ludcmp+0x4a1>
jmp    15d6 <ludcmp+0x4a6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    124d <ludcmp+0x11d>
mov    -0x60(%rbp),%rdi
xor    %esi,%esi
call   1050 <free_dvector@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ludcmp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%rbx
mov    %rdx,0x40(%rsp)
mov    %esi,%ebp
mov    %rdi,%r15
lea    -0x1(%rbp),%r13d
xor    %edi,%edi
mov    %r13d,%esi
call   1040 <dvector@plt>
movabs $0x3ff0000000000000,%rcx
mov    %rbx,0x38(%rsp)
mov    %rcx,(%rbx)
mov    %rbp,0x8(%rsp)
test   %ebp,%ebp
jle    16c4 <ludcmp+0x594>
mov    0x8(%rsp),%r14d
lea    -0x1(%r14),%r8
mov    %r14d,%esi
and    $0x3,%esi
mov    %r14d,%edi
and    $0xfffffffc,%edi
xor    %ebp,%ebp
xorpd  %xmm2,%xmm2
movsd  0xe84(%rip),%xmm8
movapd 0xe5c(%rip),%xmm1
movapd 0xe54(%rip),%xmm3
nopl   0x0(%rax)
mov    (%r15,%rbp,8),%rdx
cmp    $0x3,%r8
jae    11d0 <ludcmp+0xa0>
xor    %ecx,%ecx
xorpd  %xmm4,%xmm4
jmp    1224 <ludcmp+0xf4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm5,%xmm5
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm6
movsd  0x8(%rdx,%rcx,8),%xmm7
movsd  0x10(%rdx,%rcx,8),%xmm0
movsd  0x18(%rdx,%rcx,8),%xmm4
andpd  %xmm3,%xmm6
maxsd  %xmm5,%xmm6
andpd  %xmm3,%xmm7
maxsd  %xmm6,%xmm7
andpd  %xmm3,%xmm0
maxsd  %xmm7,%xmm0
andpd  %xmm3,%xmm4
maxsd  %xmm0,%xmm4
add    $0x4,%rcx
movapd %xmm4,%xmm5
cmp    %rcx,%rdi
jne    11e0 <ludcmp+0xb0>
movapd %xmm4,%xmm5
test   %rsi,%rsi
je     125a <ludcmp+0x12a>
lea    (%rdx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm5
andpd  %xmm1,%xmm5
maxsd  %xmm4,%xmm5
add    $0x1,%rdx
movapd %xmm5,%xmm4
cmp    %rdx,%rsi
jne    1240 <ludcmp+0x110>
ucomisd %xmm2,%xmm5
jne    1266 <ludcmp+0x136>
jnp    16d5 <ludcmp+0x5a5>
movapd %xmm8,%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %r14,%rbp
jne    11b0 <ludcmp+0x80>
cmpl   $0x0,0x8(%rsp)
jle    16c4 <ludcmp+0x594>
mov    %r13d,%r11d
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x28(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x20(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x18(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x10(%rsp)
mov    %r14,%rcx
neg    %rcx
mov    %rcx,0x30(%rsp)
xor    %r9d,%r9d
xorpd  %xmm2,%xmm2
movsd  0xd4f(%rip),%xmm3
movapd 0xd2f(%rip),%xmm4
mov    %r14,%r12
mov    %r15,%r10
jmp    130b <ludcmp+0x1db>
nopl   0x0(%rax)
add    $0x1,%r9
mov    %r9,%rcx
add    $0x8,%r10
add    $0xffffffffffffffff,%r12
mov    %rcx,%r9
cmp    %r14,%rcx
je     16c4 <ludcmp+0x594>
test   %r9,%r9
je     13b0 <ludcmp+0x280>
xor    %edx,%edx
jmp    1334 <ludcmp+0x204>
nopl   0x0(%rax,%rax,1)
movsd  %xmm5,0x0(%rbp,%r9,8)
add    $0x1,%rdx
cmp    %r9,%rdx
je     13b0 <ludcmp+0x280>
mov    (%r15,%rdx,8),%rbp
movsd  0x0(%rbp,%r9,8),%xmm5
test   %rdx,%rdx
je     1320 <ludcmp+0x1f0>
cmp    $0x1,%rdx
jne    1350 <ludcmp+0x220>
xor    %edi,%edi
jmp    1392 <ludcmp+0x262>
xchg   %ax,%ax
mov    %rdx,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  0x8(%rbp,%rdi,8),%xmm6
mov    (%r15,%rdi,8),%rsi
mov    0x8(%r15,%rdi,8),%rbx
mulsd  (%rsi,%r9,8),%xmm0
mulsd  (%rbx,%r9,8),%xmm6
subsd  %xmm0,%xmm5
subsd  %xmm6,%xmm5
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1360 <ludcmp+0x230>
test   $0x1,%dl
je     1320 <ludcmp+0x1f0>
movsd  0x0(%rbp,%rdi,8),%xmm0
mov    (%r15,%rdi,8),%rcx
mulsd  (%rcx,%r9,8),%xmm0
subsd  %xmm0,%xmm5
jmp    1320 <ludcmp+0x1f0>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
xorpd  %xmm5,%xmm5
mov    %r9,%rdx
jmp    1401 <ludcmp+0x2d1>
movsd  %xmm6,(%rdi,%r9,8)
andpd  %xmm1,%xmm6
mulsd  (%rax,%rdx,8),%xmm6
ucomisd %xmm5,%xmm6
cmovae %edx,%r8d
movapd %xmm5,%xmm0
cmpnlesd %xmm6,%xmm0
movapd %xmm0,%xmm7
andnpd %xmm6,%xmm7
andpd  %xmm5,%xmm0
orpd   %xmm7,%xmm0
add    $0x1,%rdx
movapd %xmm0,%xmm5
cmp    %r14,%rdx
je     1480 <ludcmp+0x350>
mov    (%r15,%rdx,8),%rdi
movsd  (%rdi,%r9,8),%xmm6
test   %r9,%r9
je     13c0 <ludcmp+0x290>
xor    %ecx,%ecx
cmp    $0x1,%r9
je     1451 <ludcmp+0x321>
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm0
movsd  0x8(%rdi,%rcx,8),%xmm7
mov    (%r15,%rcx,8),%rsi
mov    0x8(%r15,%rcx,8),%rbx
mulsd  (%rsi,%r9,8),%xmm0
mulsd  (%rbx,%r9,8),%xmm7
subsd  %xmm0,%xmm6
subsd  %xmm7,%xmm6
add    $0x2,%rcx
cmp    %rcx,%rbp
jne    1420 <ludcmp+0x2f0>
test   $0x1,%r9b
je     13c0 <ludcmp+0x290>
movsd  (%rdi,%rcx,8),%xmm0
mov    (%r15,%rcx,8),%rcx
mulsd  (%rcx,%r9,8),%xmm0
subsd  %xmm0,%xmm6
jmp    13c0 <ludcmp+0x290>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8d,%ecx
cmp    %rcx,%r9
je     163f <ludcmp+0x50f>
mov    %r11,%rdi
movslq %r8d,%rsi
mov    (%r15,%rsi,8),%r11
mov    (%r15,%r9,8),%r13
cmpl   $0x4,0x8(%rsp)
jb     14c2 <ludcmp+0x392>
lea    0x0(,%r14,8),%rcx
add    %r13,%rcx
cmp    %rcx,%r11
jae    1544 <ludcmp+0x414>
lea    (%r11,%r14,8),%rcx
cmp    %rcx,%r13
jae    1544 <ludcmp+0x414>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r14b
je     14ee <ludcmp+0x3be>
movsd  (%r11,%rdx,8),%xmm0
movsd  0x0(%r13,%rdx,8),%xmm5
movsd  %xmm5,(%r11,%rdx,8)
movsd  %xmm0,0x0(%r13,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x30(%rsp),%rdx
je     1620 <ludcmp+0x4f0>
nopl   0x0(%rax)
movsd  (%r11,%rcx,8),%xmm0
movsd  0x0(%r13,%rcx,8),%xmm5
movsd  %xmm5,(%r11,%rcx,8)
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  0x8(%r11,%rcx,8),%xmm0
movsd  0x8(%r13,%rcx,8),%xmm5
movsd  %xmm5,0x8(%r11,%rcx,8)
movsd  %xmm0,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    1500 <ludcmp+0x3d0>
jmp    1620 <ludcmp+0x4f0>
cmpq   $0x0,0x20(%rsp)
je     16b2 <ludcmp+0x582>
mov    0x10(%rsp),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%r11,%rdx,8),%xmm0
movups 0x10(%r11,%rdx,8),%xmm5
movups 0x0(%r13,%rdx,8),%xmm6
movups 0x10(%r13,%rdx,8),%xmm7
movups %xmm6,(%r11,%rdx,8)
movups %xmm7,0x10(%r11,%rdx,8)
movups %xmm0,0x0(%r13,%rdx,8)
movups %xmm5,0x10(%r13,%rdx,8)
movupd 0x20(%r11,%rdx,8),%xmm0
movupd 0x30(%r11,%rdx,8),%xmm5
movupd 0x20(%r13,%rdx,8),%xmm6
movupd 0x30(%r13,%rdx,8),%xmm7
movupd %xmm6,0x20(%r11,%rdx,8)
movupd %xmm7,0x30(%r11,%rdx,8)
movupd %xmm0,0x20(%r13,%rdx,8)
movupd %xmm5,0x30(%r13,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1560 <ludcmp+0x430>
testb  $0x1,0x18(%rsp)
je     160d <ludcmp+0x4dd>
movupd (%r11,%rdx,8),%xmm0
movupd 0x10(%r11,%rdx,8),%xmm5
movupd 0x0(%r13,%rdx,8),%xmm6
movupd 0x10(%r13,%rdx,8),%xmm7
movupd %xmm6,(%r11,%rdx,8)
movupd %xmm7,0x10(%r11,%rdx,8)
movupd %xmm0,0x0(%r13,%rdx,8)
movupd %xmm5,0x10(%r13,%rdx,8)
mov    0x28(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r14,%rcx
jne    14c4 <ludcmp+0x394>
xchg   %ax,%ax
mov    0x38(%rsp),%rcx
movsd  (%rcx),%xmm0
xorpd  %xmm4,%xmm0
movlpd %xmm0,(%rcx)
movsd  (%rax,%r9,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
mov    %rdi,%r11
mov    0x40(%rsp),%rcx
mov    %r8d,(%rcx,%r9,4)
mov    (%r15,%r9,8),%rcx
movsd  (%rcx,%r9,8),%xmm5
ucomisd %xmm2,%xmm5
jne    166c <ludcmp+0x53c>
jp     166c <ludcmp+0x53c>
movabs $0x3841039d428a8b8f,%rdx
03 41 38
mov    %rdx,(%rcx,%r9,8)
movapd %xmm3,%xmm5
cmp    %r11,%r9
je     12f0 <ludcmp+0x1c0>
lea    0x1(%r9),%rcx
cmp    %r14,%rcx
jge    12f7 <ludcmp+0x1c7>
movapd %xmm8,%xmm6
divsd  %xmm5,%xmm6
mov    $0x1,%edx
mov    (%r10,%rdx,8),%rsi
movsd  (%rsi,%r9,8),%xmm0
mulsd  %xmm6,%xmm0
movsd  %xmm0,(%rsi,%r9,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1690 <ludcmp+0x560>
jmp    12f7 <ludcmp+0x1c7>
xor    %edx,%edx
testb  $0x1,0x18(%rsp)
jne    15d7 <ludcmp+0x4a7>
jmp    160d <ludcmp+0x4dd>
mov    %rax,%rdi
xor    %esi,%esi
call   1050 <free_dvector@plt>
mov    $0x1,%ebx
jmp    16ed <ludcmp+0x5bd>
xor    %ebx,%ebx
mov    %rax,%rdi
xor    %esi,%esi
call   1050 <free_dvector@plt>
lea    0x948(%rip),%rdi
call   1030 <NUMERICS_ERROR@plt>
mov    %ebx,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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