#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(double *, int);
double array_max_abs(double *, int);
double array_min(double *, int);
double cholmod(double *, int, double *, double, double);
scalar_t__ fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double sqrt(double);
double modelhess(double *A, int N, double *dx, double eps, double *L) {
  double *U22;
  double sqrteps, maxdiag, mindiag, maxposdiag, u;
  double maxoffdiag, maxinp, maxadd;
  double maxev, minev, offrow, sdd;
  int step, i, j, k;
  sqrteps = sqrt(eps);
  U22 = (double *)malloc(sizeof(double) * N * N);
  for (i = 0; i < N; ++i) {
    step = i * N;
    for (j = 0; j < N; ++j) {
      A[step + j] /= (dx[i] * dx[j]);
    }
  }
  for (i = 0; i < N; ++i) {
    U22[i] = A[i + i * N];
  }
  maxdiag = array_max(U22, N);
  mindiag = array_min(U22, N);
  maxposdiag = 0.0;
  if (maxdiag > maxposdiag) {
    maxposdiag = maxdiag;
  }
  for (i = 0; i < N; ++i) {
    U22[i] = 0.0;
  }
  u = 0.0;
  if (mindiag <= sqrteps * maxposdiag) {
    u = 2 * (maxposdiag - mindiag) * sqrteps - mindiag;
    maxdiag += u;
  }
  k = 0;
  for (i = 0; i < N; ++i) {
    for (j = 0; j < N; ++j) {
      if (j > i) {
        U22[k] = A[i * N + j];
        k++;
      }
    }
  }
  maxoffdiag = array_max_abs(U22, k);
  if (maxoffdiag * (1 + 2 * sqrteps) > maxdiag) {
    u += (maxoffdiag - maxdiag) + 2 * sqrteps * maxoffdiag;
    maxdiag = maxoffdiag * (1 + 2 * sqrteps);
  }
  if (maxdiag == 0) {
    u = 1;
    maxdiag = 1;
  }
  if (u > 0) {
    for (i = 0; i < N; ++i) {
      A[i * N + i] += u;
    }
  }
  if (maxdiag > maxoffdiag / N) {
    maxinp = sqrt(maxdiag);
  } else {
    maxinp = sqrt(maxoffdiag / N);
  }
  maxadd = cholmod(A, N, L, eps, maxinp);
  if (maxadd > 0) {
    maxev = minev = A[0];
    for (i = 0; i < N; ++i) {
      offrow = 0.0;
      step = i * N;
      for (j = 0; j < i; ++j) {
        offrow += fabs(A[step + j]);
      }
      for (j = i + 1; j < N; ++j) {
        offrow += fabs(A[step + j]);
      }
      if (maxev < A[step + i] + offrow) {
        maxev = A[step + i] + offrow;
      }
      if (minev > A[step + i] - offrow) {
        minev = A[step + i] - offrow;
      }
    }
    sdd = (maxev - minev) * sqrteps - minev;
    if (sdd < 0) {
      sdd = 0;
    }
    if (maxadd > sdd) {
      u = sdd;
    } else {
      u = maxadd;
    }
    for (i = 0; i < N; ++i) {
      A[i * N + i] += u;
    }
  }
  maxadd = cholmod(A, N, L, eps, 0.0);
  for (i = 0; i < N; ++i) {
    step = i * N;
    for (j = 0; j < N; ++j) {
      A[step + j] *= (dx[i] * dx[j]);
    }
  }
  for (i = 0; i < N; ++i) {
    step = i * N;
    for (j = 0; j < i + 1; ++j) {
      L[step + j] *= dx[i];
    }
  }
  free(U22);
  return maxadd;
}


x86 assembly (clang, -O0):
<modelhess>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0x38(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1279 <modelhess+0xf9>
mov    -0x98(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1260 <modelhess+0xe0>
mov    -0x18(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    11fc <modelhess+0x7c>
jmp    1265 <modelhess+0xe5>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    11d3 <modelhess+0x53>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12d4 <modelhess+0x154>
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    -0x98(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1283 <modelhess+0x103>
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1070 <array_max@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1050 <array_min@plt>
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1318 <modelhess+0x198>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1358 <modelhess+0x1d8>
mov    -0x30(%rbp),%rax
movslq -0x98(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1322 <modelhess+0x1a2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     13cc <modelhess+0x24c>
movsd  -0x50(%rbp),%xmm1
subsd  -0x48(%rbp),%xmm1
movsd  0xc75(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1487 <modelhess+0x307>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    146e <modelhess+0x2ee>
mov    -0x9c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jle    1455 <modelhess+0x2d5>
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    145a <modelhess+0x2da>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    13f9 <modelhess+0x279>
jmp    1473 <modelhess+0x2f3>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    13e0 <modelhess+0x260>
mov    -0x30(%rbp),%rdi
mov    -0xa0(%rbp),%esi
call   10a0 <array_max_abs@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
addsd  %xmm1,%xmm1
movsd  0xb57(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1515 <modelhess+0x395>
movsd  -0x60(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
movsd  0xb2a(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
addsd  %xmm1,%xmm1
movsd  0xb00(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1547 <modelhess+0x3c7>
jp     1547 <modelhess+0x3c7>
movsd  0xad3(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xac6(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15b1 <modelhess+0x431>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15ac <modelhess+0x42c>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1563 <modelhess+0x3e3>
jmp    15b1 <modelhess+0x431>
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
cvtsi2sdl -0xc(%rbp),%xmm2
divsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    15e2 <modelhess+0x462>
movsd  -0x40(%rbp),%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
jmp    15fa <modelhess+0x47a>
movsd  -0x60(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x28(%rbp),%rdx
movsd  -0x20(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
call   1040 <cholmod@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    18d6 <modelhess+0x756>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17f8 <modelhess+0x678>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    16d3 <modelhess+0x553>
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    167b <modelhess+0x4fb>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1737 <modelhess+0x5b7>
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    16e2 <modelhess+0x562>
movsd  -0x78(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    178b <modelhess+0x60b>
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    17df <modelhess+0x65f>
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
jmp    17e4 <modelhess+0x664>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1647 <modelhess+0x4c7>
movsd  -0x78(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    184f <modelhess+0x6cf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    1874 <modelhess+0x6f4>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
jmp    187e <modelhess+0x6fe>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18d1 <modelhess+0x751>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1888 <modelhess+0x708>
jmp    18d6 <modelhess+0x756>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x28(%rbp),%rdx
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
call   1040 <cholmod@plt>
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    199f <modelhess+0x81f>
mov    -0x98(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1986 <modelhess+0x806>
mov    -0x18(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1926 <modelhess+0x7a6>
jmp    198b <modelhess+0x80b>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    18fd <modelhess+0x77d>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a43 <modelhess+0x8c3>
mov    -0x98(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x98(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a2a <modelhess+0x8aa>
mov    -0x18(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    19d2 <modelhess+0x852>
jmp    1a2f <modelhess+0x8af>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    19a9 <modelhess+0x829>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x70(%rbp),%xmm0
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<modelhess>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rcx,0x38(%rsp)
mov    %rdx,%r13
mov    %esi,%ebp
mov    %rdi,0x28(%rsp)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movsd  %xmm0,0x50(%rsp)
jb     11c6 <modelhess+0x36>
sqrtsd %xmm0,%xmm0
jmp    11cb <modelhess+0x3b>
call   10a0 <sqrt@plt>
movsd  %xmm0,0x48(%rsp)
mov    %ebp,%edi
imul   %ebp,%edi
shl    $0x3,%edi
call   1090 <malloc@plt>
mov    %ebp,%r8d
test   %ebp,%ebp
mov    %rax,0x40(%rsp)
mov    %r8,0x10(%rsp)
mov    %rbp,0x30(%rsp)
mov    0x28(%rsp),%r10
jle    14ae <modelhess+0x31e>
lea    0x0(,%r8,8),%r11
add    %r13,%r11
mov    %r8d,%r14d
and    $0xfffffffe,%r14d
lea    -0x2(%r14),%rax
mov    %rax,0x8(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
lea    -0x1(%r8),%r15
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x20(%rsp)
lea    0x10(%r10),%rbp
lea    0x0(,%r8,8),%r12
lea    0x8(%r10),%rdi
xor    %eax,%eax
jmp    1263 <modelhess+0xd3>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %r12,%rbp
add    %r12,%rdi
cmp    %r8,%rax
je     141d <modelhess+0x28d>
mov    %rax,%rcx
imul   %r8,%rcx
cmpl   $0x2,0x30(%rsp)
jae    1300 <modelhess+0x170>
xor    %esi,%esi
mov    %rsi,%rdx
test   $0x1,%r8b
je     12a8 <modelhess+0x118>
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  0x0(%r13,%rsi,8),%xmm0
add    %rsi,%rcx
movsd  (%r10,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rcx,8)
mov    %rsi,%rdx
or     $0x1,%rdx
cmp    %rsi,%r15
je     1250 <modelhess+0xc0>
nopl   (%rax)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  0x0(%r13,%rdx,8),%xmm0
movsd  -0x8(%rdi,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm1,-0x8(%rdi,%rdx,8)
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  0x8(%r13,%rdx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r8
jne    12b0 <modelhess+0x120>
jmp    1250 <modelhess+0xc0>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r8,1),%rdx
lea    (%r10,%rcx,8),%rsi
lea    (%r10,%rdx,8),%rbx
lea    0x8(,%rax,8),%rdx
add    %r13,%rdx
lea    0x0(,%rax,8),%r8
add    %r13,%r8
cmp    %r11,%rsi
setb   %r9b
cmp    %r13,%rbx
seta   %r10b
cmp    %rdx,%rsi
setb   %dl
cmp    %rbx,%r8
setb   %bl
test   %r10b,%r9b
jne    1401 <modelhess+0x271>
mov    $0x0,%esi
and    %bl,%dl
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r10
jne    1277 <modelhess+0xe7>
cmpq   $0x0,0x8(%rsp)
je     1412 <modelhess+0x282>
movsd  0x0(%r13,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    0x20(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rdx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd -0x10(%rbp,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd %xmm2,-0x10(%rbp,%rdx,8)
movupd 0x10(%r13,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1380 <modelhess+0x1f0>
testb  $0x1,0x18(%rsp)
je     13f0 <modelhess+0x260>
movsd  0x0(%r13,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
movupd 0x0(%r13,%rdx,8),%xmm1
mulpd  %xmm0,%xmm1
add    %rcx,%rdx
movupd (%r10,%rdx,8),%xmm0
divpd  %xmm1,%xmm0
movupd %xmm0,(%r10,%rdx,8)
mov    %r14,%rsi
cmp    %r8,%r14
je     1250 <modelhess+0xc0>
jmp    1277 <modelhess+0xe7>
xor    %esi,%esi
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r10
jmp    1277 <modelhess+0xe7>
xor    %edx,%edx
testb  $0x1,0x18(%rsp)
jne    13c7 <modelhess+0x237>
jmp    13f0 <modelhess+0x260>
mov    0x30(%rsp),%rbp
test   %ebp,%ebp
mov    0x40(%rsp),%rax
jle    14ae <modelhess+0x31e>
xor    %ecx,%ecx
test   %r15,%r15
je     148a <modelhess+0x2fa>
and    $0xfffffffe,%r8d
mov    0x30(%rsp),%rbp
lea    0x0(%rbp,%rbp,1),%r9d
mov    $0x1,%edi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbp
lea    (%rdi,%rbp,1),%rbx
movslq %ecx,%rcx
lea    (%rsi,%rcx,1),%rdx
movsd  (%r10,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
movsd  (%r10,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rsi,8)
add    $0x2,%rsi
add    %r9d,%ecx
add    $0x2,%rdi
add    %r9d,%ebp
cmp    %rsi,%r8
jne    1450 <modelhess+0x2c0>
jmp    148c <modelhess+0x2fc>
xor    %esi,%esi
testb  $0x1,0x10(%rsp)
mov    0x30(%rsp),%rbp
je     14ae <modelhess+0x31e>
mov    %esi,%ecx
imul   %ebp,%ecx
movslq %ecx,%rcx
add    %rsi,%rcx
movsd  (%r10,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
mov    %rax,%rdi
mov    %ebp,%esi
mov    %rax,%rbx
call   1080 <array_max@plt>
movsd  %xmm0,0x8(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
call   1060 <array_min@plt>
movsd  0x8(%rsp),%xmm2
xorpd  %xmm1,%xmm1
movapd %xmm2,%xmm4
maxsd  %xmm1,%xmm4
test   %ebp,%ebp
mov    %rbp,%r15
jle    151d <modelhess+0x38d>
mov    0x10(%rsp),%rax
lea    0x0(,%rax,8),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
movsd  %xmm0,0x18(%rsp)
movsd  %xmm4,0x20(%rsp)
call   1040 <memset@plt>
movsd  0x20(%rsp),%xmm4
movsd  0x18(%rsp),%xmm0
movsd  0x8(%rsp),%xmm2
xorpd  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm3
mulsd  %xmm4,%xmm3
ucomisd %xmm0,%xmm3
jb     1547 <modelhess+0x3b7>
subsd  %xmm0,%xmm4
addsd  %xmm4,%xmm4
mulsd  0x48(%rsp),%xmm4
subsd  %xmm0,%xmm4
addsd  %xmm4,%xmm2
movapd %xmm4,%xmm1
test   %r15d,%r15d
mov    0x40(%rsp),%rdi
mov    0x10(%rsp),%rbx
mov    0x28(%rsp),%r9
movsd  %xmm1,0x18(%rsp)
movsd  %xmm2,0x8(%rsp)
jle    1616 <modelhess+0x486>
mov    %ebx,%eax
and    $0xfffffffe,%eax
lea    0x8(%r9),%rcx
lea    0x0(,%rbx,8),%r8
xor    %edx,%edx
xor    %esi,%esi
jmp    159c <modelhess+0x40c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
add    %r8,%rcx
cmp    %rbx,%rdx
je     1618 <modelhess+0x488>
xor    %ebp,%ebp
cmp    $0x1,%r15d
jne    15e9 <modelhess+0x459>
test   $0x1,%bl
je     1590 <modelhess+0x400>
cmp    %rdx,%rbp
jbe    1590 <modelhess+0x400>
mov    %rdx,%rbx
imul   0x10(%rsp),%rbx
add    %rbx,%rbp
mov    0x10(%rsp),%rbx
movsd  (%r9,%rbp,8),%xmm0
movslq %esi,%rsi
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%esi
jmp    1590 <modelhess+0x400>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rbp
cmp    %rbp,%rax
je     15a4 <modelhess+0x414>
cmp    %rdx,%rbp
jbe    15ff <modelhess+0x46f>
movsd  -0x8(%rcx,%rbp,8),%xmm0
movslq %esi,%rsi
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%esi
cmp    %rdx,%rbp
jb     15e0 <modelhess+0x450>
movsd  (%rcx,%rbp,8),%xmm0
movslq %esi,%rsi
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%esi
jmp    15e0 <modelhess+0x450>
xor    %esi,%esi
call   10b0 <array_max_abs@plt>
movapd %xmm0,%xmm1
movsd  0x48(%rsp),%xmm2
addsd  %xmm2,%xmm2
movsd  0x9cd(%rip),%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm4
ucomisd %xmm4,%xmm0
jbe    1663 <modelhess+0x4d3>
movapd %xmm1,%xmm3
subsd  %xmm4,%xmm3
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movsd  0x18(%rsp),%xmm4
addsd  %xmm2,%xmm4
jmp    166d <modelhess+0x4dd>
movapd %xmm4,%xmm0
movsd  0x18(%rsp),%xmm4
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
movsd  0x983(%rip),%xmm3
mov    0x28(%rsp),%rdi
jne    168a <modelhess+0x4fa>
jp     168a <modelhess+0x4fa>
movapd %xmm3,%xmm4
jne    1692 <modelhess+0x502>
jp     1692 <modelhess+0x502>
movapd %xmm3,%xmm0
ucomisd %xmm2,%xmm4
jbe    1738 <modelhess+0x5a8>
test   %r15d,%r15d
jle    1738 <modelhess+0x5a8>
xor    %eax,%eax
cmp    $0x1,%r15d
je     171d <modelhess+0x58d>
lea    (%r15,%r15,1),%r9d
mov    %ebx,%r8d
and    $0xfffffffe,%r8d
neg    %r8
mov    $0x1,%ebx
xor    %esi,%esi
mov    %r15d,%ebp
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rbp
lea    (%rbx,%rbp,1),%r10
cltq
lea    (%rdx,%rax,1),%rcx
movsd  (%rdi,%rcx,8),%xmm2
addsd  %xmm4,%xmm2
movsd  %xmm2,(%rdi,%rcx,8)
movsd  (%rdi,%r10,8),%xmm2
addsd  %xmm4,%xmm2
movsd  %xmm2,(%rdi,%r10,8)
add    $0x2,%rdx
add    %r9d,%eax
add    $0x2,%rbx
add    %r9d,%ebp
add    $0xfffffffffffffffe,%rsi
cmp    %rsi,%r8
jne    16d0 <modelhess+0x540>
neg    %rsi
mov    %rsi,%rax
mov    0x10(%rsp),%rbx
test   $0x1,%bl
je     1738 <modelhess+0x5a8>
mov    %eax,%ecx
imul   %r15d,%ecx
movslq %ecx,%rcx
add    %rax,%rcx
addsd  (%rdi,%rcx,8),%xmm4
movsd  %xmm4,(%rdi,%rcx,8)
xorps  %xmm2,%xmm2
cvtsi2sd %r15d,%xmm2
divsd  %xmm2,%xmm1
maxsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     175b <modelhess+0x5cb>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1769 <modelhess+0x5d9>
call   10a0 <sqrt@plt>
mov    0x28(%rsp),%rdi
movapd %xmm0,%xmm1
mov    %r15d,%esi
mov    0x38(%rsp),%rdx
movsd  0x50(%rsp),%xmm0
call   1050 <cholmod@plt>
mov    0x28(%rsp),%rdi
ucomisd 0x87f(%rip),%xmm0
jbe    1ac8 <modelhess+0x938>
movsd  %xmm0,0x70(%rsp)
movsd  (%rdi),%xmm2
test   %r15d,%r15d
jle    1a06 <modelhess+0x876>
lea    0x18(%rdi),%r14
lea    0x0(,%rbx,8),%rax
mov    %rax,0x80(%rsp)
lea    0x8(,%rbx,8),%rax
mov    %rax,0x78(%rsp)
xor    %r15d,%r15d
mov    %rbx,%rbp
mov    %rdi,%rcx
mov    %rdi,0x58(%rsp)
movapd %xmm2,%xmm3
jmp    1851 <modelhess+0x6c1>
nopw   0x0(%rax,%rax,1)
mov    0x68(%rsp),%rbp
mov    0x60(%rsp),%rcx
movslq 0x18(%rsp),%rax
mov    0x20(%rsp),%rdx
add    %rax,%rdx
mov    0x28(%rsp),%rdi
movsd  (%rdi,%rdx,8),%xmm0
movapd %xmm2,%xmm1
addsd  %xmm0,%xmm1
maxsd  0x88(%rsp),%xmm1
subsd  %xmm2,%xmm0
minsd  0x90(%rsp),%xmm0
mov    0x80(%rsp),%rax
add    %rax,%r14
add    %rax,0x58(%rsp)
add    0x78(%rsp),%rcx
add    $0xffffffffffffffff,%rbp
mov    %r12,%r15
movapd %xmm0,%xmm2
movapd %xmm1,%xmm3
mov    0x10(%rsp),%rbx
cmp    %rbx,%r12
je     1a0e <modelhess+0x87e>
mov    %r15d,%eax
mov    %r15d,0x18(%rsp)
test   %r15,%r15
mov    %rbp,0x68(%rsp)
mov    %rcx,0x60(%rsp)
movsd  %xmm2,0x90(%rsp)
mov    %r15,0x20(%rsp)
movsd  %xmm3,0x88(%rsp)
je     18a0 <modelhess+0x710>
lea    -0x1(%r15),%rax
cmp    $0x3,%rax
jae    18b0 <modelhess+0x720>
xorpd  %xmm2,%xmm2
xor    %r12d,%r12d
jmp    194c <modelhess+0x7bc>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm2,%xmm2
jmp    199b <modelhess+0x80b>
nopl   0x0(%rax)
and    $0xfffffffffffffffc,%r15
xorpd  %xmm2,%xmm2
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
movsd  %xmm2,0x8(%rsp)
movsd  -0x18(%r14,%r12,8),%xmm0
call   1070 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  -0x10(%r14,%r12,8),%xmm0
call   1070 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  -0x8(%r14,%r12,8),%xmm0
call   1070 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r14,%r12,8),%xmm0
call   1070 <fabs@plt>
xorps  %xmm2,%xmm2
cvtsi2sd %rax,%xmm2
addsd  0x8(%rsp),%xmm2
add    $0x4,%r12
cmp    %r12,%r15
jne    18c0 <modelhess+0x730>
testb  $0x3,0x20(%rsp)
je     199b <modelhess+0x80b>
mov    0x18(%rsp),%eax
mov    %eax,%r15d
and    $0x3,%r15d
mov    0x58(%rsp),%rax
lea    (%rax,%r12,8),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  %xmm2,0x8(%rsp)
movsd  (%rbx,%rbp,8),%xmm0
call   1070 <fabs@plt>
movsd  0x8(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1970 <modelhess+0x7e0>
mov    0x18(%rsp),%eax
imul   0x30(%rsp),%eax
mov    %eax,0x18(%rsp)
mov    0x20(%rsp),%rax
lea    0x1(%rax),%r12
cmp    0x10(%rsp),%r12
jae    17e0 <modelhess+0x650>
mov    $0x1,%ebx
mov    0x68(%rsp),%rbp
mov    0x60(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movsd  %xmm2,0x8(%rsp)
movsd  (%rcx,%rbx,8),%xmm0
mov    %rcx,%r15
call   1070 <fabs@plt>
movsd  0x8(%rsp),%xmm2
mov    %r15,%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    19d0 <modelhess+0x840>
jmp    17ea <modelhess+0x65a>
movapd %xmm2,%xmm1
movapd %xmm2,%xmm0
mov    0x30(%rsp),%r15
test   %r15d,%r15d
jle    1eb4 <modelhess+0xd24>
subsd  %xmm0,%xmm1
mulsd  0x48(%rsp),%xmm1
subsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
maxsd  %xmm1,%xmm0
minsd  0x70(%rsp),%xmm0
xor    %eax,%eax
cmp    $0x1,%r15d
je     1aad <modelhess+0x91d>
lea    (%r15,%r15,1),%r9d
mov    %ebx,%r8d
and    $0xfffffffe,%r8d
neg    %r8
mov    $0x1,%ebx
xor    %esi,%esi
mov    %r15d,%ebp
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rbp
lea    (%rbx,%rbp,1),%r10
cltq
lea    (%rdx,%rax,1),%rcx
movsd  (%rdi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  (%rdi,%r10,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%r10,8)
add    $0x2,%rdx
add    %r9d,%eax
add    $0x2,%rbx
add    %r9d,%ebp
add    $0xfffffffffffffffe,%rsi
cmp    %rsi,%r8
jne    1a60 <modelhess+0x8d0>
neg    %rsi
mov    %rsi,%rax
mov    0x10(%rsp),%rbx
test   $0x1,%bl
je     1ac8 <modelhess+0x938>
mov    %eax,%ecx
imul   %r15d,%ecx
movslq %ecx,%rcx
add    %rax,%rcx
addsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
xorpd  %xmm1,%xmm1
mov    %r15d,%esi
mov    0x38(%rsp),%rdx
movsd  0x50(%rsp),%xmm0
mov    %rdi,%rbp
call   1050 <cholmod@plt>
test   %r15d,%r15d
movsd  %xmm0,0x20(%rsp)
jle    1ed1 <modelhess+0xd41>
lea    0x0(,%rbx,8),%rax
add    %r13,%rax
mov    %rax,0x8(%rsp)
mov    %ebx,%r9d
and    $0xfffffffc,%r9d
mov    %rbx,%r10
neg    %r10
lea    0x10(%rbp),%rsi
lea    0x0(,%rbx,8),%r11
mov    %r11,%r14
and    $0xffffffffffffffe0,%r14
lea    0x8(%rbp),%rax
xor    %ecx,%ecx
jmp    1b43 <modelhess+0x9b3>
nopl   0x0(%rax)
add    $0x1,%rcx
add    %r11,%rsi
add    %r11,%rax
cmp    %rbx,%rcx
je     1caf <modelhess+0xb1f>
mov    %rcx,%rdx
imul   %rbx,%rdx
cmp    $0x4,%r15d
jae    1bd0 <modelhess+0xa40>
xor    %edi,%edi
mov    %rdi,%rbp
test   $0x1,%bl
je     1b87 <modelhess+0x9f7>
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  0x0(%r13,%rdi,8),%xmm1
add    %rdi,%rdx
mov    0x28(%rsp),%rbp
mulsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
mov    %rdi,%rbp
or     $0x1,%rbp
not    %rdi
cmp    %r10,%rdi
je     1b30 <modelhess+0x9a0>
nop
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  0x0(%r13,%rbp,8),%xmm1
mulsd  -0x8(%rax,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%rax,%rbp,8)
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  0x8(%r13,%rbp,8),%xmm1
mulsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rbx
jne    1b90 <modelhess+0xa00>
jmp    1b30 <modelhess+0x9a0>
lea    (%rdx,%rbx,1),%rdi
mov    0x28(%rsp),%rbp
lea    0x0(,%rdx,8),%rbx
add    %rbp,%rbx
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
lea    0x8(,%rcx,8),%rbp
add    %r13,%rbp
lea    0x0(,%rcx,8),%r15
add    %r13,%r15
cmp    0x8(%rsp),%rbx
setb   %r12b
cmp    %r13,%rdi
seta   %r8b
cmp    %rbp,%rbx
setb   %bl
cmp    %rdi,%r15
setb   %bpl
test   %r8b,%r12b
jne    1c9e <modelhess+0xb0e>
mov    $0x0,%edi
and    %bpl,%bl
mov    0x10(%rsp),%rbx
mov    0x30(%rsp),%r15
jne    1b56 <modelhess+0x9c6>
movsd  0x0(%r13,%rcx,8),%xmm4
unpcklpd %xmm4,%xmm4
xor    %edi,%edi
nopl   0x0(%rax)
movupd 0x0(%r13,%rdi,1),%xmm1
movupd 0x10(%r13,%rdi,1),%xmm2
mulpd  %xmm4,%xmm1
mulpd  %xmm4,%xmm2
movupd -0x10(%rsi,%rdi,1),%xmm3
mulpd  %xmm1,%xmm3
movupd (%rsi,%rdi,1),%xmm1
mulpd  %xmm2,%xmm1
movupd %xmm3,-0x10(%rsi,%rdi,1)
movupd %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r14
jne    1c50 <modelhess+0xac0>
mov    %r9,%rdi
cmp    %rbx,%r9
je     1b30 <modelhess+0x9a0>
jmp    1b56 <modelhess+0x9c6>
xor    %edi,%edi
mov    0x10(%rsp),%rbx
mov    0x30(%rsp),%r15
jmp    1b56 <modelhess+0x9c6>
test   %r15d,%r15d
jle    1ed1 <modelhess+0xd41>
mov    0x38(%rsp),%rax
lea    0x8(%rax),%rcx
mov    %rcx,0x8(%rsp)
lea    0x8(,%rbx,8),%rcx
mov    %rcx,0x18(%rsp)
lea    0x30(%rax),%rdx
lea    0x0(,%rbx,8),%r10
mov    $0x1,%edi
mov    $0xfffffffffffffffd,%r15
xor    %r11d,%r11d
mov    0x38(%rsp),%r8
jmp    1d1c <modelhess+0xb8c>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
add    %r10,%rdx
add    $0x1,%r15
add    %r10,%rax
mov    0x10(%rsp),%rbx
cmp    %rbx,%r11
je     1ed1 <modelhess+0xd41>
mov    %r11,%rcx
lea    -0x3(%r11),%r14
add    $0x1,%r11
mov    %rcx,%r12
imul   %rbx,%r12
mov    %rcx,%rsi
sub    $0x3,%rsi
jb     1d74 <modelhess+0xbe4>
lea    0x8(,%rcx,8),%r9
add    %r13,%r9
mov    %rcx,%rbp
imul   %rbx,%rbp
lea    (%r8,%rbp,8),%rbp
cmp    %r9,%rbp
jae    1df0 <modelhess+0xc60>
lea    0x0(,%rcx,8),%rbx
add    %r13,%rbx
mov    0x18(%rsp),%rbp
imul   %rcx,%rbp
add    0x8(%rsp),%rbp
cmp    %rbx,%rbp
jbe    1df0 <modelhess+0xc60>
xor    %ebx,%ebx
mov    %rbx,%rsi
test   $0x1,%dil
je     1da1 <modelhess+0xc11>
movsd  0x0(%r13,%rcx,8),%xmm1
add    %rbx,%r12
mov    0x38(%rsp),%rsi
mulsd  (%rsi,%r12,8),%xmm1
movsd  %xmm1,(%rsi,%r12,8)
mov    %rbx,%rsi
or     $0x1,%rsi
cmp    %rbx,%rcx
je     1d00 <modelhess+0xb70>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  (%rax,%rsi,8),%xmm1
movsd  %xmm1,(%rax,%rsi,8)
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  0x8(%rax,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rax,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    1db0 <modelhess+0xc20>
jmp    1d00 <modelhess+0xb70>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
shr    $0x2,%r14
add    $0x1,%r14
cmp    $0x4,%rsi
jae    1e02 <modelhess+0xc72>
xor    %ebp,%ebp
jmp    1e68 <modelhess+0xcd8>
mov    %r15,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
movsd  0x0(%r13,%rcx,8),%xmm5
unpcklpd %xmm5,%xmm5
xor    %ebp,%ebp
xchg   %ax,%ax
movupd -0x30(%rdx,%rbp,8),%xmm1
movupd -0x20(%rdx,%rbp,8),%xmm2
movupd -0x10(%rdx,%rbp,8),%xmm3
movupd (%rdx,%rbp,8),%xmm4
mulpd  %xmm5,%xmm1
mulpd  %xmm5,%xmm2
movupd %xmm1,-0x30(%rdx,%rbp,8)
movupd %xmm2,-0x20(%rdx,%rbp,8)
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm4
movupd %xmm3,-0x10(%rdx,%rbp,8)
movupd %xmm4,(%rdx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1e20 <modelhess+0xc90>
mov    %r11,%rbx
and    $0xfffffffffffffffc,%rbx
test   $0x1,%r14b
je     1ea6 <modelhess+0xd16>
movsd  0x0(%r13,%rcx,8),%xmm3
unpcklpd %xmm3,%xmm3
add    %r12,%rbp
mov    0x38(%rsp),%rsi
movupd (%rsi,%rbp,8),%xmm1
movupd 0x10(%rsi,%rbp,8),%xmm2
mulpd  %xmm3,%xmm1
mulpd  %xmm3,%xmm2
movupd %xmm1,(%rsi,%rbp,8)
movupd %xmm2,0x10(%rsi,%rbp,8)
cmp    %rbx,%r11
je     1d00 <modelhess+0xb70>
jmp    1d76 <modelhess+0xbe6>
xorpd  %xmm1,%xmm1
mov    %r15d,%esi
mov    0x38(%rsp),%rdx
movsd  0x50(%rsp),%xmm0
call   1050 <cholmod@plt>
movsd  %xmm0,0x20(%rsp)
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
movsd  0x20(%rsp),%xmm0
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @modelhess(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 double*
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
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
%28 = load double, double* %9
%29 = call double @sqrt(double %28)
store double %29, double* %12
%30 = load i32, i32* %7
%31 = sext i32 %30 to i64
%32 = mul i64 8, %31
%33 = load i32, i32* %7
%34 = sext i32 %33 to i64
%35 = mul i64 %32, %34
%36 = trunc i64 %35 to i32
%37 = call i64 @malloc(i32 %36)
%38 = inttoptr i64 %37 to double*
store double* %38, double** %11
store i32 0, i32* %25
br label %39
39: ; preds = %75, %5
%40 = load i32, i32* %25
%41 = load i32, i32* %7
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %78
43: ; preds = %39
%44 = load i32, i32* %25
%45 = load i32, i32* %7
%46 = mul nsw i32 %44, %45
store i32 %46, i32* %24
store i32 0, i32* %26
br label %47
47: ; preds = %71, %43
%48 = load i32, i32* %26
%49 = load i32, i32* %7
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %74
51: ; preds = %47
%52 = load double*, double** %8
%53 = load i32, i32* %25
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = load double*, double** %8
%58 = load i32, i32* %26
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = fmul double %56, %61
%63 = load double*, double** %6
%64 = load i32, i32* %24
%65 = load i32, i32* %26
%66 = add nsw i32 %64, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %63, i64 %67
%69 = load double, double* %68
%70 = fdiv double %69, %62
store double %70, double* %68
br label %71
71: ; preds = %51
%72 = load i32, i32* %26
%73 = add nsw i32 %72, 1
store i32 %73, i32* %26
br label %47
74: ; preds = %47
br label %75
75: ; preds = %74
%76 = load i32, i32* %25
%77 = add nsw i32 %76, 1
store i32 %77, i32* %25
br label %39
78: ; preds = %39
store i32 0, i32* %25
br label %79
79: ; preds = %97, %78
%80 = load i32, i32* %25
%81 = load i32, i32* %7
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %100
83: ; preds = %79
%84 = load double*, double** %6
%85 = load i32, i32* %25
%86 = load i32, i32* %25
%87 = load i32, i32* %7
%88 = mul nsw i32 %86, %87
%89 = add nsw i32 %85, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %84, i64 %90
%92 = load double, double* %91
%93 = load double*, double** %11
%94 = load i32, i32* %25
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
store double %92, double* %96
br label %97
97: ; preds = %83
%98 = load i32, i32* %25
%99 = add nsw i32 %98, 1
store i32 %99, i32* %25
br label %79
100: ; preds = %79
%101 = load double*, double** %11
%102 = load i32, i32* %7
%103 = call double @array_max(double* %101, i32 %102)
store double %103, double* %13
%104 = load double*, double** %11
%105 = load i32, i32* %7
%106 = call double @array_min(double* %104, i32 %105)
store double %106, double* %14
store double 0.000000e+00, double* %15
%107 = load double, double* %13
%108 = load double, double* %15
%109 = fcmp ogt double %107, %108
br i1 %109, label %110, label %112
110: ; preds = %100
%111 = load double, double* %13
store double %111, double* %15
br label %112
112: ; preds = %110, %100
store i32 0, i32* %25
br label %113
113: ; preds = %122, %112
%114 = load i32, i32* %25
%115 = load i32, i32* %7
%116 = icmp slt i32 %114, %115
br i1 %116, label %117, label %125
117: ; preds = %113
%118 = load double*, double** %11
%119 = load i32, i32* %25
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
store double 0.000000e+00, double* %121
br label %122
122: ; preds = %117
%123 = load i32, i32* %25
%124 = add nsw i32 %123, 1
store i32 %124, i32* %25
br label %113
125: ; preds = %113
store double 0.000000e+00, double* %16
%126 = load double, double* %14
%127 = load double, double* %12
%128 = load double, double* %15
%129 = fmul double %127, %128
%130 = fcmp ole double %126, %129
br i1 %130, label %131, label %143
131: ; preds = %125
%132 = load double, double* %15
%133 = load double, double* %14
%134 = fsub double %132, %133
%135 = fmul double 2.000000e+00, %134
%136 = load double, double* %12
%137 = load double, double* %14
%138 = fneg double %137
%139 = call double @llvm.fmuladd.f64(double %135, double %136, double %138)
store double %139, double* %16
%140 = load double, double* %16
%141 = load double, double* %13
%142 = fadd double %141, %140
store double %142, double* %13
br label %143
143: ; preds = %131, %125
store i32 0, i32* %27
store i32 0, i32* %25
br label %144
144: ; preds = %178, %143
%145 = load i32, i32* %25
%146 = load i32, i32* %7
%147 = icmp slt i32 %145, %146
br i1 %147, label %148, label %181
148: ; preds = %144
store i32 0, i32* %26
br label %149
149: ; preds = %174, %148
%150 = load i32, i32* %26
%151 = load i32, i32* %7
%152 = icmp slt i32 %150, %151
br i1 %152, label %153, label %177
153: ; preds = %149
%154 = load i32, i32* %26
%155 = load i32, i32* %25
%156 = icmp sgt i32 %154, %155
br i1 %156, label %157, label %173
157: ; preds = %153
%158 = load double*, double** %6
%159 = load i32, i32* %25
%160 = load i32, i32* %7
%161 = mul nsw i32 %159, %160
%162 = load i32, i32* %26
%163 = add nsw i32 %161, %162
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %158, i64 %164
%166 = load double, double* %165
%167 = load double*, double** %11
%168 = load i32, i32* %27
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %167, i64 %169
store double %166, double* %170
%171 = load i32, i32* %27
%172 = add nsw i32 %171, 1
store i32 %172, i32* %27
br label %173
173: ; preds = %157, %153
br label %174
174: ; preds = %173
%175 = load i32, i32* %26
%176 = add nsw i32 %175, 1
store i32 %176, i32* %26
br label %149
177: ; preds = %149
br label %178
178: ; preds = %177
%179 = load i32, i32* %25
%180 = add nsw i32 %179, 1
store i32 %180, i32* %25
br label %144
181: ; preds = %144
%182 = load double*, double** %11
%183 = load i32, i32* %27
%184 = call double @array_max_abs(double* %182, i32 %183)
store double %184, double* %17
%185 = load double, double* %17
%186 = load double, double* %12
%187 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %186, double 1.000000e+00)
%188 = fmul double %185, %187
%189 = load double, double* %13
%190 = fcmp ogt double %188, %189
br i1 %190, label %191, label %205
191: ; preds = %181
%192 = load double, double* %17
%193 = load double, double* %13
%194 = fsub double %192, %193
%195 = load double, double* %12
%196 = fmul double 2.000000e+00, %195
%197 = load double, double* %17
%198 = call double @llvm.fmuladd.f64(double %196, double %197, double %194)
%199 = load double, double* %16
%200 = fadd double %199, %198
store double %200, double* %16
%201 = load double, double* %17
%202 = load double, double* %12
%203 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %202, double 1.000000e+00)
%204 = fmul double %201, %203
store double %204, double* %13
br label %205
205: ; preds = %191, %181
%206 = load double, double* %13
%207 = fcmp oeq double %206, 0.000000e+00
br i1 %207, label %208, label %209
208: ; preds = %205
store double 1.000000e+00, double* %16
store double 1.000000e+00, double* %13
br label %209
209: ; preds = %208, %205
%210 = load double, double* %16
%211 = fcmp ogt double %210, 0.000000e+00
br i1 %211, label %212, label %233
212: ; preds = %209
store i32 0, i32* %25
br label %213
213: ; preds = %229, %212
%214 = load i32, i32* %25
%215 = load i32, i32* %7
%216 = icmp slt i32 %214, %215
br i1 %216, label %217, label %232
217: ; preds = %213
%218 = load double, double* %16
%219 = load double*, double** %6
%220 = load i32, i32* %25
%221 = load i32, i32* %7
%222 = mul nsw i32 %220, %221
%223 = load i32, i32* %25
%224 = add nsw i32 %222, %223
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %219, i64 %225
%227 = load double, double* %226
%228 = fadd double %227, %218
store double %228, double* %226
br label %229
229: ; preds = %217
%230 = load i32, i32* %25
%231 = add nsw i32 %230, 1
store i32 %231, i32* %25
br label %213
232: ; preds = %213
br label %233
233: ; preds = %232, %209
%234 = load double, double* %13
%235 = load double, double* %17
%236 = load i32, i32* %7
%237 = sitofp i32 %236 to double
%238 = fdiv double %235, %237
%239 = fcmp ogt double %234, %238
br i1 %239, label %240, label %243
240: ; preds = %233
%241 = load double, double* %13
%242 = call double @sqrt(double %241)
store double %242, double* %18
br label %249
243: ; preds = %233
%244 = load double, double* %17
%245 = load i32, i32* %7
%246 = sitofp i32 %245 to double
%247 = fdiv double %244, %246
%248 = call double @sqrt(double %247)
store double %248, double* %18
br label %249
249: ; preds = %243, %240
%250 = load double*, double** %6
%251 = load i32, i32* %7
%252 = load double*, double** %10
%253 = load double, double* %9
%254 = load double, double* %18
%255 = call double @cholmod(double* %250, i32 %251, double* %252, double %253, double %254)
store double %255, double* %19
%256 = load double, double* %19
%257 = fcmp ogt double %256, 0.000000e+00
br i1 %257, label %258, label %399
258: ; preds = %249
%259 = load double*, double** %6
%260 = getelementptr inbounds double, double* %259, i64 0
%261 = load double, double* %260
store double %261, double* %21
store double %261, double* %20
store i32 0, i32* %25
br label %262
262: ; preds = %356, %258
%263 = load i32, i32* %25
%264 = load i32, i32* %7
%265 = icmp slt i32 %263, %264
br i1 %265, label %266, label %359
266: ; preds = %262
store double 0.000000e+00, double* %22
%267 = load i32, i32* %25
%268 = load i32, i32* %7
%269 = mul nsw i32 %267, %268
store i32 %269, i32* %24
store i32 0, i32* %26
br label %270
270: ; preds = %286, %266
%271 = load i32, i32* %26
%272 = load i32, i32* %25
%273 = icmp slt i32 %271, %272
br i1 %273, label %274, label %289
274: ; preds = %270
%275 = load double*, double** %6
%276 = load i32, i32* %24
%277 = load i32, i32* %26
%278 = add nsw i32 %276, %277
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %275, i64 %279
%281 = load double, double* %280
%282 = call i64 @fabs(double %281)
%283 = sitofp i64 %282 to double
%284 = load double, double* %22
%285 = fadd double %284, %283
store double %285, double* %22
br label %286
286: ; preds = %274
%287 = load i32, i32* %26
%288 = add nsw i32 %287, 1
store i32 %288, i32* %26
br label %270
289: ; preds = %270
%290 = load i32, i32* %25
%291 = add nsw i32 %290, 1
store i32 %291, i32* %26
br label %292
292: ; preds = %308, %289
%293 = load i32, i32* %26
%294 = load i32, i32* %7
%295 = icmp slt i32 %293, %294
br i1 %295, label %296, label %311
296: ; preds = %292
%297 = load double*, double** %6
%298 = load i32, i32* %24
%299 = load i32, i32* %26
%300 = add nsw i32 %298, %299
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds double, double* %297, i64 %301
%303 = load double, double* %302
%304 = call i64 @fabs(double %303)
%305 = sitofp i64 %304 to double
%306 = load double, double* %22
%307 = fadd double %306, %305
store double %307, double* %22
br label %308
308: ; preds = %296
%309 = load i32, i32* %26
%310 = add nsw i32 %309, 1
store i32 %310, i32* %26
br label %292
311: ; preds = %292
%312 = load double, double* %20
%313 = load double*, double** %6
%314 = load i32, i32* %24
%315 = load i32, i32* %25
%316 = add nsw i32 %314, %315
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %313, i64 %317
%319 = load double, double* %318
%320 = load double, double* %22
%321 = fadd double %319, %320
%322 = fcmp olt double %312, %321
br i1 %322, label %323, label %333
323: ; preds = %311
%324 = load double*, double** %6
%325 = load i32, i32* %24
%326 = load i32, i32* %25
%327 = add nsw i32 %325, %326
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %324, i64 %328
%330 = load double, double* %329
%331 = load double, double* %22
%332 = fadd double %330, %331
store double %332, double* %20
br label %333
333: ; preds = %323, %311
%334 = load double, double* %21
%335 = load double*, double** %6
%336 = load i32, i32* %24
%337 = load i32, i32* %25
%338 = add nsw i32 %336, %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %335, i64 %339
%341 = load double, double* %340
%342 = load double, double* %22
%343 = fsub double %341, %342
%344 = fcmp ogt double %334, %343
br i1 %344, label %345, label %355
345: ; preds = %333
%346 = load double*, double** %6
%347 = load i32, i32* %24
%348 = load i32, i32* %25
%349 = add nsw i32 %347, %348
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double, double* %346, i64 %350
%352 = load double, double* %351
%353 = load double, double* %22
%354 = fsub double %352, %353
store double %354, double* %21
br label %355
355: ; preds = %345, %333
br label %356
356: ; preds = %355
%357 = load i32, i32* %25
%358 = add nsw i32 %357, 1
store i32 %358, i32* %25
br label %262
359: ; preds = %262
%360 = load double, double* %20
%361 = load double, double* %21
%362 = fsub double %360, %361
%363 = load double, double* %12
%364 = load double, double* %21
%365 = fneg double %364
%366 = call double @llvm.fmuladd.f64(double %362, double %363, double %365)
store double %366, double* %23
%367 = load double, double* %23
%368 = fcmp olt double %367, 0.000000e+00
br i1 %368, label %369, label %370
369: ; preds = %359
store double 0.000000e+00, double* %23
br label %370
370: ; preds = %369, %359
%371 = load double, double* %19
%372 = load double, double* %23
%373 = fcmp ogt double %371, %372
br i1 %373, label %374, label %376
374: ; preds = %370
%375 = load double, double* %23
store double %375, double* %16
br label %378
376: ; preds = %370
%377 = load double, double* %19
store double %377, double* %16
br label %378
378: ; preds = %376, %374
store i32 0, i32* %25
br label %379
379: ; preds = %395, %378
%380 = load i32, i32* %25
%381 = load i32, i32* %7
%382 = icmp slt i32 %380, %381
br i1 %382, label %383, label %398
383: ; preds = %379
%384 = load double, double* %16
%385 = load double*, double** %6
%386 = load i32, i32* %25
%387 = load i32, i32* %7
%388 = mul nsw i32 %386, %387
%389 = load i32, i32* %25
%390 = add nsw i32 %388, %389
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double, double* %385, i64 %391
%393 = load double, double* %392
%394 = fadd double %393, %384
store double %394, double* %392
br label %395
395: ; preds = %383
%396 = load i32, i32* %25
%397 = add nsw i32 %396, 1
store i32 %397, i32* %25
br label %379
398: ; preds = %379
br label %399
399: ; preds = %398, %249
%400 = load double*, double** %6
%401 = load i32, i32* %7
%402 = load double*, double** %10
%403 = load double, double* %9
%404 = call double @cholmod(double* %400, i32 %401, double* %402, double %403, double 0.000000e+00)
store double %404, double* %19
store i32 0, i32* %25
br label %405
405: ; preds = %441, %399
%406 = load i32, i32* %25
%407 = load i32, i32* %7
%408 = icmp slt i32 %406, %407
br i1 %408, label %409, label %444
409: ; preds = %405
%410 = load i32, i32* %25
%411 = load i32, i32* %7
%412 = mul nsw i32 %410, %411
store i32 %412, i32* %24
store i32 0, i32* %26
br label %413
413: ; preds = %437, %409
%414 = load i32, i32* %26
%415 = load i32, i32* %7
%416 = icmp slt i32 %414, %415
br i1 %416, label %417, label %440
417: ; preds = %413
%418 = load double*, double** %8
%419 = load i32, i32* %25
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds double, double* %418, i64 %420
%422 = load double, double* %421
%423 = load double*, double** %8
%424 = load i32, i32* %26
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double, double* %423, i64 %425
%427 = load double, double* %426
%428 = fmul double %422, %427
%429 = load double*, double** %6
%430 = load i32, i32* %24
%431 = load i32, i32* %26
%432 = add nsw i32 %430, %431
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %429, i64 %433
%435 = load double, double* %434
%436 = fmul double %435, %428
store double %436, double* %434
br label %437
437: ; preds = %417
%438 = load i32, i32* %26
%439 = add nsw i32 %438, 1
store i32 %439, i32* %26
br label %413
440: ; preds = %413
br label %441
441: ; preds = %440
%442 = load i32, i32* %25
%443 = add nsw i32 %442, 1
store i32 %443, i32* %25
br label %405
444: ; preds = %405
store i32 0, i32* %25
br label %445
445: ; preds = %476, %444
%446 = load i32, i32* %25
%447 = load i32, i32* %7
%448 = icmp slt i32 %446, %447
br i1 %448, label %449, label %479
449: ; preds = %445
%450 = load i32, i32* %25
%451 = load i32, i32* %7
%452 = mul nsw i32 %450, %451
store i32 %452, i32* %24
store i32 0, i32* %26
br label %453
453: ; preds = %472, %449
%454 = load i32, i32* %26
%455 = load i32, i32* %25
%456 = add nsw i32 %455, 1
%457 = icmp slt i32 %454, %456
br i1 %457, label %458, label %475
458: ; preds = %453
%459 = load double*, double** %8
%460 = load i32, i32* %25
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %459, i64 %461
%463 = load double, double* %462
%464 = load double*, double** %10
%465 = load i32, i32* %24
%466 = load i32, i32* %26
%467 = add nsw i32 %465, %466
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds double, double* %464, i64 %468
%470 = load double, double* %469
%471 = fmul double %470, %463
store double %471, double* %469
br label %472
472: ; preds = %458
%473 = load i32, i32* %26
%474 = add nsw i32 %473, 1
store i32 %474, i32* %26
br label %453
475: ; preds = %453
br label %476
476: ; preds = %475
%477 = load i32, i32* %25
%478 = add nsw i32 %477, 1
store i32 %478, i32* %25
br label %445
479: ; preds = %445
%480 = load double*, double** %11
%481 = call i32 @free(double* %480)
%482 = load double, double* %19
ret double %482
}

LLVM IR (-O2):
define double @modelhess(double* %0, i32 %1, double* nocapture %2, double %3, double* %4) {
%6 = tail call double @sqrt(double %3)
%7 = shl i32 %1, 3
%8 = mul i32 %7, %1
%9 = tail call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to double*
%11 = inttoptr i64 %9 to i8*
%12 = icmp sgt i32 %1, 0
br i1 %12, label %13, label %179
13: ; preds = %5
%14 = zext i32 %1 to i64
%15 = zext i32 %1 to i64
%16 = getelementptr double, double* %2, i64 %15
%17 = and i64 %15, 4294967294
%18 = add nsw i64 %17, -2
%19 = lshr exact i64 %18, 1
%20 = add nuw i64 %19, 1
%21 = add nsw i64 %15, -1
%22 = icmp ult i32 %1, 2
%23 = and i64 %15, 4294967294
%24 = and i64 %20, 1
%25 = icmp eq i64 %18, 0
%26 = and i64 %20, -2
%27 = icmp eq i64 %24, 0
%28 = icmp eq i64 %23, %15
%29 = and i64 %15, 1
%30 = icmp eq i64 %29, 0
br label %37
31: ; preds = %144
br i1 %12, label %32, label %179
32: ; preds = %31
%33 = and i64 %15, 1
%34 = icmp eq i64 %21, 0
br i1 %34, label %168, label %35
35: ; preds = %32
%36 = and i64 %15, 4294967294
br label %147
37: ; preds = %144, %13
%38 = phi i64 [ 0, %13 ], [ %145, %144 ]
%39 = mul i64 %38, %15
%40 = getelementptr double, double* %0, i64 %39
%41 = add i64 %39, %15
%42 = getelementptr double, double* %0, i64 %41
%43 = mul nsw i64 %38, %14
%44 = getelementptr inbounds double, double* %2, i64 %38
br i1 %22, label %108, label %45
45: ; preds = %37
%46 = add nuw i64 %38, 1
%47 = getelementptr double, double* %2, i64 %46
%48 = getelementptr double, double* %2, i64 %38
%49 = icmp ult double* %40, %16
%50 = icmp ugt double* %42, %2
%51 = and i1 %49, %50
%52 = icmp ult double* %40, %47
%53 = icmp ult double* %48, %42
%54 = and i1 %52, %53
%55 = or i1 %51, %54
br i1 %55, label %108, label %56
56: ; preds = %45
br i1 %25, label %91, label %57
57: ; preds = %56
%58 = load double, double* %44
%59 = insertelement <2 x double> poison, double %58, i64 0
%60 = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> zeroinitializer
%61 = load double, double* %44
%62 = insertelement <2 x double> poison, double %61, i64 0
%63 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> zeroinitializer
br label %64
64: ; preds = %64, %57
%65 = phi i64 [ 0, %57 ], [ %88, %64 ]
%66 = phi i64 [ 0, %57 ], [ %89, %64 ]
%67 = getelementptr inbounds double, double* %2, i64 %65
%68 = bitcast double* %67 to <2 x double>*
%69 = load <2 x double>, <2 x double>* %68
%70 = fmul <2 x double> %60, %69
%71 = add nuw nsw i64 %65, %43
%72 = getelementptr inbounds double, double* %0, i64 %71
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = fdiv <2 x double> %74, %70
%76 = bitcast double* %72 to <2 x double>*
store <2 x double> %75, <2 x double>* %76
%77 = or i64 %65, 2
%78 = getelementptr inbounds double, double* %2, i64 %77
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = fmul <2 x double> %63, %80
%82 = add nuw nsw i64 %77, %43
%83 = getelementptr inbounds double, double* %0, i64 %82
%84 = bitcast double* %83 to <2 x double>*
%85 = load <2 x double>, <2 x double>* %84
%86 = fdiv <2 x double> %85, %81
%87 = bitcast double* %83 to <2 x double>*
store <2 x double> %86, <2 x double>* %87
%88 = add nuw i64 %65, 4
%89 = add nuw i64 %66, 2
%90 = icmp eq i64 %89, %26
br i1 %90, label %91, label %64
91: ; preds = %64, %56
%92 = phi i64 [ 0, %56 ], [ %88, %64 ]
br i1 %27, label %107, label %93
93: ; preds = %91
%94 = load double, double* %44
%95 = insertelement <2 x double> poison, double %94, i64 0
%96 = shufflevector <2 x double> %95, <2 x double> poison, <2 x i32> zeroinitializer
%97 = getelementptr inbounds double, double* %2, i64 %92
%98 = bitcast double* %97 to <2 x double>*
%99 = load <2 x double>, <2 x double>* %98
%100 = fmul <2 x double> %96, %99
%101 = add nuw nsw i64 %92, %43
%102 = getelementptr inbounds double, double* %0, i64 %101
%103 = bitcast double* %102 to <2 x double>*
%104 = load <2 x double>, <2 x double>* %103
%105 = fdiv <2 x double> %104, %100
%106 = bitcast double* %102 to <2 x double>*
store <2 x double> %105, <2 x double>* %106
br label %107
107: ; preds = %91, %93
br i1 %28, label %144, label %108
108: ; preds = %45, %37, %107
%109 = phi i64 [ 0, %45 ], [ 0, %37 ], [ %23, %107 ]
br i1 %30, label %120, label %110
110: ; preds = %108
%111 = load double, double* %44
%112 = getelementptr inbounds double, double* %2, i64 %109
%113 = load double, double* %112
%114 = fmul double %111, %113
%115 = add nuw nsw i64 %109, %43
%116 = getelementptr inbounds double, double* %0, i64 %115
%117 = load double, double* %116
%118 = fdiv double %117, %114
store double %118, double* %116
%119 = or i64 %109, 1
br label %120
120: ; preds = %110, %108
%121 = phi i64 [ %109, %108 ], [ %119, %110 ]
%122 = icmp eq i64 %21, %109
br i1 %122, label %144, label %123
123: ; preds = %120, %123
%124 = phi i64 [ %142, %123 ], [ %121, %120 ]
%125 = load double, double* %44
%126 = getelementptr inbounds double, double* %2, i64 %124
%127 = load double, double* %126
%128 = fmul double %125, %127
%129 = add nuw nsw i64 %124, %43
%130 = getelementptr inbounds double, double* %0, i64 %129
%131 = load double, double* %130
%132 = fdiv double %131, %128
store double %132, double* %130
%133 = add nuw nsw i64 %124, 1
%134 = load double, double* %44
%135 = getelementptr inbounds double, double* %2, i64 %133
%136 = load double, double* %135
%137 = fmul double %134, %136
%138 = add nuw nsw i64 %133, %43
%139 = getelementptr inbounds double, double* %0, i64 %138
%140 = load double, double* %139
%141 = fdiv double %140, %137
store double %141, double* %139
%142 = add nuw nsw i64 %124, 2
%143 = icmp eq i64 %142, %15
br i1 %143, label %144, label %123
144: ; preds = %120, %123, %107
%145 = add nuw nsw i64 %38, 1
%146 = icmp eq i64 %145, %15
br i1 %146, label %31, label %37
147: ; preds = %147, %35
%148 = phi i64 [ 0, %35 ], [ %165, %147 ]
%149 = phi i64 [ 0, %35 ], [ %166, %147 ]
%150 = trunc i64 %148 to i32
%151 = mul nsw i32 %150, %1
%152 = sext i32 %151 to i64
%153 = add nsw i64 %148, %152
%154 = getelementptr inbounds double, double* %0, i64 %153
%155 = load double, double* %154
%156 = getelementptr inbounds double, double* %10, i64 %148
store double %155, double* %156
%157 = or i64 %148, 1
%158 = trunc i64 %157 to i32
%159 = mul nsw i32 %158, %1
%160 = sext i32 %159 to i64
%161 = add nsw i64 %157, %160
%162 = getelementptr inbounds double, double* %0, i64 %161
%163 = load double, double* %162
%164 = getelementptr inbounds double, double* %10, i64 %157
store double %163, double* %164
%165 = add nuw nsw i64 %148, 2
%166 = add i64 %149, 2
%167 = icmp eq i64 %166, %36
br i1 %167, label %168, label %147
168: ; preds = %147, %32
%169 = phi i64 [ 0, %32 ], [ %165, %147 ]
%170 = icmp eq i64 %33, 0
br i1 %170, label %179, label %171
171: ; preds = %168
%172 = trunc i64 %169 to i32
%173 = mul nsw i32 %172, %1
%174 = sext i32 %173 to i64
%175 = add nsw i64 %169, %174
%176 = getelementptr inbounds double, double* %0, i64 %175
%177 = load double, double* %176
%178 = getelementptr inbounds double, double* %10, i64 %169
store double %177, double* %178
br label %179
179: ; preds = %171, %168, %5, %31
%180 = tail call double @array_max(double* %10, i32 %1)
%181 = tail call double @array_min(double* %10, i32 %1)
%182 = fcmp ogt double %180, 0.000000e+00
%183 = select i1 %182, double %180, double 0.000000e+00
br i1 %12, label %184, label %187
184: ; preds = %179
%185 = zext i32 %1 to i64
%186 = shl nuw nsw i64 %185, 3
br label %187
187: ; preds = %184, %179
%188 = fmul double %6, %183
%189 = fcmp ugt double %181, %188
br i1 %189, label %196, label %190
190: ; preds = %187
%191 = fsub double %183, %181
%192 = fmul double %191, 2.000000e+00
%193 = fneg double %181
%194 = tail call double @llvm.fmuladd.f64(double %192, double %6, double %193)
%195 = fadd double %180, %194
br label %196
196: ; preds = %190, %187
%197 = phi double [ %194, %190 ], [ 0.000000e+00, %187 ]
%198 = phi double [ %195, %190 ], [ %180, %187 ]
br i1 %12, label %199, label %255
199: ; preds = %196
%200 = zext i32 %1 to i64
%201 = zext i32 %1 to i64
%202 = and i64 %201, 1
%203 = icmp eq i32 %1, 1
%204 = and i64 %201, 4294967294
%205 = icmp eq i64 %202, 0
br label %206
206: ; preds = %251, %199
%207 = phi i64 [ 0, %199 ], [ %253, %251 ]
%208 = phi i32 [ 0, %199 ], [ %252, %251 ]
%209 = mul nsw i64 %207, %200
br i1 %203, label %238, label %210
210: ; preds = %206, %233
%211 = phi i64 [ %235, %233 ], [ 0, %206 ]
%212 = phi i32 [ %234, %233 ], [ %208, %206 ]
%213 = phi i64 [ %236, %233 ], [ 0, %206 ]
%214 = icmp ugt i64 %211, %207
br i1 %214, label %215, label %222
215: ; preds = %210
%216 = add nuw nsw i64 %211, %209
%217 = getelementptr inbounds double, double* %0, i64 %216
%218 = load double, double* %217
%219 = sext i32 %212 to i64
%220 = getelementptr inbounds double, double* %10, i64 %219
store double %218, double* %220
%221 = add nsw i32 %212, 1
br label %222
222: ; preds = %210, %215
%223 = phi i32 [ %221, %215 ], [ %212, %210 ]
%224 = icmp ult i64 %211, %207
br i1 %224, label %233, label %225
225: ; preds = %222
%226 = or i64 %211, 1
%227 = add nuw nsw i64 %226, %209
%228 = getelementptr inbounds double, double* %0, i64 %227
%229 = load double, double* %228
%230 = sext i32 %223 to i64
%231 = getelementptr inbounds double, double* %10, i64 %230
store double %229, double* %231
%232 = add nsw i32 %223, 1
br label %233
233: ; preds = %225, %222
%234 = phi i32 [ %232, %225 ], [ %223, %222 ]
%235 = add nuw nsw i64 %211, 2
%236 = add i64 %213, 2
%237 = icmp eq i64 %236, %204
br i1 %237, label %238, label %210
238: ; preds = %233, %206
%239 = phi i32 [ undef, %206 ], [ %234, %233 ]
%240 = phi i64 [ 0, %206 ], [ %235, %233 ]
%241 = phi i32 [ %208, %206 ], [ %234, %233 ]
br i1 %205, label %251, label %242
242: ; preds = %238
%243 = icmp ugt i64 %240, %207
br i1 %243, label %244, label %251
244: ; preds = %242
%245 = add nuw nsw i64 %240, %209
%246 = getelementptr inbounds double, double* %0, i64 %245
%247 = load double, double* %246
%248 = sext i32 %241 to i64
%249 = getelementptr inbounds double, double* %10, i64 %248
store double %247, double* %249
%250 = add nsw i32 %241, 1
br label %251
251: ; preds = %242, %244, %238
%252 = phi i32 [ %239, %238 ], [ %250, %244 ], [ %241, %242 ]
%253 = add nuw nsw i64 %207, 1
%254 = icmp eq i64 %253, %201
br i1 %254, label %255, label %206
255: ; preds = %251, %196
%256 = phi i32 [ 0, %196 ], [ %252, %251 ]
%257 = tail call double @array_max_abs(double* %10, i32 %256)
%258 = tail call double @llvm.fmuladd.f64(double %6, double 2.000000e+00, double 1.000000e+00)
%259 = fmul double %258, %257
%260 = fcmp ogt double %259, %198
br i1 %260, label %261, label %266
261: ; preds = %255
%262 = fsub double %257, %198
%263 = fmul double %6, 2.000000e+00
%264 = tail call double @llvm.fmuladd.f64(double %263, double %257, double %262)
%265 = fadd double %197, %264
br label %266
266: ; preds = %261, %255
%267 = phi double [ %265, %261 ], [ %197, %255 ]
%268 = phi double [ %259, %261 ], [ %198, %255 ]
%269 = fcmp oeq double %268, 0.000000e+00
%270 = select i1 %269, double 1.000000e+00, double %267
%271 = select i1 %269, double 1.000000e+00, double %268
%272 = fcmp ogt double %270, 0.000000e+00
%273 = and i1 %272, %12
br i1 %273, label %274, label %312
274: ; preds = %266
%275 = zext i32 %1 to i64
%276 = and i64 %275, 1
%277 = icmp eq i32 %1, 1
br i1 %277, label %301, label %278
278: ; preds = %274
%279 = and i64 %275, 4294967294
br label %280
280: ; preds = %280, %278
%281 = phi i64 [ 0, %278 ], [ %298, %280 ]
%282 = phi i64 [ 0, %278 ], [ %299, %280 ]
%283 = trunc i64 %281 to i32
%284 = mul nsw i32 %283, %1
%285 = sext i32 %284 to i64
%286 = add nsw i64 %281, %285
%287 = getelementptr inbounds double, double* %0, i64 %286
%288 = load double, double* %287
%289 = fadd double %270, %288
store double %289, double* %287
%290 = or i64 %281, 1
%291 = trunc i64 %290 to i32
%292 = mul nsw i32 %291, %1
%293 = sext i32 %292 to i64
%294 = add nsw i64 %290, %293
%295 = getelementptr inbounds double, double* %0, i64 %294
%296 = load double, double* %295
%297 = fadd double %270, %296
store double %297, double* %295
%298 = add nuw nsw i64 %281, 2
%299 = add i64 %282, 2
%300 = icmp eq i64 %299, %279
br i1 %300, label %301, label %280
301: ; preds = %280, %274
%302 = phi i64 [ 0, %274 ], [ %298, %280 ]
%303 = icmp eq i64 %276, 0
br i1 %303, label %312, label %304
304: ; preds = %301
%305 = trunc i64 %302 to i32
%306 = mul nsw i32 %305, %1
%307 = sext i32 %306 to i64
%308 = add nsw i64 %302, %307
%309 = getelementptr inbounds double, double* %0, i64 %308
%310 = load double, double* %309
%311 = fadd double %270, %310
store double %311, double* %309
br label %312
312: ; preds = %304, %301, %266
%313 = sitofp i32 %1 to double
%314 = fdiv double %257, %313
%315 = fcmp ogt double %271, %314
%316 = select i1 %315, double %271, double %314
%317 = tail call double @sqrt(double %316)
%318 = tail call double @cholmod(double* %0, i32 %1, double* %4, double %3, double %317)
%319 = fcmp ogt double %318, 0.000000e+00
br i1 %319, label %320, label %471
320: ; preds = %312
%321 = load double, double* %0
br i1 %12, label %322, label %421
322: ; preds = %320
%323 = zext i32 %1 to i64
%324 = zext i32 %1 to i64
br label %325
325: ; preds = %322, %407
%326 = phi i64 [ 0, %322 ], [ %394, %407 ]
%327 = phi i64 [ 1, %322 ], [ %419, %407 ]
%328 = phi double [ %321, %322 ], [ %418, %407 ]
%329 = phi double [ %321, %322 ], [ %415, %407 ]
%330 = trunc i64 %326 to i32
%331 = mul nsw i64 %326, %323
%332 = mul nsw i32 %330, %1
%333 = icmp eq i64 %326, 0
br i1 %333, label %392, label %334
334: ; preds = %325
%335 = add nsw i64 %326, -1
%336 = and i64 %326, 3
%337 = icmp ult i64 %335, 3
br i1 %337, label %374, label %338
338: ; preds = %334
%339 = and i64 %326, 9223372036854775804
br label %340
340: ; preds = %340, %338
%341 = phi i64 [ 0, %338 ], [ %371, %340 ]
%342 = phi double [ 0.000000e+00, %338 ], [ %370, %340 ]
%343 = phi i64 [ 0, %338 ], [ %372, %340 ]
%344 = add nuw nsw i64 %341, %331
%345 = getelementptr inbounds double, double* %0, i64 %344
%346 = load double, double* %345
%347 = tail call i64 @fabs(double %346)
%348 = sitofp i64 %347 to double
%349 = fadd double %342, %348
%350 = or i64 %341, 1
%351 = add nuw nsw i64 %350, %331
%352 = getelementptr inbounds double, double* %0, i64 %351
%353 = load double, double* %352
%354 = tail call i64 @fabs(double %353)
%355 = sitofp i64 %354 to double
%356 = fadd double %349, %355
%357 = or i64 %341, 2
%358 = add nuw nsw i64 %357, %331
%359 = getelementptr inbounds double, double* %0, i64 %358
%360 = load double, double* %359
%361 = tail call i64 @fabs(double %360)
%362 = sitofp i64 %361 to double
%363 = fadd double %356, %362
%364 = or i64 %341, 3
%365 = add nuw nsw i64 %364, %331
%366 = getelementptr inbounds double, double* %0, i64 %365
%367 = load double, double* %366
%368 = tail call i64 @fabs(double %367)
%369 = sitofp i64 %368 to double
%370 = fadd double %363, %369
%371 = add nuw nsw i64 %341, 4
%372 = add i64 %343, 4
%373 = icmp eq i64 %372, %339
br i1 %373, label %374, label %340
374: ; preds = %340, %334
%375 = phi double [ undef, %334 ], [ %370, %340 ]
%376 = phi i64 [ 0, %334 ], [ %371, %340 ]
%377 = phi double [ 0.000000e+00, %334 ], [ %370, %340 ]
%378 = icmp eq i64 %336, 0
br i1 %378, label %392, label %379
379: ; preds = %374, %379
%380 = phi i64 [ %389, %379 ], [ %376, %374 ]
%381 = phi double [ %388, %379 ], [ %377, %374 ]
%382 = phi i64 [ %390, %379 ], [ 0, %374 ]
%383 = add nuw nsw i64 %380, %331
%384 = getelementptr inbounds double, double* %0, i64 %383
%385 = load double, double* %384
%386 = tail call i64 @fabs(double %385)
%387 = sitofp i64 %386 to double
%388 = fadd double %381, %387
%389 = add nuw nsw i64 %380, 1
%390 = add i64 %382, 1
%391 = icmp eq i64 %390, %336
br i1 %391, label %392, label %379
392: ; preds = %374, %379, %325
%393 = phi double [ 0.000000e+00, %325 ], [ %375, %374 ], [ %388, %379 ]
%394 = add nuw nsw i64 %326, 1
%395 = icmp ult i64 %394, %323
br i1 %395, label %396, label %407
396: ; preds = %392, %396
%397 = phi i64 [ %405, %396 ], [ %327, %392 ]
%398 = phi double [ %404, %396 ], [ %393, %392 ]
%399 = add nuw nsw i64 %397, %331
%400 = getelementptr inbounds double, double* %0, i64 %399
%401 = load double, double* %400
%402 = tail call i64 @fabs(double %401)
%403 = sitofp i64 %402 to double
%404 = fadd double %398, %403
%405 = add nuw nsw i64 %397, 1
%406 = icmp eq i64 %405, %324
br i1 %406, label %407, label %396
407: ; preds = %396, %392
%408 = phi double [ %393, %392 ], [ %404, %396 ]
%409 = sext i32 %332 to i64
%410 = add nsw i64 %326, %409
%411 = getelementptr inbounds double, double* %0, i64 %410
%412 = load double, double* %411
%413 = fadd double %408, %412
%414 = fcmp olt double %329, %413
%415 = select i1 %414, double %413, double %329
%416 = fsub double %412, %408
%417 = fcmp ogt double %328, %416
%418 = select i1 %417, double %416, double %328
%419 = add nuw nsw i64 %327, 1
%420 = icmp eq i64 %394, %324
br i1 %420, label %421, label %325
421: ; preds = %407, %320
%422 = phi double [ %321, %320 ], [ %415, %407 ]
%423 = phi double [ %321, %320 ], [ %418, %407 ]
%424 = fsub double %422, %423
%425 = fneg double %423
%426 = tail call double @llvm.fmuladd.f64(double %424, double %6, double %425)
%427 = fcmp olt double %426, 0.000000e+00
%428 = select i1 %427, double 0.000000e+00, double %426
%429 = fcmp ogt double %318, %428
%430 = select i1 %429, double %428, double %318
br i1 %12, label %433, label %431
431: ; preds = %421
%432 = tail call double @cholmod(double* %0, i32 %1, double* %4, double %3, double 0.000000e+00)
br label %702
433: ; preds = %421
%434 = zext i32 %1 to i64
%435 = and i64 %434, 1
%436 = icmp eq i32 %1, 1
br i1 %436, label %460, label %437
437: ; preds = %433
%438 = and i64 %434, 4294967294
br label %439
439: ; preds = %439, %437
%440 = phi i64 [ 0, %437 ], [ %457, %439 ]
%441 = phi i64 [ 0, %437 ], [ %458, %439 ]
%442 = trunc i64 %440 to i32
%443 = mul nsw i32 %442, %1
%444 = sext i32 %443 to i64
%445 = add nsw i64 %440, %444
%446 = getelementptr inbounds double, double* %0, i64 %445
%447 = load double, double* %446
%448 = fadd double %430, %447
store double %448, double* %446
%449 = or i64 %440, 1
%450 = trunc i64 %449 to i32
%451 = mul nsw i32 %450, %1
%452 = sext i32 %451 to i64
%453 = add nsw i64 %449, %452
%454 = getelementptr inbounds double, double* %0, i64 %453
%455 = load double, double* %454
%456 = fadd double %430, %455
store double %456, double* %454
%457 = add nuw nsw i64 %440, 2
%458 = add i64 %441, 2
%459 = icmp eq i64 %458, %438
br i1 %459, label %460, label %439
460: ; preds = %439, %433
%461 = phi i64 [ 0, %433 ], [ %457, %439 ]
%462 = icmp eq i64 %435, 0
br i1 %462, label %471, label %463
463: ; preds = %460
%464 = trunc i64 %461 to i32
%465 = mul nsw i32 %464, %1
%466 = sext i32 %465 to i64
%467 = add nsw i64 %461, %466
%468 = getelementptr inbounds double, double* %0, i64 %467
%469 = load double, double* %468
%470 = fadd double %430, %469
store double %470, double* %468
br label %471
471: ; preds = %463, %460, %312
%472 = tail call double @cholmod(double* %0, i32 %1, double* %4, double %3, double 0.000000e+00)
br i1 %12, label %473, label %702
473: ; preds = %471
%474 = zext i32 %1 to i64
%475 = zext i32 %1 to i64
%476 = getelementptr double, double* %2, i64 %475
%477 = icmp ult i32 %1, 4
%478 = and i64 %475, 4294967292
%479 = icmp eq i64 %478, %475
%480 = and i64 %475, 1
%481 = icmp eq i64 %480, 0
%482 = sub nsw i64 0, %475
br label %491
483: ; preds = %577
br i1 %12, label %484, label %702
484: ; preds = %483
%485 = zext i32 %1 to i64
%486 = zext i32 %1 to i64
%487 = getelementptr double, double* %4, i64 1
%488 = bitcast double* %487 to i8*
%489 = shl nuw nsw i64 %475, 3
%490 = add nuw nsw i64 %489, 8
br label %580
491: ; preds = %577, %473
%492 = phi i64 [ 0, %473 ], [ %578, %577 ]
%493 = mul i64 %492, %475
%494 = getelementptr double, double* %0, i64 %493
%495 = add i64 %493, %475
%496 = getelementptr double, double* %0, i64 %495
%497 = mul nsw i64 %492, %474
%498 = getelementptr inbounds double, double* %2, i64 %492
br i1 %477, label %540, label %499
499: ; preds = %491
%500 = add nuw i64 %492, 1
%501 = getelementptr double, double* %2, i64 %500
%502 = getelementptr double, double* %2, i64 %492
%503 = icmp ult double* %494, %476
%504 = icmp ugt double* %496, %2
%505 = and i1 %503, %504
%506 = icmp ult double* %494, %501
%507 = icmp ult double* %502, %496
%508 = and i1 %506, %507
%509 = or i1 %505, %508
br i1 %509, label %540, label %510
510: ; preds = %499
%511 = load double, double* %498
%512 = insertelement <2 x double> poison, double %511, i64 0
%513 = shufflevector <2 x double> %512, <2 x double> poison, <2 x i32> zeroinitializer
%514 = insertelement <2 x double> poison, double %511, i64 0
%515 = shufflevector <2 x double> %514, <2 x double> poison, <2 x i32> zeroinitializer
br label %516
516: ; preds = %516, %510
%517 = phi i64 [ 0, %510 ], [ %537, %516 ]
%518 = getelementptr inbounds double, double* %2, i64 %517
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = getelementptr inbounds double, double* %518, i64 2
%522 = bitcast double* %521 to <2 x double>*
%523 = load <2 x double>, <2 x double>* %522
%524 = fmul <2 x double> %513, %520
%525 = fmul <2 x double> %515, %523
%526 = add nuw nsw i64 %517, %497
%527 = getelementptr inbounds double, double* %0, i64 %526
%528 = bitcast double* %527 to <2 x double>*
%529 = load <2 x double>, <2 x double>* %528
%530 = getelementptr inbounds double, double* %527, i64 2
%531 = bitcast double* %530 to <2 x double>*
%532 = load <2 x double>, <2 x double>* %531
%533 = fmul <2 x double> %529, %524
%534 = fmul <2 x double> %532, %525
%535 = bitcast double* %527 to <2 x double>*
store <2 x double> %533, <2 x double>* %535
%536 = bitcast double* %530 to <2 x double>*
store <2 x double> %534, <2 x double>* %536
%537 = add nuw i64 %517, 4
%538 = icmp eq i64 %537, %478
br i1 %538, label %539, label %516
539: ; preds = %516
br i1 %479, label %577, label %540
540: ; preds = %499, %491, %539
%541 = phi i64 [ 0, %499 ], [ 0, %491 ], [ %478, %539 ]
%542 = xor i64 %541, -1
br i1 %481, label %553, label %543
543: ; preds = %540
%544 = load double, double* %498
%545 = getelementptr inbounds double, double* %2, i64 %541
%546 = load double, double* %545
%547 = fmul double %544, %546
%548 = add nuw nsw i64 %541, %497
%549 = getelementptr inbounds double, double* %0, i64 %548
%550 = load double, double* %549
%551 = fmul double %550, %547
store double %551, double* %549
%552 = or i64 %541, 1
br label %553
553: ; preds = %543, %540
%554 = phi i64 [ %541, %540 ], [ %552, %543 ]
%555 = icmp eq i64 %542, %482
br i1 %555, label %577, label %556
556: ; preds = %553, %556
%557 = phi i64 [ %575, %556 ], [ %554, %553 ]
%558 = load double, double* %498
%559 = getelementptr inbounds double, double* %2, i64 %557
%560 = load double, double* %559
%561 = fmul double %558, %560
%562 = add nuw nsw i64 %557, %497
%563 = getelementptr inbounds double, double* %0, i64 %562
%564 = load double, double* %563
%565 = fmul double %564, %561
store double %565, double* %563
%566 = add nuw nsw i64 %557, 1
%567 = load double, double* %498
%568 = getelementptr inbounds double, double* %2, i64 %566
%569 = load double, double* %568
%570 = fmul double %567, %569
%571 = add nuw nsw i64 %566, %497
%572 = getelementptr inbounds double, double* %0, i64 %571
%573 = load double, double* %572
%574 = fmul double %573, %570
store double %574, double* %572
%575 = add nuw nsw i64 %557, 2
%576 = icmp eq i64 %575, %475
br i1 %576, label %577, label %556
577: ; preds = %553, %556, %539
%578 = add nuw nsw i64 %492, 1
%579 = icmp eq i64 %578, %475
br i1 %579, label %483, label %491
580: ; preds = %484, %698
%581 = phi i64 [ 0, %484 ], [ %699, %698 ]
%582 = phi i64 [ 1, %484 ], [ %700, %698 ]
%583 = add nsw i64 %581, -3
%584 = lshr i64 %583, 2
%585 = add nuw nsw i64 %584, 1
%586 = add nuw i64 %581, 1
%587 = mul nsw i64 %581, %485
%588 = getelementptr inbounds double, double* %2, i64 %581
%589 = icmp ult i64 %581, 3
br i1 %589, label %669, label %590
590: ; preds = %580
%591 = add nuw i64 %581, 1
%592 = getelementptr double, double* %2, i64 %591
%593 = getelementptr double, double* %2, i64 %581
%594 = bitcast double* %593 to i8*
%595 = mul i64 %490, %581
%596 = getelementptr i8, i8* %488, i64 %595
%597 = mul i64 %581, %475
%598 = getelementptr double, double* %4, i64 %597
%599 = icmp ult double* %598, %592
%600 = icmp ugt i8* %596, %594
%601 = and i1 %599, %600
br i1 %601, label %669, label %602
602: ; preds = %590
%603 = and i64 %586, -4
%604 = and i64 %585, 1
%605 = icmp ult i64 %583, 4
br i1 %605, label %647, label %606
606: ; preds = %602
%607 = and i64 %585, 9223372036854775806
%608 = load double, double* %588
%609 = insertelement <2 x double> poison, double %608, i64 0
%610 = shufflevector <2 x double> %609, <2 x double> poison, <2 x i32> zeroinitializer
%611 = insertelement <2 x double> poison, double %608, i64 0
%612 = shufflevector <2 x double> %611, <2 x double> poison, <2 x i32> zeroinitializer
%613 = load double, double* %588
%614 = insertelement <2 x double> poison, double %613, i64 0
%615 = shufflevector <2 x double> %614, <2 x double> poison, <2 x i32> zeroinitializer
%616 = insertelement <2 x double> poison, double %613, i64 0
%617 = shufflevector <2 x double> %616, <2 x double> poison, <2 x i32> zeroinitializer
br label %618
618: ; preds = %618, %606
%619 = phi i64 [ 0, %606 ], [ %644, %618 ]
%620 = phi i64 [ 0, %606 ], [ %645, %618 ]
%621 = add nuw nsw i64 %619, %587
%622 = getelementptr inbounds double, double* %4, i64 %621
%623 = bitcast double* %622 to <2 x double>*
%624 = load <2 x double>, <2 x double>* %623
%625 = getelementptr inbounds double, double* %622, i64 2
%626 = bitcast double* %625 to <2 x double>*
%627 = load <2 x double>, <2 x double>* %626
%628 = fmul <2 x double> %610, %624
%629 = fmul <2 x double> %612, %627
%630 = bitcast double* %622 to <2 x double>*
store <2 x double> %628, <2 x double>* %630
%631 = bitcast double* %625 to <2 x double>*
store <2 x double> %629, <2 x double>* %631
%632 = or i64 %619, 4
%633 = add nuw nsw i64 %632, %587
%634 = getelementptr inbounds double, double* %4, i64 %633
%635 = bitcast double* %634 to <2 x double>*
%636 = load <2 x double>, <2 x double>* %635
%637 = getelementptr inbounds double, double* %634, i64 2
%638 = bitcast double* %637 to <2 x double>*
%639 = load <2 x double>, <2 x double>* %638
%640 = fmul <2 x double> %615, %636
%641 = fmul <2 x double> %617, %639
%642 = bitcast double* %634 to <2 x double>*
store <2 x double> %640, <2 x double>* %642
%643 = bitcast double* %637 to <2 x double>*
store <2 x double> %641, <2 x double>* %643
%644 = add nuw i64 %619, 8
%645 = add i64 %620, 2
%646 = icmp eq i64 %645, %607
br i1 %646, label %647, label %618
647: ; preds = %618, %602
%648 = phi i64 [ 0, %602 ], [ %644, %618 ]
%649 = icmp eq i64 %604, 0
br i1 %649, label %667, label %650
650: ; preds = %647
%651 = load double, double* %588
%652 = insertelement <2 x double> poison, double %651, i64 0
%653 = shufflevector <2 x double> %652, <2 x double> poison, <2 x i32> zeroinitializer
%654 = insertelement <2 x double> poison, double %651, i64 0
%655 = shufflevector <2 x double> %654, <2 x double> poison, <2 x i32> zeroinitializer
%656 = add nuw nsw i64 %648, %587
%657 = getelementptr inbounds double, double* %4, i64 %656
%658 = bitcast double* %657 to <2 x double>*
%659 = load <2 x double>, <2 x double>* %658
%660 = getelementptr inbounds double, double* %657, i64 2
%661 = bitcast double* %660 to <2 x double>*
%662 = load <2 x double>, <2 x double>* %661
%663 = fmul <2 x double> %653, %659
%664 = fmul <2 x double> %655, %662
%665 = bitcast double* %657 to <2 x double>*
store <2 x double> %663, <2 x double>* %665
%666 = bitcast double* %660 to <2 x double>*
store <2 x double> %664, <2 x double>* %666
br label %667
667: ; preds = %647, %650
%668 = icmp eq i64 %586, %603
br i1 %668, label %698, label %669
669: ; preds = %590, %580, %667
%670 = phi i64 [ 0, %590 ], [ 0, %580 ], [ %603, %667 ]
%671 = and i64 %582, 1
%672 = icmp eq i64 %671, 0
br i1 %672, label %680, label %673
673: ; preds = %669
%674 = load double, double* %588
%675 = add nuw nsw i64 %670, %587
%676 = getelementptr inbounds double, double* %4, i64 %675
%677 = load double, double* %676
%678 = fmul double %674, %677
store double %678, double* %676
%679 = or i64 %670, 1
br label %680
680: ; preds = %673, %669
%681 = phi i64 [ %670, %669 ], [ %679, %673 ]
%682 = icmp eq i64 %581, %670
br i1 %682, label %698, label %683
683: ; preds = %680, %683
%684 = phi i64 [ %696, %683 ], [ %681, %680 ]
%685 = load double, double* %588
%686 = add nuw nsw i64 %684, %587
%687 = getelementptr inbounds double, double* %4, i64 %686
%688 = load double, double* %687
%689 = fmul double %685, %688
store double %689, double* %687
%690 = add nuw nsw i64 %684, 1
%691 = load double, double* %588
%692 = add nuw nsw i64 %690, %587
%693 = getelementptr inbounds double, double* %4, i64 %692
%694 = load double, double* %693
%695 = fmul double %691, %694
store double %695, double* %693
%696 = add nuw nsw i64 %684, 2
%697 = icmp eq i64 %696, %582
br i1 %697, label %698, label %683
698: ; preds = %680, %683, %667
%699 = add nuw nsw i64 %581, 1
%700 = add nuw nsw i64 %582, 1
%701 = icmp eq i64 %699, %486
br i1 %701, label %702, label %580
702: ; preds = %698, %471, %431, %483
%703 = phi double [ %472, %483 ], [ %472, %471 ], [ %432, %431 ], [ %472, %698 ]
%704 = tail call i32 @free(double* %10)
ret double %703
}