#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*/ Exit(char *);
int /*<<< orphan*/ Free(double *);
double fabs(double);
scalar_t__ mCalloc(int, int);
int ludcmp(double **a, int n, double *d) {
  int i, imax, j, k;
  double big, dum, sum, temp;
  double *vv;
  imax = 0;
  vv = (double *)mCalloc(n, sizeof(double));
  *d = 1.0;
  for (i = 0; i < n; i++) {
    big = 0.0;
    for (j = 0; j < n; j++)
      if ((temp = fabs(a[i][j])) > big)
        big = temp;
    if (big == 0.0)
      Exit("\n. Singular matrix in routine LUDCMP");
    vv[i] = 1.0 / big;
  }
  for (j = 0; j < n; j++) {
    for (i = 0; i < j; i++) {
      sum = a[i][j];
      for (k = 0; k < i; k++)
        sum -= a[i][k] * a[k][j];
      a[i][j] = sum;
    }
    big = 0.0;
    for (i = j; i < n; i++) {
      sum = a[i][j];
      for (k = 0; k < j; k++)
        sum -= a[i][k] * a[k][j];
      a[i][j] = sum;
      if ((dum = vv[i] * fabs(sum)) >= big) {
        big = dum;
        imax = i;
      }
    }
    if (j != imax) {
      for (k = 0; k < n; k++) {
        dum = a[imax][k];
        a[imax][k] = a[j][k];
        a[j][k] = dum;
      }
      *d = -(*d);
      vv[imax] = vv[j];
    }
    if (a[j][j] == 0.0)
      a[j][j] = 1.0e-20;
    ;
    if (j != n) {
      dum = 1.0 / (a[j][j]);
      for (i = j + 1; i < n; i++)
        a[i][j] *= dum;
    }
  }
  Free(vv);
  return (0);
}


x86 assembly (clang, -O0):
<ludcmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x8,%esi
call   1050 <mCalloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movsd  0xe99(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1232 <ludcmp+0x102>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11e6 <ludcmp+0xb6>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe5b(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
ucomisd -0x30(%rbp),%xmm0
jbe    11d3 <ludcmp+0xa3>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    11d8 <ludcmp+0xa8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    118d <ludcmp+0x5d>
movsd  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    120a <ludcmp+0xda>
jp     120a <ludcmp+0xda>
lea    0xe1b(%rip),%rdi
call   1030 <Exit@plt>
movsd  0xdee(%rip),%xmm0
divsd  -0x30(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1172 <ludcmp+0x42>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15bd <ludcmp+0x48d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    130e <ludcmp+0x1de>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12e6 <ludcmp+0x1b6>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1279 <ludcmp+0x149>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    124c <ludcmp+0x11c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1424 <ludcmp+0x2f4>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13b6 <ludcmp+0x286>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1349 <ludcmp+0x219>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm1
movaps 0xc27(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
ucomisd -0x30(%rbp),%xmm0
jb     1411 <ludcmp+0x2e1>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1416 <ludcmp+0x2e6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    131c <ludcmp+0x1ec>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     14f0 <ludcmp+0x3c0>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14af <ludcmp+0x37f>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1437 <ludcmp+0x307>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1535 <ludcmp+0x405>
jp     1535 <ludcmp+0x405>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  0xad8(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
je     15aa <ludcmp+0x47a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  0xaa7(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15a5 <ludcmp+0x475>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    156c <ludcmp+0x43c>
jmp    15aa <ludcmp+0x47a>
jmp    15af <ludcmp+0x47f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1239 <ludcmp+0x109>
mov    -0x50(%rbp),%rdi
call   1040 <Free@plt>
xor    %eax,%eax
add    $0x50,%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    %rdx,%rbx
mov    %esi,%ebp
mov    %rdi,%r14
mov    %esi,%edi
mov    $0x8,%esi
call   1050 <mCalloc@plt>
mov    %rax,%r13
movabs $0x3ff0000000000000,%rax
mov    %rbx,0x40(%rsp)
mov    %rax,(%rbx)
mov    %ebp,0x4(%rsp)
test   %ebp,%ebp
jle    16e2 <ludcmp+0x5b2>
mov    0x4(%rsp),%r15d
lea    -0x1(%r15),%rax
mov    %rax,0x8(%rsp)
mov    %r15d,%ebx
and    $0x3,%ebx
mov    %r15d,%r12d
and    $0xfffffffc,%r12d
xor    %ebp,%ebp
movsd  0xe88(%rip),%xmm7
movapd 0xe5f(%rip),%xmm8
movapd 0xe57(%rip),%xmm5
jmp    11cc <ludcmp+0x9c>
nopl   0x0(%rax,%rax,1)
movapd %xmm7,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x1,%rbp
cmp    %r15,%rbp
je     12b5 <ludcmp+0x185>
mov    (%r14,%rbp,8),%rax
cmpq   $0x3,0x8(%rsp)
jae    11e0 <ludcmp+0xb0>
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
jmp    1234 <ludcmp+0x104>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm2
movsd  0x8(%rax,%rcx,8),%xmm3
movsd  0x10(%rax,%rcx,8),%xmm4
movsd  0x18(%rax,%rcx,8),%xmm0
andpd  %xmm5,%xmm2
maxsd  %xmm1,%xmm2
andpd  %xmm5,%xmm3
maxsd  %xmm2,%xmm3
andpd  %xmm5,%xmm4
maxsd  %xmm3,%xmm4
andpd  %xmm5,%xmm0
maxsd  %xmm4,%xmm0
add    $0x4,%rcx
movapd %xmm0,%xmm1
cmp    %rcx,%r12
jne    11f0 <ludcmp+0xc0>
movapd %xmm0,%xmm1
test   %rbx,%rbx
je     126b <ludcmp+0x13b>
lea    (%rax,%rcx,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm1
andpd  %xmm8,%xmm1
maxsd  %xmm0,%xmm1
add    $0x1,%rcx
movapd %xmm1,%xmm0
cmp    %rcx,%rbx
jne    1250 <ludcmp+0x120>
ucomisd 0xdbd(%rip),%xmm1
jne    11b0 <ludcmp+0x80>
jp     11b0 <ludcmp+0x80>
lea    0xdb2(%rip),%rdi
movapd %xmm1,0x10(%rsp)
call   1030 <Exit@plt>
movapd 0x10(%rsp),%xmm1
movapd 0xd61(%rip),%xmm5
movapd 0xd58(%rip),%xmm8
movsd  0xd70(%rip),%xmm7
jmp    11b0 <ludcmp+0x80>
cmpl   $0x0,0x4(%rsp)
jle    16e2 <ludcmp+0x5b2>
mov    %r15d,%eax
and    $0xfffffffc,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x30(%rsp)
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x28(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x10(%rsp)
xor    %esi,%esi
xorpd  %xmm0,%xmm0
movsd  0xd19(%rip),%xmm1
movapd 0xcf9(%rip),%xmm2
mov    %r15,%r11
mov    %r14,%r8
xor    %r12d,%r12d
jmp    1344 <ludcmp+0x214>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x8,%r8
add    $0xffffffffffffffff,%r11
mov    %rax,%rsi
cmp    %r15,%rax
je     16e2 <ludcmp+0x5b2>
test   %rsi,%rsi
je     13f0 <ludcmp+0x2c0>
xor    %edi,%edi
jmp    1372 <ludcmp+0x242>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,(%rbx,%rsi,8)
add    $0x1,%rdi
cmp    %rsi,%rdi
je     13f0 <ludcmp+0x2c0>
mov    (%r14,%rdi,8),%rbx
movsd  (%rbx,%rsi,8),%xmm3
test   %rdi,%rdi
je     1360 <ludcmp+0x230>
cmp    $0x1,%rdi
jne    1390 <ludcmp+0x260>
xor    %eax,%eax
jmp    13d0 <ludcmp+0x2a0>
nopw   0x0(%rax,%rax,1)
mov    %rdi,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm4
movsd  0x8(%rbx,%rax,8),%xmm5
mov    (%r14,%rax,8),%rdx
mov    0x8(%r14,%rax,8),%rbp
mulsd  (%rdx,%rsi,8),%xmm4
mulsd  0x0(%rbp,%rsi,8),%xmm5
subsd  %xmm4,%xmm3
subsd  %xmm5,%xmm3
add    $0x2,%rax
cmp    %rax,%rcx
jne    13a0 <ludcmp+0x270>
test   $0x1,%dil
je     1360 <ludcmp+0x230>
movsd  (%rbx,%rax,8),%xmm4
mov    (%r14,%rax,8),%rax
mulsd  (%rax,%rsi,8),%xmm4
subsd  %xmm4,%xmm3
jmp    1360 <ludcmp+0x230>
nopl   (%rax)
mov    %rsi,%rbx
and    $0xfffffffffffffffe,%rbx
xorpd  %xmm3,%xmm3
mov    %rsi,%rdi
jmp    1443 <ludcmp+0x313>
movsd  %xmm4,(%rax,%rsi,8)
andpd  %xmm8,%xmm4
mulsd  0x0(%r13,%rdi,8),%xmm4
ucomisd %xmm3,%xmm4
movapd %xmm3,%xmm5
cmpnlesd %xmm4,%xmm5
movapd %xmm5,%xmm6
andnpd %xmm4,%xmm6
andpd  %xmm3,%xmm5
orpd   %xmm6,%xmm5
cmovae %edi,%r12d
add    $0x1,%rdi
movapd %xmm5,%xmm3
cmp    %r15,%rdi
je     14c0 <ludcmp+0x390>
mov    (%r14,%rdi,8),%rax
movsd  (%rax,%rsi,8),%xmm4
test   %rsi,%rsi
je     1400 <ludcmp+0x2d0>
xor    %ecx,%ecx
cmp    $0x1,%rsi
je     1490 <ludcmp+0x360>
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm5
movsd  0x8(%rax,%rcx,8),%xmm6
mov    (%r14,%rcx,8),%rdx
mov    0x8(%r14,%rcx,8),%rbp
mulsd  (%rdx,%rsi,8),%xmm5
mulsd  0x0(%rbp,%rsi,8),%xmm6
subsd  %xmm5,%xmm4
subsd  %xmm6,%xmm4
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1460 <ludcmp+0x330>
test   $0x1,%sil
je     1400 <ludcmp+0x2d0>
movsd  (%rax,%rcx,8),%xmm5
mov    (%r14,%rcx,8),%rcx
mulsd  (%rcx,%rsi,8),%xmm5
subsd  %xmm5,%xmm4
jmp    1400 <ludcmp+0x2d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12d,%eax
cmp    %rax,%rsi
je     166f <ludcmp+0x53f>
movslq %r12d,%rdx
mov    (%r14,%rdx,8),%r9
mov    (%r14,%rsi,8),%r10
cmpl   $0x4,0x4(%rsp)
jb     14f8 <ludcmp+0x3c8>
lea    (%r10,%r15,8),%rax
cmp    %rax,%r9
jae    1572 <ludcmp+0x442>
lea    (%r9,%r15,8),%rax
cmp    %rax,%r10
jae    1572 <ludcmp+0x442>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r15b
je     1522 <ludcmp+0x3f2>
movsd  (%r9,%rcx,8),%xmm3
movsd  (%r10,%rcx,8),%xmm4
movsd  %xmm4,(%r9,%rcx,8)
movsd  %xmm3,(%r10,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x10(%rsp),%rcx
je     1650 <ludcmp+0x520>
movsd  (%r9,%rax,8),%xmm3
movsd  (%r10,%rax,8),%xmm4
movsd  %xmm4,(%r9,%rax,8)
movsd  %xmm3,(%r10,%rax,8)
movsd  0x8(%r9,%rax,8),%xmm3
movsd  0x8(%r10,%rax,8),%xmm4
movsd  %xmm4,0x8(%r9,%rax,8)
movsd  %xmm3,0x8(%r10,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    1530 <ludcmp+0x400>
jmp    1650 <ludcmp+0x520>
cmpq   $0x0,0x8(%rsp)
je     16d0 <ludcmp+0x5a0>
mov    0x28(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r9,%rax,8),%xmm3
movups 0x10(%r9,%rax,8),%xmm4
movups (%r10,%rax,8),%xmm5
movups 0x10(%r10,%rax,8),%xmm6
movups %xmm5,(%r9,%rax,8)
movups %xmm6,0x10(%r9,%rax,8)
movups %xmm3,(%r10,%rax,8)
movups %xmm4,0x10(%r10,%rax,8)
movupd 0x20(%r9,%rax,8),%xmm3
movupd 0x30(%r9,%rax,8),%xmm4
movupd 0x20(%r10,%rax,8),%xmm5
movupd 0x30(%r10,%rax,8),%xmm6
movupd %xmm5,0x20(%r9,%rax,8)
movupd %xmm6,0x30(%r9,%rax,8)
movupd %xmm3,0x20(%r10,%rax,8)
movupd %xmm4,0x30(%r10,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1590 <ludcmp+0x460>
testb  $0x1,0x38(%rsp)
je     1639 <ludcmp+0x509>
movupd (%r9,%rax,8),%xmm3
movupd 0x10(%r9,%rax,8),%xmm4
movupd (%r10,%rax,8),%xmm5
movupd 0x10(%r10,%rax,8),%xmm6
movupd %xmm5,(%r9,%rax,8)
movupd %xmm6,0x10(%r9,%rax,8)
movupd %xmm3,(%r10,%rax,8)
movupd %xmm4,0x10(%r10,%rax,8)
mov    0x30(%rsp),%rax
mov    %rax,%rcx
cmp    %r15,%rax
jne    14fa <ludcmp+0x3ca>
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rax
movsd  (%rax),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rax)
movsd  0x0(%r13,%rsi,8),%xmm3
movsd  %xmm3,0x0(%r13,%rdx,8)
mov    (%r14,%rsi,8),%rax
movsd  (%rax,%rsi,8),%xmm4
ucomisd %xmm0,%xmm4
jne    1692 <ludcmp+0x562>
jp     1692 <ludcmp+0x562>
movabs $0x3bc79ca10c924223,%rcx
9c c7 3b
mov    %rcx,(%rax,%rsi,8)
movapd %xmm1,%xmm4
lea    0x1(%rsi),%rax
cmp    %r15,%rax
jae    1330 <ludcmp+0x200>
movapd %xmm7,%xmm3
divsd  %xmm4,%xmm3
mov    $0x1,%ecx
nopl   0x0(%rax)
mov    (%r8,%rcx,8),%rdx
movsd  (%rdx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%rsi,8)
add    $0x1,%rcx
cmp    %rcx,%r11
jne    16b0 <ludcmp+0x580>
jmp    1330 <ludcmp+0x200>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    1605 <ludcmp+0x4d5>
jmp    1639 <ludcmp+0x509>
mov    %r13,%rdi
call   1040 <Free@plt>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [37 x i8] c"\0A. Singular matrix in routine LUDCMP\00"
define i32 @ludcmp(double** nocapture %0, i32 %1, double* nocapture %2) {
%4 = tail call i64 @mCalloc(i32 %1, i32 8)
%5 = inttoptr i64 %4 to double*
store double 1.000000e+00, double* %2
%6 = icmp sgt i32 %1, 0
br i1 %6, label %7, label %344
7: ; preds = %3
%8 = zext i32 %1 to i64
%9 = add nsw i64 %8, -1
%10 = and i64 %8, 3
%11 = icmp ult i64 %9, 3
%12 = and i64 %8, 4294967292
%13 = icmp eq i64 %10, 0
br label %14
14: ; preds = %87, %7
%15 = phi i64 [ 0, %7 ], [ %90, %87 ]
%16 = getelementptr inbounds double*, double** %0, i64 %15
%17 = load double*, double** %16
br i1 %11, label %66, label %36
18: ; preds = %87
br i1 %6, label %19, label %344
19: ; preds = %18
%20 = zext i32 %1 to i64
%21 = zext i32 %1 to i64
%22 = and i64 %21, 4294967292
%23 = add nsw i64 %22, -4
%24 = lshr exact i64 %23, 2
%25 = add nuw nsw i64 %24, 1
%26 = icmp ult i32 %1, 4
%27 = and i64 %8, 4294967292
%28 = and i64 %25, 1
%29 = icmp eq i64 %23, 0
%30 = and i64 %25, 9223372036854775806
%31 = icmp eq i64 %28, 0
%32 = icmp eq i64 %27, %8
%33 = and i64 %21, 1
%34 = icmp eq i64 %33, 0
%35 = sub nsw i64 0, %21
br label %92
36: ; preds = %14, %36
%37 = phi i64 [ %63, %36 ], [ 0, %14 ]
%38 = phi double [ %62, %36 ], [ 0.000000e+00, %14 ]
%39 = phi i64 [ %64, %36 ], [ 0, %14 ]
%40 = getelementptr inbounds double, double* %17, i64 %37
%41 = load double, double* %40
%42 = tail call double @llvm.fabs.f64(double %41)
%43 = fcmp ogt double %42, %38
%44 = select i1 %43, double %42, double %38
%45 = or i64 %37, 1
%46 = getelementptr inbounds double, double* %17, i64 %45
%47 = load double, double* %46
%48 = tail call double @llvm.fabs.f64(double %47)
%49 = fcmp ogt double %48, %44
%50 = select i1 %49, double %48, double %44
%51 = or i64 %37, 2
%52 = getelementptr inbounds double, double* %17, i64 %51
%53 = load double, double* %52
%54 = tail call double @llvm.fabs.f64(double %53)
%55 = fcmp ogt double %54, %50
%56 = select i1 %55, double %54, double %50
%57 = or i64 %37, 3
%58 = getelementptr inbounds double, double* %17, i64 %57
%59 = load double, double* %58
%60 = tail call double @llvm.fabs.f64(double %59)
%61 = fcmp ogt double %60, %56
%62 = select i1 %61, double %60, double %56
%63 = add nuw nsw i64 %37, 4
%64 = add i64 %39, 4
%65 = icmp eq i64 %64, %12
br i1 %65, label %66, label %36
66: ; preds = %36, %14
%67 = phi double [ undef, %14 ], [ %62, %36 ]
%68 = phi i64 [ 0, %14 ], [ %63, %36 ]
%69 = phi double [ 0.000000e+00, %14 ], [ %62, %36 ]
br i1 %13, label %82, label %70
70: ; preds = %66, %70
%71 = phi i64 [ %79, %70 ], [ %68, %66 ]
%72 = phi double [ %78, %70 ], [ %69, %66 ]
%73 = phi i64 [ %80, %70 ], [ 0, %66 ]
%74 = getelementptr inbounds double, double* %17, i64 %71
%75 = load double, double* %74
%76 = tail call double @llvm.fabs.f64(double %75)
%77 = fcmp ogt double %76, %72
%78 = select i1 %77, double %76, double %72
%79 = add nuw nsw i64 %71, 1
%80 = add i64 %73, 1
%81 = icmp eq i64 %80, %10
br i1 %81, label %82, label %70
82: ; preds = %70, %66
%83 = phi double [ %67, %66 ], [ %78, %70 ]
%84 = fcmp oeq double %83, 0.000000e+00
br i1 %84, label %85, label %87
85: ; preds = %82
%86 = tail call i32 @Exit(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0))
br label %87
87: ; preds = %85, %82
%88 = fdiv double 1.000000e+00, %83
%89 = getelementptr inbounds double, double* %5, i64 %15
store double %88, double* %89
%90 = add nuw nsw i64 %15, 1
%91 = icmp eq i64 %90, %8
br i1 %91, label %18, label %14
92: ; preds = %19, %341
%93 = phi i64 [ 1, %19 ], [ %342, %341 ]
%94 = phi i64 [ 0, %19 ], [ %330, %341 ]
%95 = phi i32 [ 0, %19 ], [ %211, %341 ]
%96 = icmp eq i64 %94, 0
br i1 %96, label %151, label %97
97: ; preds = %92, %147
%98 = phi i64 [ %149, %147 ], [ 0, %92 ]
%99 = getelementptr inbounds double*, double** %0, i64 %98
%100 = load double*, double** %99
%101 = getelementptr inbounds double, double* %100, i64 %94
%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 %94
%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 %94
%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 %94
%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, %94
br i1 %150, label %151, label %97
151: ; preds = %147, %92
%152 = and i64 %94, 1
%153 = icmp eq i64 %94, 1
%154 = and i64 %94, 9223372036854775806
%155 = icmp eq i64 %152, 0
br label %156
156: ; preds = %151, %202
%157 = phi i64 [ %212, %202 ], [ %94, %151 ]
%158 = phi i32 [ %211, %202 ], [ %95, %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 %94
%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 %94
%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 %94
%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 %94
%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* %5, 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, %21
br i1 %213, label %214, label %156
214: ; preds = %202
%215 = zext i32 %211 to i64
%216 = icmp eq i64 %94, %215
br i1 %216, label %320, label %217
217: ; preds = %214
%218 = sext i32 %211 to i64
%219 = getelementptr inbounds double*, double** %0, i64 %218
%220 = load double*, double** %219
%221 = getelementptr inbounds double*, double** %0, i64 %94
%222 = load double*, double** %221
br i1 %26, label %289, label %223
223: ; preds = %217
%224 = getelementptr double, double* %220, i64 %8
%225 = getelementptr double, double* %222, i64 %8
%226 = icmp ult double* %220, %225
%227 = icmp ult double* %222, %224
%228 = and i1 %226, %227
br i1 %228, label %289, label %229
229: ; preds = %223
br i1 %29, label %269, label %230
230: ; preds = %229, %230
%231 = phi i64 [ %266, %230 ], [ 0, %229 ]
%232 = phi i64 [ %267, %230 ], [ 0, %229 ]
%233 = getelementptr inbounds double, double* %220, i64 %231
%234 = bitcast double* %233 to <2 x double>*
%235 = load <2 x double>, <2 x double>* %234
%236 = getelementptr inbounds double, double* %233, i64 2
%237 = bitcast double* %236 to <2 x double>*
%238 = load <2 x double>, <2 x double>* %237
%239 = getelementptr inbounds double, double* %222, i64 %231
%240 = bitcast double* %239 to <2 x double>*
%241 = load <2 x double>, <2 x double>* %240
%242 = getelementptr inbounds double, double* %239, i64 2
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = bitcast double* %233 to <2 x double>*
store <2 x double> %241, <2 x double>* %245
%246 = bitcast double* %236 to <2 x double>*
store <2 x double> %244, <2 x double>* %246
%247 = bitcast double* %239 to <2 x double>*
store <2 x double> %235, <2 x double>* %247
%248 = bitcast double* %242 to <2 x double>*
store <2 x double> %238, <2 x double>* %248
%249 = or i64 %231, 4
%250 = getelementptr inbounds double, double* %220, i64 %249
%251 = bitcast double* %250 to <2 x double>*
%252 = load <2 x double>, <2 x double>* %251
%253 = getelementptr inbounds double, double* %250, i64 2
%254 = bitcast double* %253 to <2 x double>*
%255 = load <2 x double>, <2 x double>* %254
%256 = getelementptr inbounds double, double* %222, i64 %249
%257 = bitcast double* %256 to <2 x double>*
%258 = load <2 x double>, <2 x double>* %257
%259 = getelementptr inbounds double, double* %256, i64 2
%260 = bitcast double* %259 to <2 x double>*
%261 = load <2 x double>, <2 x double>* %260
%262 = bitcast double* %250 to <2 x double>*
store <2 x double> %258, <2 x double>* %262
%263 = bitcast double* %253 to <2 x double>*
store <2 x double> %261, <2 x double>* %263
%264 = bitcast double* %256 to <2 x double>*
store <2 x double> %252, <2 x double>* %264
%265 = bitcast double* %259 to <2 x double>*
store <2 x double> %255, <2 x double>* %265
%266 = add nuw i64 %231, 8
%267 = add i64 %232, 2
%268 = icmp eq i64 %267, %30
br i1 %268, label %269, label %230
269: ; preds = %230, %229
%270 = phi i64 [ 0, %229 ], [ %266, %230 ]
br i1 %31, label %288, label %271
271: ; preds = %269
%272 = getelementptr inbounds double, double* %220, i64 %270
%273 = bitcast double* %272 to <2 x double>*
%274 = load <2 x double>, <2 x double>* %273
%275 = getelementptr inbounds double, double* %272, i64 2
%276 = bitcast double* %275 to <2 x double>*
%277 = load <2 x double>, <2 x double>* %276
%278 = getelementptr inbounds double, double* %222, i64 %270
%279 = bitcast double* %278 to <2 x double>*
%280 = load <2 x double>, <2 x double>* %279
%281 = getelementptr inbounds double, double* %278, i64 2
%282 = bitcast double* %281 to <2 x double>*
%283 = load <2 x double>, <2 x double>* %282
%284 = bitcast double* %272 to <2 x double>*
store <2 x double> %280, <2 x double>* %284
%285 = bitcast double* %275 to <2 x double>*
store <2 x double> %283, <2 x double>* %285
%286 = bitcast double* %278 to <2 x double>*
store <2 x double> %274, <2 x double>* %286
%287 = bitcast double* %281 to <2 x double>*
store <2 x double> %277, <2 x double>* %287
br label %288
288: ; preds = %269, %271
br i1 %32, label %314, label %289
289: ; preds = %223, %217, %288
%290 = phi i64 [ 0, %223 ], [ 0, %217 ], [ %27, %288 ]
%291 = xor i64 %290, -1
br i1 %34, label %298, label %292
292: ; preds = %289
%293 = getelementptr inbounds double, double* %220, i64 %290
%294 = load double, double* %293
%295 = getelementptr inbounds double, double* %222, i64 %290
%296 = load double, double* %295
store double %296, double* %293
store double %294, double* %295
%297 = or i64 %290, 1
br label %298
298: ; preds = %292, %289
%299 = phi i64 [ %290, %289 ], [ %297, %292 ]
%300 = icmp eq i64 %291, %35
br i1 %300, label %314, label %301
301: ; preds = %298, %301
%302 = phi i64 [ %312, %301 ], [ %299, %298 ]
%303 = getelementptr inbounds double, double* %220, i64 %302
%304 = load double, double* %303
%305 = getelementptr inbounds double, double* %222, i64 %302
%306 = load double, double* %305
store double %306, double* %303
store double %304, double* %305
%307 = add nuw nsw i64 %302, 1
%308 = getelementptr inbounds double, double* %220, i64 %307
%309 = load double, double* %308
%310 = getelementptr inbounds double, double* %222, i64 %307
%311 = load double, double* %310
store double %311, double* %308
store double %309, double* %310
%312 = add nuw nsw i64 %302, 2
%313 = icmp eq i64 %312, %21
br i1 %313, label %314, label %301
314: ; preds = %298, %301, %288
%315 = load double, double* %2
%316 = fneg double %315
store double %316, double* %2
%317 = getelementptr inbounds double, double* %5, i64 %94
%318 = load double, double* %317
%319 = getelementptr inbounds double, double* %5, i64 %218
store double %318, double* %319
br label %320
320: ; preds = %314, %214
%321 = getelementptr inbounds double*, double** %0, i64 %94
%322 = load double*, double** %321
%323 = getelementptr inbounds double, double* %322, i64 %94
%324 = load double, double* %323
%325 = fcmp oeq double %324, 0.000000e+00
br i1 %325, label %326, label %327
326: ; preds = %320
store double 0x3BC79CA10C924223, double* %323
br label %327
327: ; preds = %320, %326
%328 = phi double [ 0x3BC79CA10C924223, %326 ], [ %324, %320 ]
%329 = fdiv double 1.000000e+00, %328
%330 = add nuw nsw i64 %94, 1
%331 = icmp ult i64 %330, %20
br i1 %331, label %332, label %341
332: ; preds = %327, %332
%333 = phi i64 [ %339, %332 ], [ %93, %327 ]
%334 = getelementptr inbounds double*, double** %0, i64 %333
%335 = load double*, double** %334
%336 = getelementptr inbounds double, double* %335, i64 %94
%337 = load double, double* %336
%338 = fmul double %329, %337
store double %338, double* %336
%339 = add nuw nsw i64 %333, 1
%340 = icmp eq i64 %339, %21
br i1 %340, label %341, label %332
341: ; preds = %332, %327
%342 = add nuw nsw i64 %93, 1
%343 = icmp eq i64 %330, %21
br i1 %343, label %344, label %92
344: ; preds = %341, %3, %18
%345 = tail call i32 @Free(double* %5)
ret i32 0
}