#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 */
float fabs(float);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ nrerror(char *);
float *vector(int, int);
void ludcmp(float **a, int n, int *indx, float *d) {
  int i, imax, j, k;
  float big, dum, sum, temp;
  float *vv;
  vv = vector(1, n);
  *d = 1.0;
  for (i = 1; i <= n; i++) {
    big = 0.0;
    for (j = 1; j <= n; j++)
      if ((temp = fabs(a[i][j])) > big)
        big = temp;
    if (big == 0.0)
      nrerror("Singular matrix in routine ludcmp");
    vv[i] = 1.0 / big;
  }
  for (j = 1; j <= n; j++) {
    for (i = 1; i < j; i++) {
      sum = a[i][j];
      for (k = 1; 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 = 1; 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 = 1; k <= n; k++) {
        dum = a[imax][k];
        a[imax][k] = a[j][k];
        a[j][k] = dum;
      }
      *d = -(*d);
      vv[imax] = vv[j];
    }
    indx[j] = imax;
    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_vector(vv, 1, n);
}


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)
mov    %rcx,-0x20(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1060 <vector@plt>
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0xe8c(%rip),%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1248 <ludcmp+0x108>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11ec <ludcmp+0xac>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movss  %xmm0,-0x40(%rbp)
ucomiss -0x34(%rbp),%xmm0
jbe    11d9 <ludcmp+0x99>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    11de <ludcmp+0x9e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    119a <ludcmp+0x5a>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1214 <ludcmp+0xd4>
jp     1214 <ludcmp+0xd4>
lea    0xe01(%rip),%rdi
call   1030 <nrerror@plt>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xde3(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    117f <ludcmp+0x3f>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     15d9 <ludcmp+0x499>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    131a <ludcmp+0x1da>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12f2 <ludcmp+0x1b2>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    128f <ludcmp+0x14f>
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1262 <ludcmp+0x122>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     142c <ludcmp+0x2ec>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13b8 <ludcmp+0x278>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1355 <ludcmp+0x215>
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
ucomiss -0x34(%rbp),%xmm0
jb     1419 <ludcmp+0x2d9>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    141e <ludcmp+0x2de>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1328 <ludcmp+0x1e8>
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     14ee <ludcmp+0x3ae>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14b7 <ludcmp+0x377>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    143f <ludcmp+0x2ff>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1545 <ludcmp+0x405>
jp     1545 <ludcmp+0x405>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  0xac4(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
je     15c6 <ludcmp+0x486>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa96(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     15c1 <ludcmp+0x481>
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1588 <ludcmp+0x448>
jmp    15c6 <ludcmp+0x486>
jmp    15cb <ludcmp+0x48b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    124f <ludcmp+0x10f>
mov    -0x48(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ludcmp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rcx,%r14
mov    %rdx,0x70(%rsp)
mov    %esi,%ebp
mov    %rdi,%rbx
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,%r13
mov    %r14,0x68(%rsp)
movl   $0x3f800000,(%r14)
mov    %rbp,0x8(%rsp)
test   %ebp,%ebp
jle    16e2 <ludcmp+0x5b2>
mov    0x8(%rsp),%r15d
lea    0x1(%r15),%rax
mov    %rax,0x10(%rsp)
lea    -0x1(%r15),%r12
mov    %r15d,%r14d
and    $0x3,%r14d
mov    %r15,0x18(%rsp)
and    $0xfffffffc,%r15d
mov    $0x1,%ebp
movaps 0xe61(%rip),%xmm7
jmp    11d2 <ludcmp+0xa2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0xe68(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rbp,4)
add    $0x1,%rbp
cmp    0x10(%rsp),%rbp
je     128d <ludcmp+0x15d>
mov    (%rbx,%rbp,8),%rax
mov    $0x1,%ecx
xorps  %xmm0,%xmm0
cmp    $0x3,%r12
jb     1231 <ludcmp+0x101>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  0x4(%rax,%rcx,4),%xmm1
movss  0x8(%rax,%rcx,4),%xmm2
movss  0xc(%rax,%rcx,4),%xmm3
andps  %xmm7,%xmm1
maxss  %xmm0,%xmm1
movss  0x10(%rax,%rcx,4),%xmm0
andps  %xmm7,%xmm2
maxss  %xmm1,%xmm2
andps  %xmm7,%xmm3
maxss  %xmm2,%xmm3
andps  %xmm7,%xmm0
maxss  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %rcx,%r15
jne    11f0 <ludcmp+0xc0>
add    $0x1,%rcx
movaps %xmm0,%xmm1
test   %r14,%r14
je     1258 <ludcmp+0x128>
lea    (%rax,%rcx,4),%rax
xor    %ecx,%ecx
nop
movss  (%rax,%rcx,4),%xmm1
andps  %xmm7,%xmm1
maxss  %xmm0,%xmm1
add    $0x1,%rcx
movaps %xmm1,%xmm0
cmp    %rcx,%r14
jne    1240 <ludcmp+0x110>
ucomiss 0xdc9(%rip),%xmm1
jne    11b0 <ludcmp+0x80>
jp     11b0 <ludcmp+0x80>
lea    0xdba(%rip),%rdi
movaps %xmm1,0x20(%rsp)
call   1030 <nrerror@plt>
movaps 0x20(%rsp),%xmm1
movaps 0xd78(%rip),%xmm7
jmp    11b0 <ludcmp+0x80>
cmpl   $0x0,0x8(%rsp)
jle    16e2 <ludcmp+0x5b2>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r12d
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%rcx
add    $0xfffffffffffffff7,%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0x48(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x40(%rsp)
mov    %rdx,%rax
mov    %rdx,0x50(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x38(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x60(%rsp)
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%r14
lea    0x10(%rbx),%r15
mov    $0x1,%r8d
xor    %r11d,%r11d
xorps  %xmm0,%xmm0
movss  0xd12(%rip),%xmm1
movaps 0xcf7(%rip),%xmm2
jmp    1339 <ludcmp+0x209>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x1,%r11
add    $0xffffffffffffffff,%r14
add    $0x8,%r15
cmp    %r12,%r8
je     16e2 <ludcmp+0x5b2>
mov    %r11,%r9
and    $0xfffffffffffffffe,%r9
cmp    $0x2,%r8
jb     1410 <ludcmp+0x2e0>
mov    $0x1,%ecx
xor    %edi,%edi
jmp    1378 <ludcmp+0x248>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm3,0x0(%rbp,%r8,4)
add    $0x1,%rcx
add    $0x1,%rdi
cmp    %r8,%rcx
je     1410 <ludcmp+0x2e0>
mov    (%rbx,%rcx,8),%rbp
movss  0x0(%rbp,%r8,4),%xmm3
cmp    $0x2,%rcx
jb     1360 <ludcmp+0x230>
mov    $0x1,%edx
cmp    $0x1,%rdi
je     13eb <ludcmp+0x2bb>
mov    %rdi,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%rbp,%rdx,4),%xmm4
movss  0x4(%rbp,%rdx,4),%xmm5
mov    (%rbx,%rdx,8),%rax
mulss  (%rax,%r8,4),%xmm4
mov    0x8(%rbx,%rdx,8),%rax
subss  %xmm4,%xmm3
mulss  (%rax,%r8,4),%xmm5
subss  %xmm5,%xmm3
lea    (%rsi,%rdx,1),%rax
add    $0x2,%rax
add    $0x2,%rdx
cmp    $0x1,%rax
jne    13b0 <ludcmp+0x280>
test   $0x1,%dil
je     1360 <ludcmp+0x230>
movss  0x0(%rbp,%rdx,4),%xmm4
mov    (%rbx,%rdx,8),%rax
mulss  (%rax,%r8,4),%xmm4
subss  %xmm4,%xmm3
jmp    1360 <ludcmp+0x230>
xchg   %ax,%ax
neg    %r9
xorps  %xmm3,%xmm3
mov    %r8,%rcx
jmp    145b <ludcmp+0x32b>
nopl   0x0(%rax,%rax,1)
movss  %xmm4,(%rsi,%r8,4)
andps  %xmm7,%xmm4
mulss  0x0(%r13,%rcx,4),%xmm4
ucomiss %xmm3,%xmm4
movaps %xmm3,%xmm5
cmpnless %xmm4,%xmm5
movaps %xmm5,%xmm6
andnps %xmm4,%xmm6
andps  %xmm3,%xmm5
orps   %xmm6,%xmm5
cmovae %ecx,%r10d
add    $0x1,%rcx
movaps %xmm5,%xmm3
cmp    %r12,%rcx
je     14e0 <ludcmp+0x3b0>
mov    (%rbx,%rcx,8),%rsi
movss  (%rsi,%r8,4),%xmm4
cmp    $0x2,%r8
jb     1420 <ludcmp+0x2f0>
mov    $0x1,%edx
cmp    $0x1,%r11
je     14ba <ludcmp+0x38a>
mov    $0x1,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rdx,4),%xmm5
movss  0x4(%rsi,%rdx,4),%xmm6
mov    (%rbx,%rdx,8),%rax
mulss  (%rax,%r8,4),%xmm5
mov    0x8(%rbx,%rdx,8),%rax
subss  %xmm5,%xmm4
mulss  (%rax,%r8,4),%xmm6
subss  %xmm6,%xmm4
lea    (%r9,%rdx,1),%rax
add    $0x2,%rax
add    $0x2,%rdx
cmp    $0x1,%rax
jne    1480 <ludcmp+0x350>
test   $0x1,%r11b
je     1420 <ludcmp+0x2f0>
movss  (%rsi,%rdx,4),%xmm5
mov    (%rbx,%rdx,8),%rax
mulss  (%rax,%r8,4),%xmm5
subss  %xmm5,%xmm4
jmp    1420 <ludcmp+0x2f0>
nopl   0x0(%rax)
mov    %r10d,%eax
cmp    %rax,%r8
je     1675 <ludcmp+0x545>
movslq %r10d,%r9
mov    (%rbx,%r9,8),%rbp
mov    (%rbx,%r8,8),%rcx
mov    $0x1,%edx
cmpq   $0x8,0x20(%rsp)
jb     15f0 <ludcmp+0x4c0>
lea    0x4(%rbp),%rax
mov    0x10(%rsp),%rsi
lea    (%rcx,%rsi,4),%rsi
cmp    %rsi,%rax
jae    1537 <ludcmp+0x407>
mov    0x10(%rsp),%rax
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
lea    0x4(%rcx),%rsi
cmp    %rax,%rsi
jb     15f0 <ludcmp+0x4c0>
cmpq   $0x8,0x58(%rsp)
jae    1543 <ludcmp+0x413>
xor    %esi,%esi
jmp    15aa <ludcmp+0x47a>
mov    0x38(%rsp),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups 0x4(%rbp,%rsi,4),%xmm3
movups 0x14(%rbp,%rsi,4),%xmm4
movups 0x4(%rcx,%rsi,4),%xmm5
movups 0x14(%rcx,%rsi,4),%xmm6
movups %xmm5,0x4(%rbp,%rsi,4)
movups %xmm6,0x14(%rbp,%rsi,4)
movups %xmm3,0x4(%rcx,%rsi,4)
movups %xmm4,0x14(%rcx,%rsi,4)
movups 0x24(%rbp,%rsi,4),%xmm3
movups 0x34(%rbp,%rsi,4),%xmm4
movups 0x24(%rcx,%rsi,4),%xmm5
movups 0x34(%rcx,%rsi,4),%xmm6
movups %xmm5,0x24(%rbp,%rsi,4)
movups %xmm6,0x34(%rbp,%rsi,4)
movups %xmm3,0x24(%rcx,%rsi,4)
movups %xmm4,0x34(%rcx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1550 <ludcmp+0x420>
testb  $0x1,0x50(%rsp)
je     15df <ludcmp+0x4af>
shl    $0x2,%rsi
or     $0x4,%rsi
movups 0x0(%rbp,%rsi,1),%xmm3
movups 0x10(%rbp,%rsi,1),%xmm4
movups (%rcx,%rsi,1),%xmm5
movups 0x10(%rcx,%rsi,1),%xmm6
movups %xmm5,0x0(%rbp,%rsi,1)
movups %xmm6,0x10(%rbp,%rsi,1)
movups %xmm3,(%rcx,%rsi,1)
movups %xmm4,0x10(%rcx,%rsi,1)
mov    0x40(%rsp),%rdx
mov    0x48(%rsp),%rax
cmp    %rax,0x20(%rsp)
je     1657 <ludcmp+0x527>
mov    %rdx,%rsi
test   $0x1,%r12b
jne    1613 <ludcmp+0x4e3>
movss  0x0(%rbp,%rdx,4),%xmm3
movss  (%rcx,%rdx,4),%xmm4
movss  %xmm4,0x0(%rbp,%rdx,4)
movss  %xmm3,(%rcx,%rdx,4)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0x60(%rsp),%rdx
je     1657 <ludcmp+0x527>
nopl   (%rax)
movss  0x0(%rbp,%rsi,4),%xmm3
movss  (%rcx,%rsi,4),%xmm4
movss  %xmm4,0x0(%rbp,%rsi,4)
movss  %xmm3,(%rcx,%rsi,4)
movss  0x4(%rbp,%rsi,4),%xmm3
movss  0x4(%rcx,%rsi,4),%xmm4
movss  %xmm4,0x4(%rbp,%rsi,4)
movss  %xmm3,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    1620 <ludcmp+0x4f0>
mov    0x68(%rsp),%rax
movss  (%rax),%xmm3
xorps  %xmm2,%xmm3
movss  %xmm3,(%rax)
movss  0x0(%r13,%r8,4),%xmm3
movss  %xmm3,0x0(%r13,%r9,4)
mov    0x70(%rsp),%rax
mov    %r10d,(%rax,%r8,4)
mov    (%rbx,%r8,8),%rcx
movss  (%rcx,%r8,4),%xmm4
ucomiss %xmm0,%xmm4
jne    169a <ludcmp+0x56a>
jp     169a <ludcmp+0x56a>
movl   $0x1e3ce508,(%rcx,%r8,4)
1e
movaps %xmm1,%xmm4
cmp    0x18(%rsp),%r8
je     1320 <ludcmp+0x1f0>
jae    1320 <ludcmp+0x1f0>
movss  0x96d(%rip),%xmm3
divss  %xmm4,%xmm3
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%r15,%rcx,8),%rax
movss  (%rax,%r8,4),%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,(%rax,%r8,4)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    16c0 <ludcmp+0x590>
jmp    1320 <ludcmp+0x1f0>
mov    %r13,%rdi
mov    $0x1,%esi
mov    0x8(%rsp),%rdx
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>

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

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