#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 ludcmp(double carray[5][5], int *indx, int n) {
  int i, j, k, imax;
  double dum, sum, aamax, vv[100];
  imax = 0;
  for (i = 0; i < n; i++) {
    aamax = 0.0;
    for (j = 0; j < n; j++) {
      if (fabs(carray[i][j]) > aamax)
        aamax = fabs(carray[i][j]);
    }
    if (aamax == 0.0)
      return 0;
    vv[i] = 1.0 / aamax;
  }
  for (j = 0; j < n; j++) {
    if (j > 0) {
      for (i = 0; i < j; i++) {
        sum = carray[i][j];
        if (i > 0) {
          for (k = 0; k < i; k++) {
            sum -= carray[i][k] * carray[k][j];
          }
          carray[i][j] = sum;
        }
      }
    }
    aamax = 0.0;
    for (i = j; i < n; i++) {
      sum = carray[i][j];
      if (j > 0) {
        for (k = 0; k < j; k++) {
          sum -= carray[i][k] * carray[k][j];
        }
        carray[i][j] = sum;
      }
      dum = vv[i] * fabs(sum);
      if (dum >= aamax) {
        imax = i;
        aamax = dum;
      }
    }
    if (j != imax) {
      for (k = 0; k < n; k++) {
        dum = carray[imax][k];
        carray[imax][k] = carray[j][k];
        carray[j][k] = dum;
      }
      vv[imax] = vv[j];
    }
    indx[j] = imax;
    if (j != n) {
      if (carray[j][j] == 0.0) {
        carray[j][j] = 1e-20;
      }
      dum = 1.0 / carray[j][j];
      for (i = j + 1; i < n; i++) {
        carray[i][j] *= dum;
      }
    }
  }
  if (carray[n][n] == 0.0) {
    carray[n][n] = 1e-20;
  }
  return 1;
}


x86 assembly (clang, -O0):
<ludcmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2f0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1200 <ludcmp+0x100>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11b4 <ludcmp+0xb4>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xea6(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    11a1 <ludcmp+0xa1>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe78(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    11a6 <ludcmp+0xa6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    113f <ludcmp+0x3f>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11d8 <ludcmp+0xd8>
jp     11d8 <ludcmp+0xd8>
movl   $0x0,-0x4(%rbp)
jmp    1621 <ludcmp+0x521>
movsd  0xe28(%rip),%xmm0
divsd  -0x48(%rbp),%xmm0
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x370(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1124 <ludcmp+0x24>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15cf <ludcmp+0x4cf>
cmpl   $0x0,-0x24(%rbp)
jle    1306 <ludcmp+0x206>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1301 <ludcmp+0x201>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    12ee <ludcmp+0x1ee>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12d1 <ludcmp+0x1d1>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%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    125e <ludcmp+0x15e>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    12f3 <ludcmp+0x1f3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1224 <ludcmp+0x124>
jmp    1306 <ludcmp+0x206>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1437 <ludcmp+0x337>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    13de <ludcmp+0x2de>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13c1 <ludcmp+0x2c1>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%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    134e <ludcmp+0x24e>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x20(%rbp),%rax
movsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x40(%rbp),%xmm1
movaps 0xc19(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jb     1424 <ludcmp+0x324>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1429 <ludcmp+0x329>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1314 <ludcmp+0x214>
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     14e8 <ludcmp+0x3e8>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14ce <ludcmp+0x3ce>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    144a <ludcmp+0x34a>
movslq -0x24(%rbp),%rax
movsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x370(%rbp,%rax,8)
ff ff
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     15bc <ludcmp+0x4bc>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    154d <ludcmp+0x44d>
jp     154d <ludcmp+0x44d>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  0xab8(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  0xaa0(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15b7 <ludcmp+0x4b7>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    157b <ludcmp+0x47b>
jmp    15bc <ludcmp+0x4bc>
jmp    15c1 <ludcmp+0x4c1>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1207 <ludcmp+0x107>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    161a <ludcmp+0x51a>
jp     161a <ludcmp+0x51a>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  0x9eb(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ludcmp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x308,%rsp
mov    %rsi,-0x30(%rsp)
test   %edx,%edx
jle    16b0 <ludcmp+0x5b0>
mov    %edx,%r12d
mov    %r12d,%eax
and    $0xfffffffe,%eax
lea    0x8(%rdi),%rbx
xor    %esi,%esi
xorpd  %xmm2,%xmm2
movsd  0xed7(%rip),%xmm0
movapd 0xebf(%rip),%xmm1
movapd 0xeb7(%rip),%xmm3
nopl   0x0(%rax)
cmp    $0x1,%edx
jne    1160 <ludcmp+0x60>
xor    %ebp,%ebp
xorpd  %xmm4,%xmm4
jmp    1198 <ludcmp+0x98>
nopl   (%rax)
xorpd  %xmm5,%xmm5
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rbp,8),%xmm6
movsd  (%rbx,%rbp,8),%xmm4
andpd  %xmm3,%xmm6
maxsd  %xmm5,%xmm6
andpd  %xmm3,%xmm4
maxsd  %xmm6,%xmm4
add    $0x2,%rbp
movapd %xmm4,%xmm5
cmp    %rbp,%rax
jne    1170 <ludcmp+0x70>
test   $0x1,%r12b
je     11b7 <ludcmp+0xb7>
lea    (%rsi,%rsi,4),%rcx
lea    (%rdi,%rcx,8),%rcx
movsd  (%rcx,%rbp,8),%xmm5
andpd  %xmm1,%xmm5
maxsd  %xmm4,%xmm5
movapd %xmm5,%xmm4
ucomisd %xmm2,%xmm4
jne    11c3 <ludcmp+0xc3>
jnp    16e5 <ludcmp+0x5e5>
movapd %xmm0,%xmm5
divsd  %xmm4,%xmm5
movsd  %xmm5,-0x20(%rsp,%rsi,8)
add    $0x1,%rsi
add    $0x28,%rbx
cmp    %r12,%rsi
jne    1150 <ludcmp+0x50>
test   %edx,%edx
jle    16b0 <ludcmp+0x5b0>
mov    %edx,-0x7c(%rsp)
lea    (%rdi,%r12,8),%rax
mov    %rax,-0x40(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x48(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x58(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x50(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x60(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,-0x38(%rsp)
lea    0x8(%rdi),%r13
lea    0x30(%rdi),%r11
lea    0x28(%rdi),%rax
mov    %rax,-0x70(%rsp)
xor    %r8d,%r8d
mov    $0x1,%r14d
xorpd  %xmm2,%xmm2
movsd  0xdba(%rip),%xmm3
mov    %r11,-0x68(%rsp)
mov    %r13,-0x78(%rsp)
mov    %rdi,%r9
xor    %r10d,%r10d
jmp    128f <ludcmp+0x18f>
add    $0x1,%r14
add    $0x8,%r9
add    $0x28,%r13
add    $0x28,%r11
addq   $0x30,-0x70(%rsp)
cmp    %r12,%r8
je     16b3 <ludcmp+0x5b3>
test   %r8,%r8
je     1360 <ludcmp+0x260>
mov    -0x78(%rsp),%rax
xor    %ecx,%ecx
jmp    12c5 <ludcmp+0x1c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,(%rsi)
add    $0x1,%rcx
add    $0x28,%rax
cmp    %r8,%rcx
je     1360 <ludcmp+0x260>
test   %rcx,%rcx
je     12b4 <ludcmp+0x1b4>
lea    (%rcx,%rcx,4),%rdx
lea    (%rdi,%rdx,8),%r15
lea    (%r15,%r8,8),%rsi
movsd  (%rsi),%xmm4
cmp    $0x1,%rcx
jne    12f0 <ludcmp+0x1f0>
xor    %ebp,%ebp
jmp    1329 <ludcmp+0x229>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %r9,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  -0x8(%rax,%rbp,8),%xmm5
mulsd  (%rbx),%xmm5
movsd  (%rax,%rbp,8),%xmm6
subsd  %xmm5,%xmm4
mulsd  0x28(%rbx),%xmm6
subsd  %xmm6,%xmm4
add    $0x2,%rbp
add    $0x50,%rbx
cmp    %rbp,%rdx
jne    1300 <ludcmp+0x200>
test   $0x1,%cl
je     12b0 <ludcmp+0x1b0>
movsd  (%r15,%rbp,8),%xmm5
lea    0x0(,%rbp,4),%rdx
add    %rbp,%rdx
lea    (%rdi,%rdx,8),%rdx
mulsd  (%rdx,%r8,8),%xmm5
subsd  %xmm5,%xmm4
jmp    12b0 <ludcmp+0x1b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r8,%r8,4),%rcx
lea    (%rdi,%rcx,8),%r15
lea    (%r15,%r12,8),%rcx
mov    %rcx,-0x28(%rsp)
xorpd  %xmm4,%xmm4
mov    %r13,%rbx
mov    %r8,%rsi
jmp    13d8 <ludcmp+0x2d8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdx,%r8,8),%rcx
movsd  %xmm5,(%rcx)
andpd  %xmm1,%xmm5
mulsd  -0x20(%rsp,%rsi,8),%xmm5
ucomisd %xmm4,%xmm5
cmovae %esi,%r10d
movapd %xmm4,%xmm6
cmpnlesd %xmm5,%xmm6
movapd %xmm6,%xmm7
andnpd %xmm5,%xmm7
andpd  %xmm4,%xmm6
orpd   %xmm7,%xmm6
add    $0x1,%rsi
add    $0x28,%rbx
movapd %xmm6,%xmm4
cmp    %r12,%rsi
je     1470 <ludcmp+0x370>
lea    (%rsi,%rsi,4),%rcx
lea    (%rdi,%rcx,8),%rdx
movsd  (%rdx,%r8,8),%xmm5
test   %r8,%r8
je     1398 <ludcmp+0x298>
cmp    $0x1,%r8
jne    1400 <ludcmp+0x300>
xor    %ebp,%ebp
jmp    1439 <ludcmp+0x339>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rbx,%rbp,8),%xmm6
mulsd  (%rcx),%xmm6
movsd  (%rbx,%rbp,8),%xmm7
subsd  %xmm6,%xmm5
mulsd  0x28(%rcx),%xmm7
subsd  %xmm7,%xmm5
add    $0x2,%rbp
add    $0x50,%rcx
cmp    %rbp,%rax
jne    1410 <ludcmp+0x310>
test   $0x1,%r8b
je     1390 <ludcmp+0x290>
movsd  (%rdx,%rbp,8),%xmm6
lea    0x0(,%rbp,4),%rcx
add    %rbp,%rcx
lea    (%rdi,%rcx,8),%rcx
mulsd  (%rcx,%r8,8),%xmm6
subsd  %xmm6,%xmm5
jmp    1390 <ludcmp+0x290>
cs nopw 0x0(%rax,%rax,1)
mov    %r10d,%eax
cmp    %rax,%r8
je     162d <ludcmp+0x52d>
movslq %r10d,%rdx
cmpl   $0x4,-0x7c(%rsp)
jb     14af <ludcmp+0x3af>
lea    0x0(,%rdx,8),%rax
lea    (%rax,%rax,4),%rax
lea    (%rdi,%rax,1),%rcx
cmp    -0x28(%rsp),%rcx
jae    1540 <ludcmp+0x440>
add    -0x40(%rsp),%rax
cmp    %rax,%r15
jae    1540 <ludcmp+0x440>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r12b
je     14df <ludcmp+0x3df>
lea    (%rdx,%rdx,4),%rax
lea    (%rdi,%rax,8),%rax
movsd  (%rax,%rcx,8),%xmm4
movsd  (%r15,%rcx,8),%xmm5
movsd  %xmm5,(%rax,%rcx,8)
movsd  %xmm4,(%r15,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    -0x38(%rsp),%rcx
je     1620 <ludcmp+0x520>
lea    (%rdx,%rdx,4),%rcx
mov    -0x78(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rax,8),%xmm4
movsd  -0x8(%r13,%rax,8),%xmm5
movsd  %xmm5,-0x8(%rcx,%rax,8)
movsd  %xmm4,-0x8(%r13,%rax,8)
movsd  (%rcx,%rax,8),%xmm4
movsd  0x0(%r13,%rax,8),%xmm5
movsd  %xmm5,(%rcx,%rax,8)
movsd  %xmm4,0x0(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    1500 <ludcmp+0x400>
jmp    1620 <ludcmp+0x520>
cmpq   $0x0,-0x48(%rsp)
je     169e <ludcmp+0x59e>
lea    (%rdx,%rdx,4),%rax
mov    -0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    -0x60(%rsp),%rsi
xor    %eax,%eax
movups -0x30(%rcx,%rax,8),%xmm4
movups -0x20(%rcx,%rax,8),%xmm5
movups -0x30(%r11,%rax,8),%xmm6
movups -0x20(%r11,%rax,8),%xmm7
movups %xmm6,-0x30(%rcx,%rax,8)
movups %xmm7,-0x20(%rcx,%rax,8)
movups %xmm4,-0x30(%r11,%rax,8)
movups %xmm5,-0x20(%r11,%rax,8)
movupd -0x10(%rcx,%rax,8),%xmm4
movupd (%rcx,%rax,8),%xmm5
movupd -0x10(%r11,%rax,8),%xmm6
movupd (%r11,%rax,8),%xmm7
movupd %xmm6,-0x10(%rcx,%rax,8)
movupd %xmm7,(%rcx,%rax,8)
movupd %xmm4,-0x10(%r11,%rax,8)
movupd %xmm5,(%r11,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    1560 <ludcmp+0x460>
testb  $0x1,-0x50(%rsp)
je     1605 <ludcmp+0x505>
lea    (%rdx,%rdx,4),%rcx
lea    (%rdi,%rcx,8),%rcx
movupd (%rcx,%rax,8),%xmm4
movupd 0x10(%rcx,%rax,8),%xmm5
movupd (%r15,%rax,8),%xmm6
movupd 0x10(%r15,%rax,8),%xmm7
movupd %xmm6,(%rcx,%rax,8)
movupd %xmm7,0x10(%rcx,%rax,8)
movupd %xmm4,(%r15,%rax,8)
movupd %xmm5,0x10(%r15,%rax,8)
mov    -0x58(%rsp),%rax
mov    %rax,%rcx
cmp    %r12,%rax
jne    14b1 <ludcmp+0x3b1>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x20(%rsp,%r8,8),%xmm4
movsd  %xmm4,-0x20(%rsp,%rdx,8)
mov    -0x30(%rsp),%rax
mov    %r10d,(%rax,%r8,4)
movsd  (%r15,%r8,8),%xmm5
ucomisd %xmm2,%xmm5
jne    1659 <ludcmp+0x559>
jp     1659 <ludcmp+0x559>
lea    (%r15,%r8,8),%rax
movabs $0x3bc79ca10c924223,%rcx
9c c7 3b
mov    %rcx,(%rax)
movapd %xmm3,%xmm5
add    $0x1,%r8
cmp    %r12,%r8
jae    1270 <ludcmp+0x170>
movapd %xmm0,%xmm4
divsd  %xmm5,%xmm4
mov    %r12,%rax
mov    -0x70(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx),%xmm5
mulsd  %xmm4,%xmm5
movsd  %xmm5,(%rcx)
add    $0x28,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r14
jne    1680 <ludcmp+0x580>
jmp    1270 <ludcmp+0x170>
xor    %eax,%eax
testb  $0x1,-0x50(%rsp)
jne    15cd <ludcmp+0x4cd>
jmp    1605 <ludcmp+0x505>
movslq %edx,%r12
lea    (%r12,%r12,4),%rax
lea    (%rdi,%rax,8),%rcx
movsd  (%rcx,%r12,8),%xmm0
mov    $0x1,%eax
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16e7 <ludcmp+0x5e7>
jp     16e7 <ludcmp+0x5e7>
lea    (%rcx,%r12,8),%rcx
movabs $0x3bc79ca10c924223,%rdx
9c c7 3b
mov    %rdx,(%rcx)
jmp    16e7 <ludcmp+0x5e7>
xor    %eax,%eax
add    $0x308,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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