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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ free(double *);
double *mat(int, int);
int ludcmp(double *A, int n, int *indx, double *d) {
  double big, s, tmp, *vv = mat(n, 1);
  int i, imax = 0, j, k;
  *d = 1.0;
  for (i = 0; i < n; ++i) {
    big = 0.0;
    for (j = 0; j < n; ++j) {
      if ((tmp = fabs(A[i + j * n])) > big) {
        big = tmp;
      }
    }
    if (big > 0.0) {
      vv[i] = 1.0 / big;
    } else {
      free(vv);
      return -1;
    }
  }
  for (j = 0; j < n; ++j) {
    for (i = 0; i < j; ++i) {
      s = A[i + j * n];
      for (k = 0; k < i; ++k) {
        s -= A[i + k * n] * A[k + j * n];
      }
      A[i + j * n] = s;
    }
    big = 0.0;
    for (i = j; i < n; ++i) {
      s = A[i + j * n];
      for (k = 0; k < j; ++k) {
        s -= A[i + k * n] * A[k + j * n];
      }
      A[i + j * n] = s;
      if ((tmp = vv[i] * fabs(s)) >= big) {
        big = tmp;
        imax = i;
      }
    }
    if (j != imax) {
      for (k = 0; k < n; ++k) {
        tmp = A[imax + k * n];
        A[imax + k * n] = A[j + k * n];
        A[j + k * n] = tmp;
      }
      *d = -(*d);
      vv[imax] = vv[j];
    }
    indx[j] = imax;
    if (A[j + j * n] == 0.0) {
      free(vv);
      return -1;
    }
    if (j != n - 1) {
      tmp = 1.0 / A[j + j * n];
      for (i = j + 1; i < n; ++i) {
        A[i + j * n] *= tmp;
      }
    }
  }
  free(vv);
  return 0;
}


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),%edi
mov    $0x1,%esi
call   1040 <mat@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movsd  0xea5(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1236 <ludcmp+0x116>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11dd <ludcmp+0xbd>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe64(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
ucomisd -0x30(%rbp),%xmm0
jbe    11ca <ludcmp+0xaa>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    11cf <ludcmp+0xaf>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1181 <ludcmp+0x61>
movsd  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    120e <ludcmp+0xee>
movsd  0xe09(%rip),%xmm0
divsd  -0x30(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1223 <ludcmp+0x103>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1609 <ludcmp+0x4e9>
jmp    1228 <ludcmp+0x108>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1166 <ludcmp+0x46>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15f9 <ludcmp+0x4d9>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    131e <ludcmp+0x1fe>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    12f3 <ludcmp+0x1d3>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1280 <ludcmp+0x160>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1250 <ludcmp+0x130>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1440 <ludcmp+0x320>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    13cf <ludcmp+0x2af>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    135c <ludcmp+0x23c>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
movaps 0xc0b(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
ucomisd -0x30(%rbp),%xmm0
jb     142d <ludcmp+0x30d>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    1432 <ludcmp+0x312>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    132c <ludcmp+0x20c>
mov    -0x54(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     1518 <ludcmp+0x3f8>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14d7 <ludcmp+0x3b7>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1453 <ludcmp+0x333>
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    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1566 <ludcmp+0x446>
jp     1566 <ludcmp+0x446>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1609 <ludcmp+0x4e9>
mov    -0x54(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     15e6 <ludcmp+0x4c6>
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xa6e(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15e1 <ludcmp+0x4c1>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15a5 <ludcmp+0x485>
jmp    15e6 <ludcmp+0x4c6>
jmp    15eb <ludcmp+0x4cb>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    123d <ludcmp+0x11d>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-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    $0x98,%rsp
mov    %rcx,%rbx
mov    %rdx,0x80(%rsp)
mov    %esi,%ebp
mov    %rdi,%r14
mov    %esi,%edi
mov    $0x1,%esi
call   1040 <mat@plt>
mov    %rax,%rdi
movabs $0x3ff0000000000000,%rax
mov    %rbx,0x50(%rsp)
mov    %rax,(%rbx)
mov    %rbp,0x10(%rsp)
test   %ebp,%ebp
jle    174c <ludcmp+0x62c>
mov    0x10(%rsp),%r15d
lea    -0x1(%r15),%r8
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
mov    %r15,%rdx
shl    $0x4,%rdx
xor    %esi,%esi
xorpd  %xmm2,%xmm2
movsd  0xe8d(%rip),%xmm0
movapd 0xe65(%rip),%xmm1
movapd 0xe5d(%rip),%xmm3
mov    %r14,0x8(%rsp)
nopl   0x0(%rax,%rax,1)
test   %r8,%r8
je     1250 <ludcmp+0x130>
xorpd  %xmm4,%xmm4
mov    %r14,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp),%xmm5
andpd  %xmm3,%xmm5
maxsd  %xmm4,%xmm5
movsd  0x0(%rbp,%r15,8),%xmm4
andpd  %xmm3,%xmm4
maxsd  %xmm5,%xmm4
add    $0x2,%rax
add    %rdx,%rbp
cmp    %rax,%rcx
jne    11d0 <ludcmp+0xb0>
test   $0x1,%r15b
je     121c <ludcmp+0xfc>
imul   %r15,%rax
add    %rsi,%rax
mov    0x8(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm5
andpd  %xmm1,%xmm5
maxsd  %xmm4,%xmm5
movapd %xmm5,%xmm4
ucomisd %xmm2,%xmm4
jbe    1755 <ludcmp+0x635>
movapd %xmm0,%xmm5
divsd  %xmm4,%xmm5
movsd  %xmm5,(%rdi,%rsi,8)
add    $0x1,%rsi
add    $0x8,%r14
cmp    %r15,%rsi
jne    11b0 <ludcmp+0x90>
jmp    125e <ludcmp+0x13e>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
xorpd  %xmm4,%xmm4
test   $0x1,%r15b
jne    11fe <ludcmp+0xde>
jmp    121c <ludcmp+0xfc>
mov    %r8,0x28(%rsp)
cmpl   $0x0,0x10(%rsp)
mov    0x8(%rsp),%rbx
jle    174c <ludcmp+0x62c>
mov    0x10(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x58(%rsp)
mov    %r15d,%r8d
and    $0xfffffffe,%r8d
mov    %r15,%r11
shl    $0x4,%r11
lea    0x8(%rbx),%rax
mov    %rax,0x30(%rsp)
lea    0x0(,%r15,8),%rax
mov    %rax,0x60(%rsp)
lea    0x38(%rbx),%r9
lea    -0x5(%r15),%rax
xor    %r14d,%r14d
mov    $0x1,%r12d
xorpd  %xmm9,%xmm9
movaps 0xd4e(%rip),%xmm8
xor    %r13d,%r13d
xor    %r10d,%r10d
mov    %rdi,0x48(%rsp)
mov    %r8,0x68(%rsp)
jmp    1302 <ludcmp+0x1e2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
mov    0x18(%rsp),%rax
add    $0x1,%r12
add    $0x1,%r14
add    $0x8,%r9
add    $0xffffffffffffffff,%rax
cmp    %r15,%r13
je     174c <ludcmp+0x62c>
mov    %r9,0x90(%rsp)
mov    %rax,0x18(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x38(%rsp)
mov    0x28(%rsp),%r8
sub    %r14,%r8
add    $0xfffffffffffffffc,%r8
mov    %r8,0x70(%rsp)
mov    %r8,%rax
shr    $0x2,%rax
mov    %rax,0x40(%rsp)
mov    %r13,(%rsp)
test   %r13,%r13
je     1410 <ludcmp+0x2f0>
mov    (%rsp),%r8
imul   %r15,%r8
mov    0x30(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    %rbx,%rbp
xor    %eax,%eax
jmp    1378 <ludcmp+0x258>
xchg   %ax,%ax
movsd  %xmm4,(%rbx,%r9,8)
add    $0x1,%rax
add    $0x8,%rbp
cmp    (%rsp),%rax
je     1410 <ludcmp+0x2f0>
lea    (%rax,%r8,1),%r9
movsd  (%rbx,%r9,8),%xmm4
test   %rax,%rax
je     1360 <ludcmp+0x240>
cmp    $0x1,%rax
jne    13a0 <ludcmp+0x280>
xor    %ecx,%ecx
jmp    13d9 <ludcmp+0x2b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rbp,%rbx
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rbx),%xmm5
mulsd  -0x8(%rsi,%rcx,8),%xmm5
subsd  %xmm5,%xmm4
movsd  (%rbx,%r15,8),%xmm5
mulsd  (%rsi,%rcx,8),%xmm5
subsd  %xmm5,%xmm4
add    $0x2,%rcx
add    %r11,%rbx
cmp    %rcx,%rdx
jne    13b0 <ludcmp+0x290>
test   $0x1,%al
mov    0x48(%rsp),%rdi
mov    0x8(%rsp),%rbx
je     1360 <ludcmp+0x240>
mov    %rcx,%rdx
imul   %r15,%rdx
add    %rax,%rdx
movsd  (%rbx,%rdx,8),%xmm5
add    %r8,%rcx
mulsd  (%rbx,%rcx,8),%xmm5
subsd  %xmm5,%xmm4
jmp    1360 <ludcmp+0x240>
nopl   0x0(%rax,%rax,1)
mov    %r12,0x88(%rsp)
andq   $0xfffffffffffffffe,0x38(%rsp)
addq   $0x1,0x40(%rsp)
mov    %r14,%rdx
not    %r14
add    %r15,%r14
mov    %r14,0x20(%rsp)
mov    (%rsp),%rcx
mov    %rcx,%rbp
imul   %r15,%rbp
mov    %rcx,%r14
and    $0xfffffffffffffffe,%r14
lea    0x0(,%rcx,8),%r8
mov    0x60(%rsp),%rax
lea    (%rax,%rcx,8),%r9
mov    0x30(%rsp),%rax
lea    (%rax,%rbp,8),%r13
mov    %rcx,%rax
xorpd  %xmm4,%xmm4
mov    %r8,0x78(%rsp)
mov    %rcx,%r12
jmp    14b9 <ludcmp+0x399>
nop
movsd  %xmm5,(%rbx,%rsi,8)
andpd  %xmm1,%xmm5
mulsd  (%rdi,%r12,8),%xmm5
ucomisd %xmm4,%xmm5
movapd %xmm4,%xmm6
cmpnlesd %xmm5,%xmm6
movapd %xmm6,%xmm7
andnpd %xmm5,%xmm7
andpd  %xmm4,%xmm6
orpd   %xmm7,%xmm6
cmovae %r12d,%r10d
add    $0x1,%r12
add    $0x8,%r9
add    $0x8,%r8
movapd %xmm6,%xmm4
cmp    %r15,%r12
je     1550 <ludcmp+0x430>
lea    (%r12,%rbp,1),%rsi
movsd  (%rbx,%rsi,8),%xmm5
test   %rax,%rax
je     1470 <ludcmp+0x350>
cmp    $0x1,%rax
jne    14e0 <ludcmp+0x3c0>
xor    %ecx,%ecx
jmp    151e <ludcmp+0x3fe>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%r8,1),%xmm6
mulsd  -0x8(%r13,%rcx,8),%xmm6
subsd  %xmm6,%xmm5
movsd  (%rax,%r9,1),%xmm6
mulsd  0x0(%r13,%rcx,8),%xmm6
subsd  %xmm6,%xmm5
add    $0x2,%rcx
add    %r11,%rax
cmp    %rcx,%r14
jne    14f0 <ludcmp+0x3d0>
mov    (%rsp),%rax
test   $0x1,%al
je     1470 <ludcmp+0x350>
mov    %rcx,%rax
imul   %r15,%rax
add    %r12,%rax
movsd  (%rbx,%rax,8),%xmm6
mov    (%rsp),%rax
add    %rbp,%rcx
mulsd  (%rbx,%rcx,8),%xmm6
subsd  %xmm6,%xmm5
jmp    1470 <ludcmp+0x350>
xchg   %ax,%ax
mov    %r10d,%eax
cmp    %rax,(%rsp)
mov    (%rsp),%r13
mov    0x68(%rsp),%r8
mov    0x90(%rsp),%r9
mov    %rdx,%r14
mov    0x88(%rsp),%r12
je     1627 <ludcmp+0x507>
movslq %r10d,%rsi
cmpq   $0x0,0x28(%rsp)
je     15d6 <ludcmp+0x4b6>
lea    (%r15,%r13,1),%rax
lea    (%r15,%rsi,1),%rbx
mov    0x8(%rsp),%rdx
xor    %edi,%edi
mov    0x78(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm4
movsd  (%rdx,%rcx,1),%xmm5
movsd  %xmm5,(%rdx,%rsi,8)
movsd  %xmm4,(%rdx,%rcx,1)
movsd  (%rdx,%rbx,8),%xmm4
movsd  (%rdx,%rax,8),%xmm5
movsd  %xmm5,(%rdx,%rbx,8)
movsd  %xmm4,(%rdx,%rax,8)
add    $0x2,%rdi
add    %r11,%rdx
cmp    %rdi,%r8
jne    15a0 <ludcmp+0x480>
jmp    15d8 <ludcmp+0x4b8>
xor    %edi,%edi
test   $0x1,%r15b
mov    0x8(%rsp),%rbx
je     1603 <ludcmp+0x4e3>
imul   %r15,%rdi
lea    (%rdi,%rsi,1),%rax
movsd  (%rbx,%rax,8),%xmm4
add    (%rsp),%rdi
movsd  (%rbx,%rdi,8),%xmm5
movsd  %xmm5,(%rbx,%rax,8)
movsd  %xmm4,(%rbx,%rdi,8)
mov    0x50(%rsp),%rax
movsd  (%rax),%xmm4
xorps  %xmm8,%xmm4
movlps %xmm4,(%rax)
mov    0x48(%rsp),%rdi
mov    (%rsp),%r13
movsd  (%rdi,%r13,8),%xmm4
movsd  %xmm4,(%rdi,%rsi,8)
mov    0x80(%rsp),%rax
mov    %r10d,(%rax,%r13,4)
mov    %r13d,%eax
imul   0x10(%rsp),%eax
cltq
add    %r13,%rax
movsd  (%rbx,%rax,8),%xmm5
ucomisd %xmm9,%xmm5
jne    1652 <ludcmp+0x532>
jnp    1755 <ludcmp+0x635>
cmp    0x58(%rsp),%r13
je     12e0 <ludcmp+0x1c0>
add    $0x1,%r13
cmp    %r15,%r13
jge    12e4 <ludcmp+0x1c4>
movapd %xmm0,%xmm4
divsd  %xmm5,%xmm4
mov    %r12,%rsi
cmpq   $0x4,0x20(%rsp)
jb     172b <ludcmp+0x60b>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
cmpq   $0x4,0x70(%rsp)
jae    1695 <ludcmp+0x575>
xor    %edx,%edx
jmp    16e8 <ludcmp+0x5c8>
lea    (%r9,%rbp,8),%rax
xor    %edx,%edx
mov    0x38(%rsp),%rsi
movupd -0x30(%rax,%rdx,8),%xmm6
movupd -0x20(%rax,%rdx,8),%xmm7
movupd -0x10(%rax,%rdx,8),%xmm3
movupd (%rax,%rdx,8),%xmm2
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm7
movupd %xmm6,-0x30(%rax,%rdx,8)
movupd %xmm7,-0x20(%rax,%rdx,8)
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
movupd %xmm3,-0x10(%rax,%rdx,8)
movupd %xmm2,(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    16a0 <ludcmp+0x580>
mov    0x20(%rsp),%rax
mov    %rax,%rsi
and    $0xfffffffffffffffc,%rsi
testb  $0x1,0x40(%rsp)
je     171f <ludcmp+0x5ff>
add    %r12,%rdx
add    %rbp,%rdx
movupd (%rbx,%rdx,8),%xmm2
movupd 0x10(%rbx,%rdx,8),%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
cmp    %rsi,%rax
je     12e4 <ludcmp+0x1c4>
add    %r12,%rsi
lea    (%rbx,%rbp,8),%rax
nop
movsd  (%rax,%rsi,8),%xmm2
mulsd  %xmm4,%xmm2
movsd  %xmm2,(%rax,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r15
jne    1730 <ludcmp+0x610>
jmp    12e4 <ludcmp+0x1c4>
call   1030 <free@plt>
xor    %eax,%eax
jmp    175f <ludcmp+0x63f>
call   1030 <free@plt>
mov    $0xffffffff,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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