#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 array_max_abs(double *, int);
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double sqrt(double);
double cholmod(double *A, int N, double *L, double eps, double maxinp) {
  int i, j, k, step, step2;
  double ls;
  double *U22;
  double maxadd, maxdiag, minl, minl2, minljj;
  U22 = (double *)malloc(sizeof(double) * N * N);
  minl = sqrt(sqrt(eps)) * maxinp;
  maxadd = 0.0;
  for (i = 0; i < N; ++i) {
    U22[i] = A[i + i * N];
  }
  for (i = 0; i < N * N; ++i) {
    L[i] = 0.0;
  }
  maxdiag = array_max_abs(U22, N);
  if (maxinp == 0.0) {
    maxinp = sqrt(maxdiag);
  }
  minl2 = sqrt(eps) * maxinp;
  for (j = 0; j < N; ++j) {
    step = j * N;
    ls = 0.0;
    for (i = 0; i < j; ++i) {
      ls += L[step + i] * L[step + i];
    }
    L[step + j] = A[step + j] - ls;
    minljj = 0.0;
    for (i = j + 1; i < N; ++i) {
      ls = 0.0;
      step2 = i * N;
      for (k = 0; k < j; ++k) {
        ls += L[step + k] * L[step2 + k];
      }
      L[step2 + j] = A[step + i] - ls;
      if (fabs(L[step2 + j]) > minljj) {
        minljj = fabs(L[step2 + j]);
      }
    }
    if (minljj / maxinp > minl) {
      minljj = minljj / maxinp;
    } else {
      minljj = minl;
    }
    if (L[step + j] > minljj * minljj) {
      L[step + j] = sqrt(L[step + j]);
    } else {
      if (minljj < minl2) {
        minljj = minl2;
      }
      if (maxadd < (minljj * minljj - L[step + j])) {
        maxadd = minljj * minljj - L[step + j];
      }
      L[step + j] = minljj;
    }
    for (i = j + 1; i < N; ++i) {
      L[i * N + j] /= L[step + j];
    }
  }
  free(U22);
  return maxadd;
}


x86 assembly (clang, -O0):
<cholmod>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1050 <sqrt@plt>
call   1050 <sqrt@plt>
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11e2 <cholmod+0xa2>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a3 <cholmod+0x63>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1219 <cholmod+0xd9>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e9 <cholmod+0xa9>
mov    -0x50(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1060 <array_max_abs@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1251 <cholmod+0x111>
jp     1251 <cholmod+0x111>
movsd  -0x60(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x28(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1050 <sqrt@plt>
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15c3 <cholmod+0x483>
mov    -0x30(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    12e1 <cholmod+0x1a1>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1291 <cholmod+0x151>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1416 <cholmod+0x2d6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1390 <cholmod+0x250>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1340 <cholmod+0x200>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc2e(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1403 <cholmod+0x2c3>
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc06(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1408 <cholmod+0x2c8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    131b <cholmod+0x1db>
movsd  -0x78(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    143f <cholmod+0x2ff>
movsd  -0x78(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1449 <cholmod+0x309>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    149d <cholmod+0x35d>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <sqrt@plt>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    155c <cholmod+0x41c>
movsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    14bb <cholmod+0x37b>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1545 <cholmod+0x405>
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15b0 <cholmod+0x470>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1565 <cholmod+0x425>
jmp    15b5 <cholmod+0x475>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    126c <cholmod+0x12c>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x58(%rbp),%xmm0
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cholmod>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    %rdx,0x28(%rsp)
mov    %esi,%r14d
mov    %rdi,0x18(%rsp)
mov    %esi,%r15d
imul   %r15d,%r15d
lea    0x0(,%r15,8),%edi
call   1050 <malloc@plt>
movsd  0x10(%rsp),%xmm0
mov    %rax,%r13
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     11af <cholmod+0x5f>
sqrtsd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jae    11be <cholmod+0x6e>
call   1060 <sqrt@plt>
jmp    11c2 <cholmod+0x72>
call   1060 <sqrt@plt>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     11a8 <cholmod+0x58>
sqrtsd %xmm0,%xmm0
mov    0x18(%rsp),%r9
mov    %r14d,%r12d
test   %r14d,%r14d
jle    1248 <cholmod+0xf8>
xor    %ecx,%ecx
cmp    $0x1,%r14d
jne    11db <cholmod+0x8b>
xor    %eax,%eax
jmp    1229 <cholmod+0xd9>
mov    %r12d,%r8d
and    $0xfffffffe,%r8d
lea    (%r14,%r14,1),%esi
mov    $0x1,%edi
mov    %r14d,%ebp
xor    %eax,%eax
movslq %ebp,%rbp
lea    (%rdi,%rbp,1),%rbx
movslq %ecx,%rcx
lea    (%rax,%rcx,1),%rdx
movsd  (%r9,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%r9,%rbx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
add    %esi,%ecx
add    $0x2,%rdi
add    %esi,%ebp
cmp    %rax,%r8
jne    11f0 <cholmod+0xa0>
test   $0x1,%r12b
je     1248 <cholmod+0xf8>
mov    %eax,%ecx
imul   %r14d,%ecx
movslq %ecx,%rcx
add    %rax,%rcx
movsd  (%r9,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  %xmm0,0x20(%rsp)
test   %r15d,%r15d
je     1266 <cholmod+0x116>
mov    %r15d,%edx
shl    $0x3,%rdx
mov    0x28(%rsp),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    %r13,%rdi
mov    %r14d,%esi
call   1070 <array_max_abs@plt>
xorpd  %xmm1,%xmm1
movsd  0x8(%rsp),%xmm5
ucomisd %xmm1,%xmm5
jne    129f <cholmod+0x14f>
jp     129f <cholmod+0x14f>
ucomisd %xmm1,%xmm0
jb     1292 <cholmod+0x142>
xorps  %xmm5,%xmm5
sqrtsd %xmm0,%xmm5
jmp    129f <cholmod+0x14f>
call   1060 <sqrt@plt>
xorpd  %xmm1,%xmm1
movapd %xmm0,%xmm5
movsd  0x10(%rsp),%xmm0
ucomisd %xmm1,%xmm0
movsd  %xmm5,0x50(%rsp)
jb     12b8 <cholmod+0x168>
sqrtsd %xmm0,%xmm9
jmp    12c8 <cholmod+0x178>
call   1060 <sqrt@plt>
movsd  0x50(%rsp),%xmm5
movapd %xmm0,%xmm9
mov    0x28(%rsp),%r9
mov    0x18(%rsp),%r10
movsd  0x20(%rsp),%xmm4
mov    %r13,0x60(%rsp)
test   %r14d,%r14d
jle    167c <cholmod+0x52c>
mulsd  0x8(%rsp),%xmm4
mulsd  %xmm5,%xmm9
lea    0x18(%r9),%rbx
lea    0x0(,%r12,8),%r15
lea    (%r9,%r12,8),%rax
add    $0x8,%rax
mov    %rax,0x58(%rsp)
lea    -0x2(%r12),%r11
mov    %r12,%rbp
shl    $0x4,%rbp
add    %r9,%rbp
lea    0x8(,%r12,8),%rax
mov    %rax,0x70(%rsp)
xorpd  %xmm8,%xmm8
mov    $0x1,%edx
xor    %esi,%esi
movapd 0xcc6(%rip),%xmm7
mov    %r9,%r13
xorpd  %xmm6,%xmm6
movsd  %xmm4,0x20(%rsp)
movsd  %xmm9,0x68(%rsp)
jmp    1371 <cholmod+0x221>
add    $0x1,%rdx
add    %r15,%rbx
add    %r15,%r13
add    %r15,0x58(%rsp)
add    $0xffffffffffffffff,%r11
add    0x70(%rsp),%rbp
cmp    %r12,%rsi
je     1680 <cholmod+0x530>
mov    %rdx,0x10(%rsp)
mov    %rsi,%r14
mov    %rsi,%r8
imul   %r12,%r8
xorpd  %xmm1,%xmm1
test   %rsi,%rsi
je     1426 <cholmod+0x2d6>
lea    -0x1(%r14),%rcx
cmp    $0x3,%rcx
jae    13a0 <cholmod+0x250>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
jmp    13f0 <cholmod+0x2a0>
nop
mov    %r14,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
nopl   (%rax)
movsd  -0x18(%rbx,%rcx,8),%xmm0
movsd  -0x10(%rbx,%rcx,8),%xmm2
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x8(%rbx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    13b0 <cholmod+0x260>
test   $0x3,%r14b
je     1426 <cholmod+0x2d6>
mov    %r14d,%edx
and    $0x3,%edx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%rcx,%rsi,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1410 <cholmod+0x2c0>
lea    (%r8,%r14,1),%rax
movsd  (%r10,%rax,8),%xmm0
subsd  %xmm1,%xmm0
mov    %rax,0x8(%rsp)
movsd  %xmm0,(%r9,%rax,8)
lea    0x1(%r14),%rsi
xorpd  %xmm2,%xmm2
cmp    %r12,%rsi
jae    156a <cholmod+0x41a>
mov    %rsi,0x38(%rsp)
mov    %rbp,0x40(%rsp)
mov    %r11,0x48(%rsp)
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
xorpd  %xmm2,%xmm2
mov    0x58(%rsp),%rdx
mov    0x10(%rsp),%rsi
jmp    14af <cholmod+0x35f>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%r8,1),%rax
movsd  (%r10,%rax,8),%xmm2
subsd  %xmm1,%xmm2
add    %r14,%rdi
movsd  %xmm2,(%r9,%rdi,8)
andpd  %xmm7,%xmm2
maxsd  %xmm0,%xmm2
add    $0x1,%rsi
add    %r15,%rdx
cmp    %r12,%rsi
je     1550 <cholmod+0x400>
movapd %xmm2,%xmm0
mov    %rsi,%rdi
imul   %r12,%rdi
xorpd  %xmm1,%xmm1
test   %r14,%r14
je     1480 <cholmod+0x330>
cmp    $0x1,%r14
jne    14e0 <cholmod+0x390>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    151e <cholmod+0x3ce>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm3
movsd  0x8(%r13,%rbp,8),%xmm1
mulsd  -0x8(%rdx,%rbp,8),%xmm3
mulsd  (%rdx,%rbp,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x2,%rbp
movapd %xmm1,%xmm2
cmp    %rbp,%rcx
jne    14f0 <cholmod+0x3a0>
test   $0x1,%r14b
je     1480 <cholmod+0x330>
lea    (%r8,%rbp,1),%rax
movsd  (%r9,%rax,8),%xmm2
add    %rdi,%rbp
mulsd  (%r9,%rbp,8),%xmm2
addsd  %xmm2,%xmm1
jmp    1480 <cholmod+0x330>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%rax
movsd  (%r9,%rax,8),%xmm0
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%rbp
mov    0x38(%rsp),%rsi
divsd  %xmm5,%xmm2
maxsd  %xmm4,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1590 <cholmod+0x440>
ucomisd %xmm8,%xmm0
jb     15b0 <cholmod+0x460>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    160d <cholmod+0x4bd>
movapd %xmm9,%xmm1
maxsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm0,%xmm2
maxsd  %xmm6,%xmm2
movapd %xmm2,%xmm6
jmp    160d <cholmod+0x4bd>
nop
mov    %rbp,0x40(%rsp)
mov    %r11,0x48(%rsp)
movsd  %xmm6,0x30(%rsp)
mov    %rsi,0x38(%rsp)
call   1060 <sqrt@plt>
mov    0x38(%rsp),%rsi
movsd  0x30(%rsp),%xmm6
movapd 0xa23(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%rbp
movsd  0x68(%rsp),%xmm9
movsd  0x50(%rsp),%xmm5
movsd  0x20(%rsp),%xmm4
mov    0x18(%rsp),%r10
mov    0x28(%rsp),%r9
movapd %xmm0,%xmm1
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rdi
movsd  %xmm1,(%r9,%rdi,8)
cmp    %r12,%rsi
jae    1350 <cholmod+0x200>
mov    %rdx,%rax
imul   %r12,%rax
add    %r14,%rax
movsd  (%r9,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rax,8)
lea    0x1(%rdx),%rax
cmp    %r12,%rax
je     1350 <cholmod+0x200>
mov    %rbp,%rax
mov    %r11,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax),%xmm0
divsd  (%r9,%rdi,8),%xmm0
movsd  %xmm0,(%rax)
add    %r15,%rax
add    $0xffffffffffffffff,%rcx
jne    1660 <cholmod+0x510>
jmp    1350 <cholmod+0x200>
xorpd  %xmm6,%xmm6
movsd  %xmm6,0x30(%rsp)
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
movsd  0x30(%rsp),%xmm0
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @cholmod(double* nocapture %0, i32 %1, double* nocapture %2, double %3, double %4) {
%6 = bitcast double* %2 to i8*
%7 = shl i32 %1, 3
%8 = mul i32 %7, %1
%9 = tail call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to double*
%11 = tail call double @sqrt(double %3)
%12 = tail call double @sqrt(double %11)
%13 = fmul double %12, %4
%14 = icmp sgt i32 %1, 0
br i1 %14, label %15, label %32
15: ; preds = %5
%16 = zext i32 %1 to i64
%17 = and i64 %16, 1
%18 = icmp eq i32 %1, 1
br i1 %18, label %21, label %19
19: ; preds = %15
%20 = and i64 %16, 4294967294
br label %38
21: ; preds = %38, %15
%22 = phi i64 [ 0, %15 ], [ %56, %38 ]
%23 = icmp eq i64 %17, 0
br i1 %23, label %32, label %24
24: ; preds = %21
%25 = trunc i64 %22 to i32
%26 = mul nsw i32 %25, %1
%27 = sext i32 %26 to i64
%28 = add nsw i64 %22, %27
%29 = getelementptr inbounds double, double* %0, i64 %28
%30 = load double, double* %29
%31 = getelementptr inbounds double, double* %10, i64 %22
store double %30, double* %31
br label %32
32: ; preds = %24, %21, %5
%33 = mul i32 %1, %1
%34 = icmp eq i32 %33, 0
br i1 %34, label %59, label %35
35: ; preds = %32
%36 = zext i32 %33 to i64
%37 = shl nuw nsw i64 %36, 3
br label %59
38: ; preds = %38, %19
%39 = phi i64 [ 0, %19 ], [ %56, %38 ]
%40 = phi i64 [ 0, %19 ], [ %57, %38 ]
%41 = trunc i64 %39 to i32
%42 = mul nsw i32 %41, %1
%43 = sext i32 %42 to i64
%44 = add nsw i64 %39, %43
%45 = getelementptr inbounds double, double* %0, i64 %44
%46 = load double, double* %45
%47 = getelementptr inbounds double, double* %10, i64 %39
store double %46, double* %47
%48 = or i64 %39, 1
%49 = trunc i64 %48 to i32
%50 = mul nsw i32 %49, %1
%51 = sext i32 %50 to i64
%52 = add nsw i64 %48, %51
%53 = getelementptr inbounds double, double* %0, i64 %52
%54 = load double, double* %53
%55 = getelementptr inbounds double, double* %10, i64 %48
store double %54, double* %55
%56 = add nuw nsw i64 %39, 2
%57 = add i64 %40, 2
%58 = icmp eq i64 %57, %20
br i1 %58, label %21, label %38
59: ; preds = %35, %32
%60 = tail call double @array_max_abs(double* %10, i32 %1)
%61 = fcmp oeq double %4, 0.000000e+00
br i1 %61, label %62, label %64
62: ; preds = %59
%63 = tail call double @sqrt(double %60)
br label %64
64: ; preds = %62, %59
%65 = phi double [ %63, %62 ], [ %4, %59 ]
%66 = tail call double @sqrt(double %3)
%67 = fmul double %65, %66
br i1 %14, label %68, label %234
68: ; preds = %64
%69 = zext i32 %1 to i64
%70 = zext i32 %1 to i64
br label %74
71: ; preds = %224, %216, %213
%72 = add nuw nsw i64 %76, 1
%73 = icmp eq i64 %135, %70
br i1 %73, label %234, label %74
74: ; preds = %68, %71
%75 = phi i64 [ 0, %68 ], [ %135, %71 ]
%76 = phi i64 [ 1, %68 ], [ %72, %71 ]
%77 = phi double [ 0.000000e+00, %68 ], [ %215, %71 ]
%78 = mul nsw i64 %75, %69
%79 = icmp eq i64 %75, 0
br i1 %79, label %128, label %80
80: ; preds = %74
%81 = add nsw i64 %75, -1
%82 = and i64 %75, 3
%83 = icmp ult i64 %81, 3
br i1 %83, label %112, label %84
84: ; preds = %80
%85 = and i64 %75, 9223372036854775804
br label %86
86: ; preds = %86, %84
%87 = phi i64 [ 0, %84 ], [ %109, %86 ]
%88 = phi double [ 0.000000e+00, %84 ], [ %108, %86 ]
%89 = phi i64 [ 0, %84 ], [ %110, %86 ]
%90 = add nuw nsw i64 %87, %78
%91 = getelementptr inbounds double, double* %2, i64 %90
%92 = load double, double* %91
%93 = tail call double @llvm.fmuladd.f64(double %92, double %92, double %88)
%94 = or i64 %87, 1
%95 = add nuw nsw i64 %94, %78
%96 = getelementptr inbounds double, double* %2, i64 %95
%97 = load double, double* %96
%98 = tail call double @llvm.fmuladd.f64(double %97, double %97, double %93)
%99 = or i64 %87, 2
%100 = add nuw nsw i64 %99, %78
%101 = getelementptr inbounds double, double* %2, i64 %100
%102 = load double, double* %101
%103 = tail call double @llvm.fmuladd.f64(double %102, double %102, double %98)
%104 = or i64 %87, 3
%105 = add nuw nsw i64 %104, %78
%106 = getelementptr inbounds double, double* %2, i64 %105
%107 = load double, double* %106
%108 = tail call double @llvm.fmuladd.f64(double %107, double %107, double %103)
%109 = add nuw nsw i64 %87, 4
%110 = add i64 %89, 4
%111 = icmp eq i64 %110, %85
br i1 %111, label %112, label %86
112: ; preds = %86, %80
%113 = phi double [ undef, %80 ], [ %108, %86 ]
%114 = phi i64 [ 0, %80 ], [ %109, %86 ]
%115 = phi double [ 0.000000e+00, %80 ], [ %108, %86 ]
%116 = icmp eq i64 %82, 0
br i1 %116, label %128, label %117
117: ; preds = %112, %117
%118 = phi i64 [ %125, %117 ], [ %114, %112 ]
%119 = phi double [ %124, %117 ], [ %115, %112 ]
%120 = phi i64 [ %126, %117 ], [ 0, %112 ]
%121 = add nuw nsw i64 %118, %78
%122 = getelementptr inbounds double, double* %2, i64 %121
%123 = load double, double* %122
%124 = tail call double @llvm.fmuladd.f64(double %123, double %123, double %119)
%125 = add nuw nsw i64 %118, 1
%126 = add i64 %120, 1
%127 = icmp eq i64 %126, %82
br i1 %127, label %128, label %117
128: ; preds = %112, %117, %74
%129 = phi double [ 0.000000e+00, %74 ], [ %113, %112 ], [ %124, %117 ]
%130 = add nuw nsw i64 %78, %75
%131 = getelementptr inbounds double, double* %0, i64 %130
%132 = load double, double* %131
%133 = fsub double %132, %129
%134 = getelementptr inbounds double, double* %2, i64 %130
store double %133, double* %134
%135 = add nuw nsw i64 %75, 1
%136 = icmp ult i64 %135, %69
br i1 %136, label %137, label %196
137: ; preds = %128
%138 = and i64 %75, 1
%139 = icmp eq i64 %75, 1
%140 = and i64 %75, 9223372036854775806
%141 = icmp eq i64 %138, 0
br label %142
142: ; preds = %137, %181
%143 = phi i64 [ %192, %181 ], [ %76, %137 ]
%144 = phi double [ %191, %181 ], [ 0.000000e+00, %137 ]
%145 = mul nsw i64 %143, %69
br i1 %79, label %181, label %146
146: ; preds = %142
br i1 %139, label %169, label %147
147: ; preds = %146, %147
%148 = phi i64 [ %166, %147 ], [ 0, %146 ]
%149 = phi double [ %165, %147 ], [ 0.000000e+00, %146 ]
%150 = phi i64 [ %167, %147 ], [ 0, %146 ]
%151 = add nuw nsw i64 %148, %78
%152 = getelementptr inbounds double, double* %2, i64 %151
%153 = load double, double* %152
%154 = add nuw nsw i64 %148, %145
%155 = getelementptr inbounds double, double* %2, i64 %154
%156 = load double, double* %155
%157 = tail call double @llvm.fmuladd.f64(double %153, double %156, double %149)
%158 = or i64 %148, 1
%159 = add nuw nsw i64 %158, %78
%160 = getelementptr inbounds double, double* %2, i64 %159
%161 = load double, double* %160
%162 = add nuw nsw i64 %158, %145
%163 = getelementptr inbounds double, double* %2, i64 %162
%164 = load double, double* %163
%165 = tail call double @llvm.fmuladd.f64(double %161, double %164, double %157)
%166 = add nuw nsw i64 %148, 2
%167 = add i64 %150, 2
%168 = icmp eq i64 %167, %140
br i1 %168, label %169, label %147
169: ; preds = %147, %146
%170 = phi double [ undef, %146 ], [ %165, %147 ]
%171 = phi i64 [ 0, %146 ], [ %166, %147 ]
%172 = phi double [ 0.000000e+00, %146 ], [ %165, %147 ]
br i1 %141, label %181, label %173
173: ; preds = %169
%174 = add nuw nsw i64 %171, %78
%175 = getelementptr inbounds double, double* %2, i64 %174
%176 = load double, double* %175
%177 = add nuw nsw i64 %171, %145
%178 = getelementptr inbounds double, double* %2, i64 %177
%179 = load double, double* %178
%180 = tail call double @llvm.fmuladd.f64(double %176, double %179, double %172)
br label %181
181: ; preds = %173, %169, %142
%182 = phi double [ 0.000000e+00, %142 ], [ %170, %169 ], [ %180, %173 ]
%183 = add nuw nsw i64 %143, %78
%184 = getelementptr inbounds double, double* %0, i64 %183
%185 = load double, double* %184
%186 = fsub double %185, %182
%187 = add nuw nsw i64 %145, %75
%188 = getelementptr inbounds double, double* %2, i64 %187
store double %186, double* %188
%189 = tail call double @llvm.fabs.f64(double %186)
%190 = fcmp ogt double %189, %144
%191 = select i1 %190, double %189, double %144
%192 = add nuw nsw i64 %143, 1
%193 = icmp eq i64 %192, %70
br i1 %193, label %194, label %142
194: ; preds = %181
%195 = load double, double* %134
br label %196
196: ; preds = %194, %128
%197 = phi double [ %133, %128 ], [ %195, %194 ]
%198 = phi double [ 0.000000e+00, %128 ], [ %191, %194 ]
%199 = fdiv double %198, %65
%200 = fcmp ogt double %199, %13
%201 = select i1 %200, double %199, double %13
%202 = fmul double %201, %201
%203 = fcmp ogt double %197, %202
br i1 %203, label %204, label %206
204: ; preds = %196
%205 = tail call double @sqrt(double %197)
br label %213
206: ; preds = %196
%207 = fcmp olt double %201, %67
%208 = select i1 %207, double %67, double %201
%209 = fneg double %197
%210 = tail call double @llvm.fmuladd.f64(double %208, double %208, double %209)
%211 = fcmp olt double %77, %210
%212 = select i1 %211, double %210, double %77
br label %213
213: ; preds = %206, %204
%214 = phi double [ %208, %206 ], [ %205, %204 ]
%215 = phi double [ %212, %206 ], [ %77, %204 ]
store double %214, double* %134
br i1 %136, label %216, label %71
216: ; preds = %213
%217 = mul nsw i64 %76, %69
%218 = add nuw nsw i64 %217, %75
%219 = getelementptr inbounds double, double* %2, i64 %218
%220 = load double, double* %219
%221 = fdiv double %220, %214
store double %221, double* %219
%222 = add nuw nsw i64 %76, 1
%223 = icmp eq i64 %222, %70
br i1 %223, label %71, label %224
224: ; preds = %216, %224
%225 = phi i64 [ %232, %224 ], [ %222, %216 ]
%226 = load double, double* %134
%227 = mul nsw i64 %225, %69
%228 = add nuw nsw i64 %227, %75
%229 = getelementptr inbounds double, double* %2, i64 %228
%230 = load double, double* %229
%231 = fdiv double %230, %226
store double %231, double* %229
%232 = add nuw nsw i64 %225, 1
%233 = icmp eq i64 %232, %70
br i1 %233, label %71, label %224
234: ; preds = %71, %64
%235 = phi double [ 0.000000e+00, %64 ], [ %215, %71 ]
%236 = tail call i32 @free(double* %10)
ret double %235
}