int stiff(y, dydx, n, x, htry, eps, yscal, hdid, hnext, work, epjac, ier)
double *work, *hdid, *hnext, *x, dydx[], eps, htry, y[], yscal[], epjac;
int n, *ier;
{
  int i, j, jtry, indx[700];
  int info;
  double errmax, h, xsav, *a, *dfdx, *dfdy, *dysav, *err;
  double *g1, *g2, *g3, *g4, *ysav, *work2;
  *ier = 0;
  a = work;
  dfdx = work + n * n;
  dfdy = dfdx + n;
  dysav = dfdy + n * n;
  err = dysav + n;
  g1 = err + n;
  g2 = g1 + n;
  g3 = g2 + n;
  g4 = g3 + n;
  ysav = g4 + n;
  work2 = ysav + n;
  xsav = (*x);
  for (i = 0; i < n; i++) {
    ysav[i] = y[i];
    dysav[i] = dydx[i];
  }
  jacobn(xsav, ysav, dfdx, dfdy, epjac, work2, n);
  h = htry;
  for (jtry = 1; jtry <= 40; jtry++) {
    for (i = 0; i < n; i++) {
      for (j = 0; j < n; j++)
        a[i + n * j] = -dfdy[i + n * j];
      a[i + n * i] += 1.0 / ((1.0 / 2.0) * h);
    }
    sgefa(a, n, n, indx, &info);
    if (info != -1) {
      *ier = -1;
      return -1;
    }
    for (i = 0; i < n; i++)
      g1[i] = dysav[i] + h * (1.0 / 2.0) * dfdx[i];
    sgesl(a, n, n, indx, g1, 0);
    for (i = 0; i < n; i++)
      y[i] = ysav[i] + 2.0 * g1[i];
    *x = xsav + 1.0 * h;
    rhs(*x, y, dydx, n);
    for (i = 0; i < n; i++)
      g2[i] = dydx[i] + h * (-3.0 / 2.0) * dfdx[i] + -8.0 * g1[i] / h;
    sgesl(a, n, n, indx, g2, 0);
    for (i = 0; i < n; i++)
      y[i] = ysav[i] + (48.0 / 25.0) * g1[i] + (6.0 / 25.0) * g2[i];
    *x = xsav + (3.0 / 5.0) * h;
    rhs(*x, y, dydx, n);
    for (i = 0; i < n; i++)
      g3[i] = dydx[i] + h * (121.0 / 50.0) * dfdx[i] +
              ((372.0 / 25.0) * g1[i] + (12.0 / 5.0) * g2[i]) / h;
    sgesl(a, n, n, indx, g3, 0);
    for (i = 0; i < n; i++)
      g4[i] = dydx[i] + h * (29.0 / 250.0) * dfdx[i] +
              ((-112.0 / 125.0) * g1[i] + (-54.0 / 125.0) * g2[i] +
               (-2.0 / 5.0) * g3[i]) /
                  h;
    sgesl(a, n, n, indx, g4, 0);
    for (i = 0; i < n; i++) {
      y[i] = ysav[i] + (19.0 / 9.0) * g1[i] + (1.0 / 2.0) * g2[i] +
             (25.0 / 108.0) * g3[i] + (125.0 / 108.0) * g4[i];
      err[i] = (17.0 / 54.0) * g1[i] + (7.0 / 36.0) * g2[i] + 0.0 * g3[i] +
               (125.0 / 108.0) * g4[i];
    }
    *x = xsav + h;
    if (*x == xsav) {
      *ier = 1;
      return -1;
    }
    errmax = 0.0;
    for (i = 0; i < n; i++)
      errmax =
          ((errmax) > (fabs(err[i] / yscal[i])) ? (errmax)
                                                : (fabs(err[i] / yscal[i])));
    errmax /= eps;
    if (errmax <= 1.0) {
      *hdid = h;
      *hnext = (errmax > 0.1296 ? 0.9 * h * pow(errmax, -0.25) : 1.5 * h);
      return 0;
    } else {
      *hnext = 0.9 * h * pow(errmax, (-1.0 / 3.0));
      h = (h >= 0.0 ? ((*hnext) > (0.5 * h) ? (*hnext) : (0.5 * h))
                    : ((*hnext) < (0.5 * h) ? (*hnext) : (0.5 * h)));
    }
  }
  *ier = 4;
  return -1;
}


x86 assembly (clang, -O0):
<stiff>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc00,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
movsd  %xmm2,-0x50(%rbp)
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    0x18(%rbp),%rax
mov    %rax,-0xb78(%rbp)
mov    0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb80(%rbp)
mov    -0xb80(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb88(%rbp)
mov    -0xb88(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb90(%rbp)
mov    -0xb90(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb98(%rbp)
mov    -0xb98(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xba0(%rbp)
mov    -0xba0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xba8(%rbp)
mov    -0xba8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xbb0(%rbp)
mov    -0xbb0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xbb8(%rbp)
mov    -0xbb8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xbc0(%rbp)
mov    -0xbc0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xbc8(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb70(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1310 <stiff+0x1c0>
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xbc0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb90(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12bc <stiff+0x16c>
movsd  -0xb70(%rbp),%xmm0
ff
mov    -0xbc0(%rbp),%rdi
mov    -0xb80(%rbp),%rsi
mov    -0xb88(%rbp),%rdx
movsd  -0x50(%rbp),%xmm1
mov    -0xbc8(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
mov    $0x2,%al
call   1040 <jacobn@plt>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xb68(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
cmpl   $0x28,-0x5c(%rbp)
jg     1d14 <stiff+0xbc4>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    142d <stiff+0x2dd>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13e3 <stiff+0x293>
mov    -0xb88(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xb78(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    137c <stiff+0x22c>
movsd  0xc35(%rip),%xmm1
mulsd  -0xb68(%rbp),%xmm1
ff
movsd  0xc0d(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0xb78(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x54(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1369 <stiff+0x219>
mov    -0xb78(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    -0xb50(%rbp),%rcx
lea    -0xb54(%rbp),%r8
mov    $0x0,%al
call   1030 <sgefa@plt>
cmpl   $0xffffffff,-0xb54(%rbp)
je     1472 <stiff+0x322>
mov    0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1d25 <stiff+0xbd5>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14db <stiff+0x38b>
mov    -0xb90(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xb83(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
mov    -0xb80(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1479 <stiff+0x329>
mov    -0xb78(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    -0xb50(%rbp),%rcx
mov    -0xba0(%rbp),%r8
xor    %r9d,%r9d
mov    $0x0,%al
call   1060 <sgesl@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1556 <stiff+0x406>
mov    -0xbc0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1507 <stiff+0x3b7>
movsd  -0xb70(%rbp),%xmm1
ff
movsd  -0xb68(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    $0x1,%al
call   1050 <rhs@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1616 <stiff+0x4c6>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xb04(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
mov    -0xb80(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xac9(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xb68(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
mov    -0xba8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1593 <stiff+0x443>
mov    -0xb78(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    -0xb50(%rbp),%rcx
mov    -0xba8(%rbp),%r8
xor    %r9d,%r9d
mov    $0x0,%al
call   1060 <sgesl@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16b9 <stiff+0x569>
mov    -0xbc0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xa32(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xba8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xa0a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1642 <stiff+0x4f2>
movsd  -0xb70(%rbp),%xmm1
ff
movsd  -0xb68(%rbp),%xmm0
ff
movsd  0x92f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    $0x1,%al
call   1050 <rhs@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    17a5 <stiff+0x655>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x975(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
mov    -0xb80(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xba8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0x92a(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x915(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  -0xb68(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
mov    -0xbb0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1702 <stiff+0x5b2>
mov    -0xb78(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    -0xb50(%rbp),%rcx
mov    -0xbb0(%rbp),%r8
xor    %r9d,%r9d
mov    $0x0,%al
call   1060 <sgesl@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1894 <stiff+0x744>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x88e(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
mov    -0xb80(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xba8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0x843(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x82e(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0xbb0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x806(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  -0xb68(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
mov    -0xbb8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    17d1 <stiff+0x681>
mov    -0xb78(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    -0xb50(%rbp),%rcx
mov    -0xbb8(%rbp),%r8
xor    %r9d,%r9d
mov    $0x0,%al
call   1060 <sgesl@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19fa <stiff+0x8aa>
mov    -0xbc0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x76c(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xba8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x70c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xbb0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x724(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xbb8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x6ec(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xba0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xba8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0x6c4(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x6af(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xbb0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
xorps  %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xbb8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x66c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb98(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    18c0 <stiff+0x770>
movsd  -0xb70(%rbp),%xmm0
ff
addsd  -0xb68(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0xb70(%rbp),%xmm0
ff
jne    1a44 <stiff+0x8f4>
jp     1a44 <stiff+0x8f4>
mov    0x20(%rbp),%rax
movl   $0x1,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1d25 <stiff+0xbd5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb60(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1aff <stiff+0x9af>
movsd  -0xb60(%rbp),%xmm0
ff
mov    -0xb98(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
movaps 0x632(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ab1 <stiff+0x961>
movsd  -0xb60(%rbp),%xmm0
ff
movsd  %xmm0,-0xbd0(%rbp)
ff
jmp    1ae1 <stiff+0x991>
mov    -0xb98(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movaps 0x5eb(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xbd0(%rbp)
ff
movsd  -0xbd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb60(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1a56 <stiff+0x906>
movsd  -0x38(%rbp),%xmm1
movsd  -0xb60(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb60(%rbp)
ff
movsd  0x4e8(%rip),%xmm0
ucomisd -0xb60(%rbp),%xmm0
ff
jb     1bd5 <stiff+0xa85>
movsd  -0xb68(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb60(%rbp),%xmm0
ff
movsd  0x4da(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ba1 <stiff+0xa51>
movsd  0x4b8(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
movsd  %xmm0,-0xbe0(%rbp)
ff
movsd  -0xb60(%rbp),%xmm0
ff
movsd  0x4b8(%rip),%xmm1
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xbe0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xbd8(%rbp)
ff
jmp    1bb9 <stiff+0xa69>
movsd  0x487(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
movsd  %xmm0,-0xbd8(%rbp)
ff
movsd  -0xbd8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1d25 <stiff+0xbd5>
movsd  0x43b(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
movsd  %xmm0,-0xbe8(%rbp)
ff
movsd  -0xb60(%rbp),%xmm0
ff
movsd  0x413(%rip),%xmm1
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xbe8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb68(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c92 <stiff+0xb42>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x3e2(%rip),%xmm1
mulsd  -0xb68(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    1c65 <stiff+0xb15>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xbf0(%rbp)
ff
jmp    1c7d <stiff+0xb2d>
movsd  0x3b3(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
movsd  %xmm0,-0xbf0(%rbp)
ff
movsd  -0xbf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xbf8(%rbp)
ff
jmp    1cf1 <stiff+0xba1>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x37e(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1cc9 <stiff+0xb79>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc00(%rbp)
ff
jmp    1ce1 <stiff+0xb91>
movsd  0x34f(%rip),%xmm0
mulsd  -0xb68(%rbp),%xmm0
ff
movsd  %xmm0,-0xc00(%rbp)
ff
movsd  -0xc00(%rbp),%xmm0
ff
movsd  %xmm0,-0xbf8(%rbp)
ff
movsd  -0xbf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb68(%rbp)
jmp    1d06 <stiff+0xbb6>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1358 <stiff+0x208>
mov    0x20(%rbp),%rax
movl   $0x4,(%rax)
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc00,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stiff>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc98,%rsp
mov    %r9,0x158(%rsp)
mov    %r8,0x150(%rsp)
movsd  %xmm1,0x198(%rsp)
movaps %xmm0,%xmm3
mov    %edx,%ebx
mov    %rsi,%r12
mov    0xce0(%rsp),%rax
mov    0xcd8(%rsp),%r10
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
mov    %rdx,0xe8(%rsp)
movl   $0x0,(%rax)
mov    %ebx,%r15d
imul   %r15d,%r15d
lea    (%r10,%r15,8),%rsi
movslq %ebx,%r11
lea    (%rsi,%r11,8),%rax
mov    %rax,0x118(%rsp)
lea    (%rax,%r15,8),%rax
mov    %rax,0x98(%rsp)
lea    (%rax,%r11,8),%rax
mov    %rcx,0xc8(%rsp)
movsd  (%rcx),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    %rax,0x148(%rsp)
lea    (%rax,%r11,8),%rax
mov    %rax,0x20(%rsp)
lea    (%rax,%r11,8),%rax
mov    %rax,0x70(%rsp)
lea    (%rax,%r11,8),%rax
mov    %rax,0xa0(%rsp)
lea    (%rax,%r11,8),%rax
mov    %rax,0xc0(%rsp)
lea    (%rax,%r11,8),%rax
mov    %rax,0x48(%rsp)
lea    (%rax,%r11,8),%r14
mov    %ebx,%r13d
test   %r11d,%r11d
mov    %ebx,0x1c(%rsp)
mov    %r12,0x10(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rsi,0x38(%rsp)
mov    %r11,0x28(%rsp)
jle    1539 <stiff+0x3e9>
mov    %rdi,%r9
cmp    $0x4,%ebx
jae    125b <stiff+0x10b>
xor    %eax,%eax
jmp    14a4 <stiff+0x354>
mov    %r14,0x88(%rsp)
lea    0x0(,%r11,8),%rax
sub    %r11,%rax
lea    (%rax,%r15,2),%rcx
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
lea    (%rcx,%r13,1),%rax
lea    (%r10,%rax,8),%rax
lea    (%r11,%r15,2),%rdx
mov    %rdx,%rcx
mov    %rdx,0x8(%rsp)
add    %r13,%rdx
lea    (%r10,%rdx,8),%rsi
lea    (%r9,%r13,8),%rdi
lea    (%r12,%r13,8),%rdx
mov    0x48(%rsp),%rbp
cmp    %rsi,%rbp
setb   %cl
mov    0x98(%rsp),%r10
cmp    %rax,%r10
setb   %r14b
cmp    %rdi,%rbp
setb   %bl
cmp    %r9,%rax
mov    %r9,%r8
seta   %r9b
cmp    %rdx,%rbp
setb   %r11b
cmp    %r12,%rax
seta   %bpl
cmp    %rdi,%r10
setb   %dil
cmp    %r8,%rsi
mov    %r12,%rax
seta   %r12b
cmp    %rdx,%r10
setb   %r8b
cmp    %rax,%rsi
seta   %dl
xor    %eax,%eax
test   %r14b,%cl
jne    145a <stiff+0x30a>
and    %r9b,%bl
mov    0x88(%rsp),%r14
jne    1484 <stiff+0x334>
and    %bpl,%r11b
mov    0x1c(%rsp),%ebx
mov    0x40(%rsp),%r9
jne    1453 <stiff+0x303>
and    %r12b,%dil
mov    0xcd8(%rsp),%r10
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%r11
jne    144c <stiff+0x2fc>
and    %dl,%r8b
mov    0x10(%rsp),%r12
jne    14a4 <stiff+0x354>
mov    %r13d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1401 <stiff+0x2b1>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
mov    0x50(%rsp),%rcx
lea    (%r10,%rcx,8),%rbp
add    $0x30,%rbp
mov    0x8(%rsp),%rcx
lea    (%r10,%rcx,8),%rbx
add    $0x30,%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r9,%rdx,8),%xmm0
movups 0x10(%r9,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbp,%rdx,8)
movups %xmm1,-0x20(%rbp,%rdx,8)
movups (%r12,%rdx,8),%xmm0
movups 0x10(%r12,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movups 0x20(%r9,%rdx,8),%xmm0
movups 0x30(%r9,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbp,%rdx,8)
movups %xmm1,0x0(%rbp,%rdx,8)
movups 0x20(%r12,%rdx,8),%xmm0
movups 0x30(%r12,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    13a0 <stiff+0x250>
jmp    1403 <stiff+0x2b3>
xor    %edx,%edx
test   $0x1,%r8b
mov    0x1c(%rsp),%ebx
je     1442 <stiff+0x2f2>
movups (%r9,%rdx,8),%xmm0
movups 0x10(%r9,%rdx,8),%xmm1
mov    0x48(%rsp),%rcx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movups (%r12,%rdx,8),%xmm0
movups 0x10(%r12,%rdx,8),%xmm1
mov    0x98(%rsp),%rcx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
cmp    %r13,%rax
jne    14a4 <stiff+0x354>
jmp    1539 <stiff+0x3e9>
mov    0x10(%rsp),%r12
jmp    14a4 <stiff+0x354>
mov    0x10(%rsp),%r12
jmp    1492 <stiff+0x342>
mov    0x1c(%rsp),%ebx
mov    0x10(%rsp),%r12
mov    0x40(%rsp),%r9
mov    0xcd8(%rsp),%r10
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%r11
mov    0x88(%rsp),%r14
jmp    14a4 <stiff+0x354>
mov    0x1c(%rsp),%ebx
mov    0x10(%rsp),%r12
mov    0x40(%rsp),%r9
mov    0xcd8(%rsp),%r10
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%r11
mov    %rax,%rdx
not    %rdx
test   $0x1,%r13b
je     14d7 <stiff+0x387>
movsd  (%r9,%rax,8),%xmm0
mov    0x48(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  (%r12,%rax,8),%xmm0
mov    0x98(%rsp),%rdi
movsd  %xmm0,(%rdi,%rax,8)
or     $0x1,%rax
add    %r13,%rdx
je     1539 <stiff+0x3e9>
lea    (%r11,%r15,2),%rdx
lea    (%r10,%rdx,8),%rdx
add    $0x8,%rdx
lea    0x0(,%r11,8),%rdi
sub    %r11,%rdi
lea    (%rdi,%r15,2),%rdi
lea    (%r10,%rdi,8),%rdi
add    $0x8,%rdi
nop
movsd  (%r9,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rax,8)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rax,8)
movsd  0x8(%r9,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1500 <stiff+0x3b0>
movsd  0xa8(%rsp),%xmm0
mov    0x48(%rsp),%rdi
mov    0x118(%rsp),%rdx
movapd %xmm2,%xmm1
mov    %r14,%rcx
mov    %ebx,%r8d
mov    $0x2,%al
movaps %xmm3,0x50(%rsp)
mov    %rsi,%r12
call   1040 <jacobn@plt>
movapd 0x50(%rsp),%xmm0
mov    0x28(%rsp),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0x68(%rsp)
lea    (%rax,%r15,2),%rax
mov    %rax,0xd0(%rsp)
add    %r13,%rax
mov    0xcd8(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
lea    0x0(%r13,%r15,1),%rax
mov    0xcd8(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
mov    %rbp,0x78(%rsp)
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rax
sub    0x28(%rsp),%rax
lea    (%rax,%r15,2),%rax
mov    %rax,0x120(%rsp)
add    %r13,%rax
mov    0xcd8(%rsp),%rcx
lea    (%rcx,%rax,8),%r8
mov    0x28(%rsp),%rcx
lea    (%rcx,%r15,2),%rax
mov    %rax,0x80(%rsp)
lea    (%rax,%r13,1),%rcx
mov    0xcd8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %r13d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xf0(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x140(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r13d,%r14d
and    $0xfffffffe,%r14d
lea    -0x2(%r14),%rsi
mov    %rsi,0x178(%rsp)
shr    %rsi
add    $0x1,%rsi
mov    0x20(%rsp),%rdi
cmp    %rcx,%rdi
setb   %cl
mov    %rbx,%rax
cmp    %rbx,0x98(%rsp)
setb   %bl
and    %cl,%bl
cmp    %rbp,%rdi
setb   %cl
mov    %r12,%r9
cmp    %rax,%r12
mov    %rax,%r10
setb   %al
and    %cl,%al
or     %bl,%al
mov    %al,0x36(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x138(%rsp)
and    %rdx,0xe8(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x100(%rsp)
mov    0x40(%rsp),%rax
cmp    %rax,%r8
lea    (%rax,%r13,8),%rbp
seta   %cl
cmp    %rbp,0x48(%rsp)
setb   %bl
and    %cl,%bl
cmp    %rax,%r10
mov    %r10,0x110(%rsp)
seta   %cl
cmp    %rbp,%rdi
setb   %dl
and    %cl,%dl
or     %bl,%dl
lea    (%r15,%r15,1),%rcx
mov    %rcx,0x88(%rsp)
mov    0x28(%rsp),%rax
lea    (%rcx,%rax,4),%rax
mov    %rax,0xb8(%rsp)
lea    (%rax,%r13,1),%rcx
mov    0xcd8(%rsp),%rax
lea    (%rax,%rcx,8),%r8
mov    0x10(%rsp),%r12
lea    (%r12,%r13,8),%rcx
mov    %rcx,0x8(%rsp)
mov    0x70(%rsp),%r11
cmp    %rcx,%r11
setb   %bl
cmp    %r12,%r8
seta   %cl
and    %bl,%cl
cmp    %r10,%r11
setb   %bl
cmp    %r8,%rdi
setb   %al
and    %bl,%al
or     %cl,%al
mov    0x78(%rsp),%r10
cmp    %r10,%r11
setb   %cl
cmp    %r8,%r9
setb   %bl
and    %cl,%bl
or     %al,%bl
mov    %bl,0x33(%rsp)
mov    %rsi,%rax
mov    %rsi,0x170(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x168(%rsp)
cmp    0x40(%rsp),%r8
seta   %al
cmp    %rbp,%r11
setb   %bl
and    %al,%bl
mov    0x28(%rsp),%rax
lea    (%rax,%rax,4),%rax
lea    (%rax,%r15,2),%rax
mov    %rax,0x108(%rsp)
add    %r13,%rax
mov    0xcd8(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %dl,0x34(%rsp)
or     %dl,%bl
mov    %bl,0x32(%rsp)
mov    0xa0(%rsp),%r9
mov    0x8(%rsp),%rdi
cmp    %rdi,%r9
setb   %al
cmp    %r12,%rsi
seta   %bl
and    %al,%bl
mov    0x110(%rsp),%r12
cmp    %r12,%r9
setb   %dl
cmp    %rsi,0x20(%rsp)
setb   %al
and    %dl,%al
or     %bl,%al
mov    %r10,%rbp
cmp    %r10,%r9
setb   %dl
cmp    %rsi,0x38(%rsp)
setb   %bl
and    %dl,%bl
cmp    %r8,%r9
setb   %dl
cmp    %rsi,%r11
setb   %cl
and    %dl,%cl
or     %bl,%cl
or     %al,%cl
mov    %cl,0x37(%rsp)
mov    0xc0(%rsp),%rcx
cmp    %rdi,%rcx
mov    %r13,0x8(%rsp)
mov    0x68(%rsp),%rax
mov    0x88(%rsp),%rdx
lea    (%rdx,%rax,2),%r13
mov    0x8(%rsp),%rax
lea    0x0(%r13,%rax,1),%rdx
mov    0xcd8(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
setb   %bl
cmp    0x10(%rsp),%rdx
seta   %al
and    %bl,%al
cmp    %r12,%rcx
setb   %r10b
cmp    %rdx,0x20(%rsp)
setb   %bl
and    %r10b,%bl
or     %al,%bl
cmp    %rbp,%rcx
mov    0xcd8(%rsp),%rdi
setb   %al
cmp    %rdx,0x38(%rsp)
setb   %r12b
and    %al,%r12b
cmp    %r8,%rcx
setb   %r8b
cmp    %rdx,%r11
setb   %al
and    %r8b,%al
or     %r12b,%al
or     %bl,%al
mov    0x1c(%rsp),%ebp
cmp    %rsi,%rcx
setb   %cl
cmp    %rdx,%r9
setb   %dl
and    %cl,%dl
or     %al,%dl
mov    %dl,0x35(%rsp)
mov    0x28(%rsp),%r12
shl    $0x4,%r12
mov    0x28(%rsp),%rax
lea    (%r15,%rax,2),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0x110(%rsp)
mov    0x80(%rsp),%rax
lea    0x30(%rdi,%rax,8),%rax
mov    %rax,0xf8(%rsp)
mov    0x120(%rsp),%rcx
lea    0x30(%rdi,%rcx,8),%rax
mov    %rax,0x130(%rsp)
lea    0x8(%rdi,%rcx,8),%rax
mov    %rax,0xe0(%rsp)
mov    0xd0(%rsp),%rcx
lea    0x30(%rdi,%rcx,8),%rax
mov    %rax,0x80(%rsp)
lea    0x8(%rdi,%rcx,8),%rax
mov    %rax,0x78(%rsp)
lea    0x10(%rdi,%rcx,8),%rax
mov    %rax,0x128(%rsp)
mov    0xb8(%rsp),%rax
lea    0x10(%rdi,%rax,8),%rax
mov    %rax,0x68(%rsp)
mov    0x8(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x190(%rsp)
and    $0xffffffffffffffe0,%rax
mov    %rax,0x160(%rsp)
mov    0x108(%rsp),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0xb8(%rsp)
lea    (%rdi,%r13,8),%rax
mov    0x8(%rsp),%r13
mov    %rax,0x180(%rsp)
mov    0x28(%rsp),%rax
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,2),%rax
mov    0x118(%rsp),%r11
mov    0x28(%rsp),%r10
lea    0x8(%rdi,%rax,8),%rax
mov    %rax,0x188(%rsp)
movsd  0x166d(%rip),%xmm2
movapd 0x1725(%rip),%xmm3
lea    -0x1(%r13),%rax
mov    %rax,0x88(%rsp)
lea    (%rdi,%r10,8),%rax
mov    %rax,0x108(%rsp)
lea    0x30(%rdi,%r15,8),%rax
mov    %rax,0xb0(%rsp)
mov    $0x1,%eax
lea    0x1a0(%rsp),%rbx
jmp    1a00 <stiff+0x8b0>
nop
mov    0x120(%rsp),%eax
add    $0x1,%eax
cmp    $0x29,%eax
mov    0xcd8(%rsp),%rdi
mov    0x28(%rsp),%r10
mov    0x118(%rsp),%r11
movapd 0x16c6(%rip),%xmm3
je     2b0d <stiff+0x19bd>
test   %ebp,%ebp
movapd %xmm0,0x50(%rsp)
mov    %eax,0x120(%rsp)
jle    1ba0 <stiff+0xa50>
movapd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
movsd  0x15e3(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %rdi,%r8
mov    0x110(%rsp),%r9
mov    0x108(%rsp),%rbx
xor    %esi,%esi
movapd 0x167a(%rip),%xmm2
jmp    1a81 <stiff+0x931>
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rax
imul   %r10,%rax
add    %rsi,%rax
movsd  (%rdi,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%rsi
add    $0x8,%rbx
add    $0x8,%r9
add    $0x8,%r8
cmp    %r13,%rsi
je     1b10 <stiff+0x9c0>
cmpq   $0x0,0x88(%rsp)
je     1ae0 <stiff+0x990>
mov    %r8,%rax
mov    %r9,%rcx
mov    %rbx,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%r15,8),%xmm1
xorpd  %xmm3,%xmm1
movlpd %xmm1,(%rax)
movsd  (%rcx),%xmm1
xorpd  %xmm3,%xmm1
movlpd %xmm1,(%rdx)
add    $0x2,%rbp
add    %r12,%rdx
add    %r12,%rcx
add    %r12,%rax
cmp    %rbp,%r14
jne    1aa0 <stiff+0x950>
test   $0x1,%r13b
je     1a50 <stiff+0x900>
jmp    1aec <stiff+0x99c>
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
test   $0x1,%r13b
je     1a50 <stiff+0x900>
imul   %r10,%rbp
add    %rsi,%rbp
movsd  (%r11,%rbp,8),%xmm1
xorpd  %xmm2,%xmm1
movlpd %xmm1,(%rdi,%rbp,8)
jmp    1a50 <stiff+0x900>
nopw   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%ebp
mov    %ebp,%esi
mov    %ebp,%edx
lea    0x1a0(%rsp),%rbx
mov    %rbx,%rcx
lea    0x94(%rsp),%r8
xor    %eax,%eax
call   1030 <sgefa@plt>
cmpl   $0xffffffff,0x94(%rsp)
ff
jne    2ab4 <stiff+0x1964>
test   %ebp,%ebp
jle    1bc4 <stiff+0xa74>
cmp    $0x4,%ebp
setb   %al
movapd 0x50(%rsp),%xmm0
mulsd  0x14a4(%rip),%xmm0
or     0x36(%rsp),%al
mov    %ebp,%r13d
je     1efd <stiff+0xdad>
xor    %ecx,%ecx
mov    0xcd8(%rsp),%rdi
mov    0x38(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0xf8(%rsp),%rsi
mov    0x78(%rsp),%rbp
mov    0xb0(%rsp),%rbx
mov    0x8(%rsp),%rdx
jmp    2451 <stiff+0x1301>
nopl   0x0(%rax)
mov    %ebp,%esi
mov    %ebp,%edx
mov    %rbx,%rcx
lea    0x94(%rsp),%r8
xor    %eax,%eax
call   1030 <sgefa@plt>
cmpl   $0xffffffff,0x94(%rsp)
ff
jne    2ab4 <stiff+0x1964>
mov    0xcd8(%rsp),%rdi
mov    %ebp,%esi
mov    %ebp,%edx
mov    %rbx,%rcx
mov    0x20(%rsp),%r8
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <sgesl@plt>
movsd  0xa8(%rsp),%xmm0
addsd  0x50(%rsp),%xmm0
mov    0xc8(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  %xmm0,0xd0(%rsp)
mov    0x40(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    %ebp,%edx
mov    $0x1,%al
call   1050 <rhs@plt>
mov    0xcd8(%rsp),%rdi
mov    0x70(%rsp),%r8
mov    %ebp,%esi
mov    %ebp,%edx
mov    %rbx,%rcx
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <sgesl@plt>
movapd 0x50(%rsp),%xmm4
mov    0x10(%rsp),%rsi
mov    0x40(%rsp),%rdi
mov    0x8(%rsp),%r13
movapd %xmm4,%xmm0
mulsd  0x13d8(%rip),%xmm0
addsd  0xa8(%rsp),%xmm0
mov    0xc8(%rsp),%rax
movsd  %xmm0,(%rax)
mov    %ebp,%edx
mov    $0x1,%al
call   1050 <rhs@plt>
test   %ebp,%ebp
jle    1ce0 <stiff+0xb90>
cmp    $0x1,%ebp
sete   %al
movapd 0x50(%rsp),%xmm6
movapd %xmm6,%xmm0
mulsd  0x13a6(%rip),%xmm0
or     0x37(%rsp),%al
je     1d10 <stiff+0xbc0>
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
mov    0xcd8(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0xa0(%rsp),%r8
mov    0x80(%rsp),%r10
movsd  0x137c(%rip),%xmm4
movsd  0x137c(%rip),%xmm5
jmp    1dc1 <stiff+0xc71>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%r13d
mov    0xcd8(%rsp),%rbp
mov    %rbp,%rdi
mov    %r13d,%esi
mov    %r13d,%edx
mov    %rbx,%rcx
mov    0xa0(%rsp),%r8
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <sgesl@plt>
jmp    1ec0 <stiff+0xd70>
xchg   %ax,%ax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm6,%xmm2
unpcklpd %xmm6,%xmm2
xor    %eax,%eax
mov    0x10(%rsp),%rbp
mov    0x38(%rsp),%rsi
mov    0x20(%rsp),%rcx
mov    0x70(%rsp),%rdx
mov    0xa0(%rsp),%r8
mov    0x80(%rsp),%r10
movapd 0x13c1(%rip),%xmm8
movapd 0x13c9(%rip),%xmm7
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,8),%xmm3
movupd (%rsi,%rax,8),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
movupd (%rcx,%rax,8),%xmm3
movupd (%rdx,%rax,8),%xmm5
mulpd  %xmm8,%xmm5
mulpd  %xmm7,%xmm3
addpd  %xmm5,%xmm3
divpd  %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%r8,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1d60 <stiff+0xc10>
mov    %r14,%rbx
cmp    %r13,%r14
mov    0xcd8(%rsp),%rdi
movsd  0x1289(%rip),%xmm4
movsd  0x1289(%rip),%xmm5
je     1e3b <stiff+0xceb>
mov    0xb8(%rsp),%rax
lea    (%rax,%rbx,8),%r9
mov    0x68(%rsp),%rax
lea    (%rax,%rbx,8),%rcx
add    $0xfffffffffffffff0,%rcx
lea    -0x30(%r10,%rbx,8),%rdx
lea    (%rsi,%rbx,8),%rsi
lea    0x0(,%rbx,8),%rax
add    %rbp,%rax
mov    %r13,%rbp
sub    %rbx,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rbx,8),%xmm1
movsd  (%rcx,%rbx,8),%xmm2
mulsd  %xmm4,%xmm2
movsd  (%rdx,%rbx,8),%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
divsd  %xmm6,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,(%r9,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1e00 <stiff+0xcb0>
mov    0x1c(%rsp),%r13d
mov    %r13d,%esi
mov    %r13d,%edx
lea    0x1a0(%rsp),%rbx
mov    %rbx,%rcx
xor    %r9d,%r9d
xor    %eax,%eax
mov    %rdi,%rbp
call   1060 <sgesl@plt>
test   %r13d,%r13d
jle    1ec0 <stiff+0xd70>
cmp    $0x1,%r13d
sete   %al
movapd 0x50(%rsp),%xmm6
movapd %xmm6,%xmm0
mulsd  0x11d4(%rip),%xmm0
or     0x35(%rsp),%al
mov    %rbp,%rdi
mov    0xc0(%rsp),%r8
je     1fc4 <stiff+0xe74>
xor    %ebp,%ebp
mov    0x10(%rsp),%rbx
mov    0x38(%rsp),%rcx
movsd  0x11b3(%rip),%xmm4
movsd  0x11b3(%rip),%xmm5
movsd  0x11b3(%rip),%xmm7
mov    0x8(%rsp),%r11
jmp    2088 <stiff+0xf38>
nop
mov    %rbp,%rdi
mov    %r13d,%esi
mov    %r13d,%edx
mov    %rbx,%rcx
mov    0xc0(%rsp),%r8
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <sgesl@plt>
mov    0x150(%rsp),%rcx
mov    0x148(%rsp),%r8
movsd  0xd0(%rsp),%xmm9
jmp    223e <stiff+0x10ee>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x140(%rsp)
je     23cc <stiff+0x127c>
mov    0xe8(%rsp),%rcx
xor    %eax,%eax
mov    0x38(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0xf8(%rsp),%rsi
mov    0x80(%rsp),%rdi
mov    0x78(%rsp),%rbp
mov    0xb0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%rsi,%rax,8),%xmm2
movupd -0x20(%rsi,%rax,8),%xmm3
movupd -0x30(%rbx,%rax,8),%xmm4
movupd -0x20(%rbx,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%rdi,%rax,8)
movupd %xmm5,-0x20(%rdi,%rax,8)
movupd -0x10(%rsi,%rax,8),%xmm2
movupd (%rsi,%rax,8),%xmm3
movupd -0x10(%rbx,%rax,8),%xmm4
movupd (%rbx,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%rdi,%rax,8)
movupd %xmm5,(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f50 <stiff+0xe00>
jmp    23ed <stiff+0x129d>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm6,%xmm2
unpcklpd %xmm6,%xmm2
xor    %eax,%eax
mov    0x10(%rsp),%rbx
mov    0x38(%rsp),%rcx
mov    0x20(%rsp),%rdx
mov    0x70(%rsp),%rsi
mov    0xa0(%rsp),%rbp
movapd 0x1135(%rip),%xmm8
movapd 0x113c(%rip),%xmm9
movapd 0x1144(%rip),%xmm7
nopl   0x0(%rax)
movupd (%rbx,%rax,8),%xmm3
movupd (%rcx,%rax,8),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
movupd (%rdx,%rax,8),%xmm3
movupd (%rsi,%rax,8),%xmm5
mulpd  %xmm8,%xmm5
mulpd  %xmm9,%xmm3
addpd  %xmm5,%xmm3
movupd 0x0(%rbp,%rax,8),%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm3,%xmm5
divpd  %xmm2,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r8,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    2010 <stiff+0xec0>
mov    %r14,%rbp
mov    0x8(%rsp),%r11
cmp    %r11,%r14
movsd  0xfe6(%rip),%xmm4
movsd  0xfe6(%rip),%xmm5
movsd  0xfe6(%rip),%xmm7
je     2119 <stiff+0xfc9>
mov    0x180(%rsp),%rax
lea    (%rax,%rbp,8),%r10
mov    0xb8(%rsp),%rax
lea    (%rax,%rbp,8),%r9
mov    0x68(%rsp),%rax
lea    -0x10(%rax,%rbp,8),%rdx
mov    0x80(%rsp),%rax
lea    -0x30(%rax,%rbp,8),%rsi
lea    (%rcx,%rbp,8),%rcx
lea    (%rbx,%rbp,8),%rbx
mov    %r11,%rax
sub    %rbp,%rax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rbp,8),%xmm1
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm4,%xmm2
movsd  (%rsi,%rbp,8),%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
movsd  (%r9,%rbp,8),%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm6,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r10,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    20d0 <stiff+0xf80>
mov    0x1c(%rsp),%ebx
mov    %ebx,%esi
mov    %ebx,%edx
lea    0x1a0(%rsp),%rcx
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <sgesl@plt>
mov    0xc0(%rsp),%rsi
test   %ebx,%ebx
mov    0x150(%rsp),%rcx
mov    0x40(%rsp),%r9
mov    0x148(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x70(%rsp),%rbp
mov    0xa0(%rsp),%rbx
mov    0x48(%rsp),%r10
mov    0x190(%rsp),%rdx
movsd  0xe86(%rip),%xmm8
movsd  0xeee(%rip),%xmm3
movsd  0xeee(%rip),%xmm4
movsd  0xeee(%rip),%xmm5
movsd  0xeee(%rip),%xmm6
movsd  0xeee(%rip),%xmm7
xorpd  %xmm2,%xmm2
movsd  0xd0(%rsp),%xmm9
jle    223e <stiff+0x10ee>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,1),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%r10,%rax,1),%xmm0
movsd  0x0(%rbp,%rax,1),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rbx,%rax,1),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%rax,1),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rax,1)
movsd  0x0(%rbp,%rax,1),%xmm0
mulsd  %xmm6,%xmm0
movsd  (%rdi,%rax,1),%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rbx,%rax,1),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%rax,1),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rax,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    21c0 <stiff+0x1070>
mov    0xc8(%rsp),%rax
movsd  %xmm9,(%rax)
ucomisd 0xa8(%rsp),%xmm9
jne    225d <stiff+0x110d>
jnp    2ac4 <stiff+0x1974>
mov    0x1c(%rsp),%ebp
test   %ebp,%ebp
jle    22e0 <stiff+0x1190>
cmpq   $0x0,0x88(%rsp)
je     2300 <stiff+0x11b0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
movapd 0x50(%rsp),%xmm3
mov    0x188(%rsp),%rdx
lea    0x1a0(%rsp),%rbx
movapd 0xec8(%rip),%xmm4
mov    0x8(%rsp),%r13
nopl   (%rax)
movsd  -0x8(%rdx,%rax,8),%xmm1
movsd  (%rdx,%rax,8),%xmm2
divsd  (%rcx,%rax,8),%xmm1
andpd  %xmm4,%xmm1
maxsd  %xmm1,%xmm0
divsd  0x8(%rcx,%rax,8),%xmm2
andpd  %xmm4,%xmm2
maxsd  %xmm2,%xmm0
add    $0x2,%rax
cmp    %rax,%r14
jne    22a0 <stiff+0x1150>
test   $0x1,%r13b
jne    231f <stiff+0x11cf>
jmp    2336 <stiff+0x11e6>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movapd 0x50(%rsp),%xmm3
lea    0x1a0(%rsp),%rbx
mov    0x8(%rsp),%r13
jmp    2336 <stiff+0x11e6>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
movapd 0x50(%rsp),%xmm3
lea    0x1a0(%rsp),%rbx
mov    0x8(%rsp),%r13
test   $0x1,%r13b
je     2336 <stiff+0x11e6>
movsd  (%r8,%rax,8),%xmm1
divsd  (%rcx,%rax,8),%xmm1
andpd  0xe2e(%rip),%xmm1
maxsd  %xmm1,%xmm0
divsd  0x198(%rsp),%xmm0
movsd  0xcc1(%rip),%xmm1
ucomisd %xmm0,%xmm1
jae    2ad4 <stiff+0x1984>
movapd %xmm3,%xmm1
mulsd  0xd4b(%rip),%xmm1
movapd %xmm1,0xd0(%rsp)
movsd  0xd4a(%rip),%xmm1
call   1070 <pow@plt>
xorpd  %xmm3,%xmm3
movsd  0xc81(%rip),%xmm2
mulsd  0xd0(%rsp),%xmm0
movapd 0x50(%rsp),%xmm4
movapd %xmm4,%xmm1
mulsd  %xmm2,%xmm1
xor    %eax,%eax
ucomisd %xmm0,%xmm1
seta   %al
xor    %ecx,%ecx
ucomisd %xmm1,%xmm0
seta   %cl
ucomisd %xmm3,%xmm4
mov    0xcd0(%rsp),%rdx
movsd  %xmm0,(%rdx)
cmovb  %eax,%ecx
test   %cl,%cl
jne    19d0 <stiff+0x880>
movapd %xmm1,%xmm0
jmp    19d0 <stiff+0x880>
xor    %eax,%eax
mov    0x38(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0xf8(%rsp),%rsi
mov    0x78(%rsp),%rbp
mov    0xb0(%rsp),%rbx
testb  $0x1,0x138(%rsp)
01
mov    0xcd8(%rsp),%rdi
je     243c <stiff+0x12ec>
mov    0x98(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm2
movupd 0x10(%rcx,%rax,8),%xmm3
movupd (%r9,%rax,8),%xmm4
movupd 0x10(%r9,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%r8,%rax,8)
movupd %xmm5,0x10(%r8,%rax,8)
mov    0xf0(%rsp),%rax
mov    %rax,%rcx
mov    0x8(%rsp),%rdx
cmp    %rdx,%rax
je     24c5 <stiff+0x1375>
mov    %rcx,%rax
test   $0x1,%dl
je     247d <stiff+0x132d>
movsd  (%r9,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x98(%rsp),%rax
addsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%r8,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x100(%rsp),%rcx
mov    0x8(%rsp),%rcx
je     24c5 <stiff+0x1375>
nop
movsd  -0x30(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x30(%rsi,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rax,8)
movsd  -0x28(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x28(%rsi,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    2490 <stiff+0x1340>
mov    %r13d,%ebp
mov    %r13d,%esi
mov    %r13d,%edx
lea    0x1a0(%rsp),%rbx
mov    %rbx,%rcx
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <sgesl@plt>
test   %r13d,%r13d
jle    1be2 <stiff+0xa92>
cmp    $0x4,%ebp
setb   %al
or     0x34(%rsp),%al
movapd 0x50(%rsp),%xmm4
mov    0x10(%rsp),%rsi
mov    0x40(%rsp),%rdi
mov    0x80(%rsp),%rdx
je     2533 <stiff+0x13e3>
xor    %ecx,%ecx
mov    0x20(%rsp),%r9
mov    0x48(%rsp),%r8
mov    0xe0(%rsp),%r10
mov    0x78(%rsp),%rbp
mov    0x8(%rsp),%rdx
jmp    263b <stiff+0x14eb>
cmpq   $0x0,0x140(%rsp)
mov    0x20(%rsp),%r9
mov    0x48(%rsp),%r8
mov    0x130(%rsp),%rbx
mov    0xe0(%rsp),%r10
mov    0x78(%rsp),%rbp
je     2a7b <stiff+0x192b>
mov    0xe8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rbx,%rax,8),%xmm0
movupd -0x20(%rbx,%rax,8),%xmm1
movupd -0x30(%rdx,%rax,8),%xmm2
movupd -0x20(%rdx,%rax,8),%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
movupd -0x10(%rbx,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm1
movupd -0x10(%rdx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rdi,%rax,8)
movupd %xmm3,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2570 <stiff+0x1420>
testb  $0x1,0x138(%rsp)
01
je     261e <stiff+0x14ce>
movupd (%r8,%rax,8),%xmm0
movupd 0x10(%r8,%rax,8),%xmm1
movupd (%r9,%rax,8),%xmm2
movupd 0x10(%r9,%rax,8),%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
mov    0xf0(%rsp),%rax
mov    %rax,%rcx
mov    0x8(%rsp),%rdx
cmp    %rdx,%rax
lea    0x1a0(%rsp),%rbx
je     26b5 <stiff+0x1565>
mov    %rcx,%rax
test   $0x1,%dl
je     265f <stiff+0x150f>
movsd  (%r9,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
addsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x100(%rsp),%rcx
mov    0x8(%rsp),%rcx
je     26b5 <stiff+0x1565>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rax,8),%xmm0
addsd  %xmm0,%xmm0
addsd  -0x8(%r10,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
addsd  %xmm0,%xmm0
addsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    2680 <stiff+0x1530>
movsd  0xa8(%rsp),%xmm0
addsd  %xmm4,%xmm0
mov    0xc8(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  %xmm0,0xd0(%rsp)
mov    %r13d,%ebp
mov    %r13d,%edx
mov    $0x1,%al
call   1050 <rhs@plt>
test   %r13d,%r13d
jle    1c19 <stiff+0xac9>
cmp    $0x1,%ebp
sete   %al
movapd 0x50(%rsp),%xmm5
movapd %xmm5,%xmm0
mulsd  0x90b(%rip),%xmm0
or     0x33(%rsp),%al
mov    0xcd8(%rsp),%rdi
mov    0x38(%rsp),%r11
mov    0x70(%rsp),%r8
mov    0x80(%rsp),%r10
movsd  0x8ed(%rip),%xmm6
je     273e <stiff+0x15ee>
xor    %ebp,%ebp
mov    0x10(%rsp),%rsi
mov    0x68(%rsp),%rbx
jmp    2833 <stiff+0x16e3>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm5,%xmm2
unpcklpd %xmm5,%xmm2
cmpq   $0x0,0x178(%rsp)
mov    0x128(%rsp),%rbp
movapd 0x969(%rip),%xmm7
mov    0xb0(%rsp),%rdx
je     2a90 <stiff+0x1940>
mov    0x168(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%rsi
mov    0x20(%rsp),%r9
mov    0x68(%rsp),%rbx
xchg   %ax,%ax
movupd (%rsi,%rax,8),%xmm3
movupd -0x30(%rdx,%rax,8),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
movupd -0x10(%rbp,%rax,8),%xmm3
mulpd  %xmm7,%xmm3
divpd  %xmm2,%xmm3
subpd  %xmm3,%xmm4
movupd %xmm4,-0x10(%rbx,%rax,8)
movupd 0x10(%rsi,%rax,8),%xmm3
movupd -0x20(%rdx,%rax,8),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm3,%xmm4
movupd 0x0(%rbp,%rax,8),%xmm3
mulpd  %xmm7,%xmm3
divpd  %xmm2,%xmm3
subpd  %xmm3,%xmm4
movupd %xmm4,(%rbx,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    2790 <stiff+0x1640>
testb  $0x1,0x170(%rsp)
01
je     2829 <stiff+0x16d9>
movupd (%rsi,%rax,8),%xmm3
movupd (%r11,%rax,8),%xmm4
mulpd  %xmm4,%xmm1
addpd  %xmm3,%xmm1
movupd (%r9,%rax,8),%xmm3
mulpd  0x8c5(%rip),%xmm3
divpd  %xmm2,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,(%r8,%rax,8)
mov    %r14,%rbp
cmp    0x8(%rsp),%r14
je     288d <stiff+0x173d>
lea    (%rbx,%rbp,8),%rax
add    $0xfffffffffffffff0,%rax
lea    -0x30(%r10,%rbp,8),%rcx
lea    (%r11,%rbp,8),%rdx
lea    (%rsi,%rbp,8),%rsi
mov    0x8(%rsp),%rbx
sub    %rbp,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rbp,8),%xmm1
movsd  (%rcx,%rbp,8),%xmm2
mulsd  %xmm6,%xmm2
divsd  %xmm5,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2860 <stiff+0x1710>
mov    %r13d,%ebp
mov    %r13d,%esi
mov    %r13d,%edx
lea    0x1a0(%rsp),%rbx
mov    %rbx,%rcx
xor    %r9d,%r9d
xor    %eax,%eax
call   1060 <sgesl@plt>
test   %r13d,%r13d
jle    1c37 <stiff+0xae7>
cmp    $0x4,%ebp
setb   %al
or     0x32(%rsp),%al
je     28eb <stiff+0x179b>
xor    %ecx,%ecx
movapd 0x50(%rsp),%xmm4
mov    0x10(%rsp),%rsi
mov    0x40(%rsp),%rdi
mov    0x20(%rsp),%r10
mov    0x70(%rsp),%r8
mov    0x48(%rsp),%r9
mov    0x68(%rsp),%rbx
jmp    29b9 <stiff+0x1869>
xor    %eax,%eax
movapd 0x50(%rsp),%xmm4
mov    0x10(%rsp),%rsi
mov    0x40(%rsp),%rdi
mov    0x20(%rsp),%r10
mov    0x70(%rsp),%r8
mov    0x48(%rsp),%r9
mov    0x130(%rsp),%rcx
mov    0x128(%rsp),%rbp
mov    0x68(%rsp),%rbx
mov    0x160(%rsp),%rdx
movapd 0x7bf(%rip),%xmm5
movapd 0x7c7(%rip),%xmm6
nopl   0x0(%rax)
movupd -0x30(%rcx,%rax,1),%xmm0
movupd -0x20(%rcx,%rax,1),%xmm1
movupd -0x10(%rbp,%rax,1),%xmm2
movupd 0x0(%rbp,%rax,1),%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd -0x10(%rbx,%rax,1),%xmm0
movupd (%rbx,%rax,1),%xmm1
mulpd  %xmm6,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm6,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rax,1)
movupd %xmm1,0x10(%rdi,%rax,1)
add    $0x20,%rax
cmp    %rax,%rdx
jne    2940 <stiff+0x17f0>
mov    0xf0(%rsp),%rax
mov    %rax,%rcx
cmp    0x8(%rsp),%rax
mov    %r13d,%ebp
jne    29b9 <stiff+0x1869>
lea    0x1a0(%rsp),%rbx
jmp    1c47 <stiff+0xaf7>
mov    %rcx,%rax
mov    0x8(%rsp),%r13
test   $0x1,%r13b
movsd  0x653(%rip),%xmm2
movsd  0x653(%rip),%xmm3
je     2a01 <stiff+0x18b1>
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r9,%rcx,8),%xmm0
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x100(%rsp),%rcx
je     2a6e <stiff+0x191e>
mov    0xe0(%rsp),%rcx
mov    0x78(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x8(%rcx,%rax,8),%xmm0
movsd  -0x10(%rbx,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  -0x8(%rbx,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    2a20 <stiff+0x18d0>
lea    0x1a0(%rsp),%rbx
jmp    1c4c <stiff+0xafc>
xor    %eax,%eax
testb  $0x1,0x138(%rsp)
01
jne    25e9 <stiff+0x1499>
jmp    261e <stiff+0x14ce>
xor    %eax,%eax
mov    0x10(%rsp),%rsi
mov    0x20(%rsp),%r9
mov    0x68(%rsp),%rbx
testb  $0x1,0x170(%rsp)
01
jne    27fa <stiff+0x16aa>
jmp    2829 <stiff+0x16d9>
mov    0xce0(%rsp),%rax
movl   $0xffffffff,(%rax)
jmp    2b1b <stiff+0x19cb>
mov    0xce0(%rsp),%rax
movl   $0x1,(%rax)
jmp    2b1b <stiff+0x19cb>
mov    0x158(%rsp),%rax
movsd  %xmm3,(%rax)
ucomisd 0x5b0(%rip),%xmm0
jbe    2b22 <stiff+0x19d2>
mulsd  0x5b6(%rip),%xmm3
movapd %xmm3,0x50(%rsp)
movsd  0x5b0(%rip),%xmm1
call   1070 <pow@plt>
mulsd  0x50(%rsp),%xmm0
jmp    2b2e <stiff+0x19de>
mov    0xce0(%rsp),%rax
movl   $0x4,(%rax)
mov    $0xffffffff,%eax
jmp    2b3c <stiff+0x19ec>
mulsd  0x576(%rip),%xmm3
movapd %xmm3,%xmm0
mov    0xcd0(%rsp),%rax
movsd  %xmm0,(%rax)
xor    %eax,%eax
add    $0xc98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @stiff(double* %0, double* %1, i32 %2, double* nocapture %3, double %4, double %5, double* nocapture %6, double* nocapture writeonly %7, double* nocapture writeonly %8, double* %9, double %10, i32* nocapture writeonly %11) {
%13 = alloca [700 x i32]
%14 = alloca i32
%15 = bitcast [700 x i32]* %13 to i8*
%16 = bitcast i32* %14 to i8*
store i32 0, i32* %11
%17 = mul nsw i32 %2, %2
%18 = zext i32 %17 to i64
%19 = getelementptr double, double* %9, i64 %18
%20 = sext i32 %2 to i64
%21 = getelementptr inbounds double, double* %19, i64 %20
%22 = getelementptr double, double* %21, i64 %18
%23 = getelementptr inbounds double, double* %22, i64 %20
%24 = getelementptr double, double* %23, i64 %20
%25 = getelementptr double, double* %24, i64 %20
%26 = getelementptr double, double* %25, i64 %20
%27 = getelementptr double, double* %26, i64 %20
%28 = getelementptr double, double* %27, i64 %20
%29 = getelementptr inbounds double, double* %28, i64 %20
%30 = load double, double* %3
%31 = icmp sgt i32 %2, 0
br i1 %31, label %32, label %181
32: ; preds = %12
%33 = zext i32 %2 to i64
%34 = icmp ult i32 %2, 4
br i1 %34, label %147, label %35
35: ; preds = %32
%36 = mul nsw i64 %20, 7
%37 = shl nuw nsw i64 %18, 1
%38 = add nsw i64 %36, %37
%39 = add nsw i64 %38, %33
%40 = getelementptr double, double* %9, i64 %39
%41 = add nsw i64 %37, %20
%42 = add nsw i64 %41, %33
%43 = getelementptr double, double* %9, i64 %42
%44 = getelementptr double, double* %0, i64 %33
%45 = getelementptr double, double* %1, i64 %33
%46 = icmp ult double* %28, %43
%47 = icmp ult double* %22, %40
%48 = and i1 %46, %47
%49 = icmp ult double* %28, %44
%50 = icmp ugt double* %40, %0
%51 = and i1 %49, %50
%52 = or i1 %48, %51
%53 = icmp ult double* %28, %45
%54 = icmp ugt double* %40, %1
%55 = and i1 %53, %54
%56 = or i1 %52, %55
%57 = icmp ult double* %22, %44
%58 = icmp ugt double* %43, %0
%59 = and i1 %57, %58
%60 = or i1 %56, %59
%61 = icmp ult double* %22, %45
%62 = icmp ugt double* %43, %1
%63 = and i1 %61, %62
%64 = or i1 %60, %63
br i1 %64, label %147, label %65
65: ; preds = %35
%66 = and i64 %33, 4294967292
%67 = add nsw i64 %66, -4
%68 = lshr exact i64 %67, 2
%69 = add nuw nsw i64 %68, 1
%70 = and i64 %69, 1
%71 = icmp eq i64 %67, 0
br i1 %71, label %121, label %72
72: ; preds = %65
%73 = and i64 %69, 9223372036854775806
br label %74
74: ; preds = %74, %72
%75 = phi i64 [ 0, %72 ], [ %118, %74 ]
%76 = phi i64 [ 0, %72 ], [ %119, %74 ]
%77 = getelementptr inbounds double, double* %0, i64 %75
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = getelementptr inbounds double, double* %77, i64 2
%81 = bitcast double* %80 to <2 x double>*
%82 = load <2 x double>, <2 x double>* %81
%83 = getelementptr inbounds double, double* %28, i64 %75
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> %79, <2 x double>* %84
%85 = getelementptr inbounds double, double* %83, i64 2
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> %82, <2 x double>* %86
%87 = getelementptr inbounds double, double* %1, i64 %75
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr inbounds double, double* %87, i64 2
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %22, i64 %75
%94 = bitcast double* %93 to <2 x double>*
store <2 x double> %89, <2 x double>* %94
%95 = getelementptr inbounds double, double* %93, i64 2
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> %92, <2 x double>* %96
%97 = or i64 %75, 4
%98 = getelementptr inbounds double, double* %0, i64 %97
%99 = bitcast double* %98 to <2 x double>*
%100 = load <2 x double>, <2 x double>* %99
%101 = getelementptr inbounds double, double* %98, i64 2
%102 = bitcast double* %101 to <2 x double>*
%103 = load <2 x double>, <2 x double>* %102
%104 = getelementptr inbounds double, double* %28, i64 %97
%105 = bitcast double* %104 to <2 x double>*
store <2 x double> %100, <2 x double>* %105
%106 = getelementptr inbounds double, double* %104, i64 2
%107 = bitcast double* %106 to <2 x double>*
store <2 x double> %103, <2 x double>* %107
%108 = getelementptr inbounds double, double* %1, i64 %97
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = getelementptr inbounds double, double* %108, i64 2
%112 = bitcast double* %111 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = getelementptr inbounds double, double* %22, i64 %97
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %110, <2 x double>* %115
%116 = getelementptr inbounds double, double* %114, i64 2
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> %113, <2 x double>* %117
%118 = add nuw i64 %75, 8
%119 = add i64 %76, 2
%120 = icmp eq i64 %119, %73
br i1 %120, label %121, label %74
121: ; preds = %74, %65
%122 = phi i64 [ 0, %65 ], [ %118, %74 ]
%123 = icmp eq i64 %70, 0
br i1 %123, label %145, label %124
124: ; preds = %121
%125 = getelementptr inbounds double, double* %0, i64 %122
%126 = bitcast double* %125 to <2 x double>*
%127 = load <2 x double>, <2 x double>* %126
%128 = getelementptr inbounds double, double* %125, i64 2
%129 = bitcast double* %128 to <2 x double>*
%130 = load <2 x double>, <2 x double>* %129
%131 = getelementptr inbounds double, double* %28, i64 %122
%132 = bitcast double* %131 to <2 x double>*
store <2 x double> %127, <2 x double>* %132
%133 = getelementptr inbounds double, double* %131, i64 2
%134 = bitcast double* %133 to <2 x double>*
store <2 x double> %130, <2 x double>* %134
%135 = getelementptr inbounds double, double* %1, i64 %122
%136 = bitcast double* %135 to <2 x double>*
%137 = load <2 x double>, <2 x double>* %136
%138 = getelementptr inbounds double, double* %135, i64 2
%139 = bitcast double* %138 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = getelementptr inbounds double, double* %22, i64 %122
%142 = bitcast double* %141 to <2 x double>*
store <2 x double> %137, <2 x double>* %142
%143 = getelementptr inbounds double, double* %141, i64 2
%144 = bitcast double* %143 to <2 x double>*
store <2 x double> %140, <2 x double>* %144
br label %145
145: ; preds = %121, %124
%146 = icmp eq i64 %66, %33
br i1 %146, label %181, label %147
147: ; preds = %35, %32, %145
%148 = phi i64 [ 0, %35 ], [ 0, %32 ], [ %66, %145 ]
%149 = xor i64 %148, -1
%150 = and i64 %33, 1
%151 = icmp eq i64 %150, 0
br i1 %151, label %160, label %152
152: ; preds = %147
%153 = getelementptr inbounds double, double* %0, i64 %148
%154 = load double, double* %153
%155 = getelementptr inbounds double, double* %28, i64 %148
store double %154, double* %155
%156 = getelementptr inbounds double, double* %1, i64 %148
%157 = load double, double* %156
%158 = getelementptr inbounds double, double* %22, i64 %148
store double %157, double* %158
%159 = or i64 %148, 1
br label %160
160: ; preds = %152, %147
%161 = phi i64 [ %148, %147 ], [ %159, %152 ]
%162 = sub nsw i64 0, %33
%163 = icmp eq i64 %149, %162
br i1 %163, label %181, label %164
164: ; preds = %160, %164
%165 = phi i64 [ %179, %164 ], [ %161, %160 ]
%166 = getelementptr inbounds double, double* %0, i64 %165
%167 = load double, double* %166
%168 = getelementptr inbounds double, double* %28, i64 %165
store double %167, double* %168
%169 = getelementptr inbounds double, double* %1, i64 %165
%170 = load double, double* %169
%171 = getelementptr inbounds double, double* %22, i64 %165
store double %170, double* %171
%172 = add nuw nsw i64 %165, 1
%173 = getelementptr inbounds double, double* %0, i64 %172
%174 = load double, double* %173
%175 = getelementptr inbounds double, double* %28, i64 %172
store double %174, double* %175
%176 = getelementptr inbounds double, double* %1, i64 %172
%177 = load double, double* %176
%178 = getelementptr inbounds double, double* %22, i64 %172
store double %177, double* %178
%179 = add nuw nsw i64 %165, 2
%180 = icmp eq i64 %179, %33
br i1 %180, label %181, label %164
181: ; preds = %160, %164, %145, %12
%182 = tail call i32 (double, double*, double*, double*, double, double*, i32, ...) bitcast (i32 (...)* @jacobn to i32 (double, double*, double*, double*, double, double*, i32, ...)*)(double %30, double* %28, double* %19, double* %21, double %10, double* %29, i32 %2)
%183 = getelementptr inbounds [700 x i32], [700 x i32]* %13, i64 0, i64 0
%184 = zext i32 %2 to i64
%185 = zext i32 %2 to i64
%186 = zext i32 %2 to i64
%187 = zext i32 %2 to i64
%188 = zext i32 %2 to i64
%189 = zext i32 %2 to i64
%190 = zext i32 %2 to i64
%191 = zext i32 %2 to i64
%192 = zext i32 %2 to i64
%193 = mul nsw i64 %20, 6
%194 = shl nuw nsw i64 %18, 1
%195 = add nsw i64 %193, %194
%196 = add nsw i64 %195, %184
%197 = getelementptr double, double* %9, i64 %196
%198 = getelementptr double, double* %1, i64 %184
%199 = mul nsw i64 %20, 3
%200 = add nsw i64 %199, %194
%201 = add nsw i64 %200, %184
%202 = getelementptr double, double* %9, i64 %201
%203 = add nuw nsw i64 %184, %18
%204 = getelementptr double, double* %9, i64 %203
%205 = shl nsw i64 %20, 2
%206 = add nsw i64 %205, %194
%207 = add nsw i64 %206, %184
%208 = getelementptr double, double* %9, i64 %207
%209 = mul nsw i64 %20, 5
%210 = add nsw i64 %209, %194
%211 = add nsw i64 %210, %184
%212 = getelementptr double, double* %9, i64 %211
%213 = mul nsw i64 %20, 5
%214 = shl nuw nsw i64 %18, 1
%215 = add nsw i64 %213, %214
%216 = add nsw i64 %215, %184
%217 = getelementptr double, double* %9, i64 %216
%218 = getelementptr double, double* %1, i64 %184
%219 = mul nsw i64 %20, 3
%220 = add nsw i64 %219, %214
%221 = add nsw i64 %220, %184
%222 = getelementptr double, double* %9, i64 %221
%223 = add nuw nsw i64 %184, %18
%224 = getelementptr double, double* %9, i64 %223
%225 = shl nsw i64 %20, 2
%226 = add nsw i64 %225, %214
%227 = add nsw i64 %226, %184
%228 = getelementptr double, double* %9, i64 %227
%229 = getelementptr double, double* %0, i64 %184
%230 = mul nsw i64 %20, 7
%231 = shl nuw nsw i64 %18, 1
%232 = add nsw i64 %230, %231
%233 = add nsw i64 %232, %184
%234 = getelementptr double, double* %9, i64 %233
%235 = mul nsw i64 %20, 3
%236 = add nsw i64 %235, %231
%237 = add nsw i64 %236, %184
%238 = getelementptr double, double* %9, i64 %237
%239 = shl nsw i64 %20, 2
%240 = add nsw i64 %239, %231
%241 = add nsw i64 %240, %184
%242 = getelementptr double, double* %9, i64 %241
%243 = shl nsw i64 %20, 2
%244 = shl nuw nsw i64 %18, 1
%245 = add nsw i64 %243, %244
%246 = add nsw i64 %245, %184
%247 = getelementptr double, double* %9, i64 %246
%248 = getelementptr double, double* %1, i64 %184
%249 = mul nsw i64 %20, 3
%250 = add nsw i64 %249, %244
%251 = add nsw i64 %250, %184
%252 = getelementptr double, double* %9, i64 %251
%253 = add nuw nsw i64 %184, %18
%254 = getelementptr double, double* %9, i64 %253
%255 = getelementptr double, double* %0, i64 %184
%256 = mul nsw i64 %20, 7
%257 = shl nuw nsw i64 %18, 1
%258 = add nsw i64 %256, %257
%259 = add nsw i64 %258, %184
%260 = getelementptr double, double* %9, i64 %259
%261 = mul nsw i64 %20, 3
%262 = add nsw i64 %261, %257
%263 = add nsw i64 %262, %184
%264 = getelementptr double, double* %9, i64 %263
%265 = mul nsw i64 %20, 3
%266 = shl nuw nsw i64 %18, 1
%267 = add nsw i64 %265, %266
%268 = add nsw i64 %267, %184
%269 = getelementptr double, double* %9, i64 %268
%270 = add nsw i64 %266, %20
%271 = add nsw i64 %270, %184
%272 = getelementptr double, double* %9, i64 %271
%273 = add nuw nsw i64 %184, %18
%274 = getelementptr double, double* %9, i64 %273
%275 = add nsw i64 %192, -1
%276 = and i64 %192, 4294967292
%277 = add nsw i64 %276, -4
%278 = lshr exact i64 %277, 2
%279 = add nuw nsw i64 %278, 1
%280 = and i64 %192, 4294967294
%281 = add nsw i64 %280, -2
%282 = lshr exact i64 %281, 1
%283 = add nuw i64 %282, 1
%284 = and i64 %192, 1
%285 = icmp eq i64 %275, 0
%286 = and i64 %192, 4294967294
%287 = icmp eq i64 %284, 0
%288 = icmp ult i32 %2, 4
%289 = icmp ult double* %24, %272
%290 = icmp ult double* %22, %269
%291 = and i1 %289, %290
%292 = icmp ult double* %24, %274
%293 = icmp ult double* %19, %269
%294 = and i1 %292, %293
%295 = or i1 %291, %294
%296 = and i64 %184, 4294967292
%297 = and i64 %279, 1
%298 = icmp eq i64 %277, 0
%299 = and i64 %279, 9223372036854775806
%300 = icmp eq i64 %297, 0
%301 = icmp eq i64 %296, %184
%302 = and i64 %192, 1
%303 = icmp eq i64 %302, 0
%304 = sub nsw i64 0, %192
%305 = icmp ult i32 %2, 4
%306 = icmp ugt double* %260, %0
%307 = icmp ult double* %28, %255
%308 = and i1 %306, %307
%309 = icmp ugt double* %264, %0
%310 = icmp ult double* %24, %255
%311 = and i1 %309, %310
%312 = or i1 %308, %311
%313 = and i64 %184, 4294967292
%314 = and i64 %279, 1
%315 = icmp eq i64 %277, 0
%316 = and i64 %279, 9223372036854775806
%317 = icmp eq i64 %314, 0
%318 = icmp eq i64 %313, %184
%319 = and i64 %192, 1
%320 = icmp eq i64 %319, 0
%321 = sub nsw i64 0, %192
%322 = icmp eq i32 %2, 1
%323 = icmp ult double* %25, %248
%324 = icmp ugt double* %247, %1
%325 = and i1 %323, %324
%326 = icmp ult double* %25, %252
%327 = icmp ult double* %24, %247
%328 = and i1 %326, %327
%329 = or i1 %325, %328
%330 = icmp ult double* %25, %254
%331 = icmp ult double* %19, %247
%332 = and i1 %330, %331
%333 = or i1 %329, %332
%334 = and i64 %184, 4294967294
%335 = and i64 %283, 1
%336 = icmp eq i64 %281, 0
%337 = and i64 %283, -2
%338 = icmp eq i64 %335, 0
%339 = icmp eq i64 %334, %184
%340 = icmp ult i32 %2, 4
%341 = icmp ugt double* %234, %0
%342 = icmp ult double* %28, %229
%343 = and i1 %341, %342
%344 = icmp ugt double* %238, %0
%345 = icmp ult double* %24, %229
%346 = and i1 %344, %345
%347 = or i1 %343, %346
%348 = icmp ugt double* %242, %0
%349 = icmp ult double* %25, %229
%350 = and i1 %348, %349
%351 = or i1 %347, %350
%352 = and i64 %184, 4294967292
%353 = icmp eq i64 %352, %184
%354 = and i64 %192, 1
%355 = icmp eq i64 %354, 0
%356 = sub nsw i64 0, %192
%357 = icmp eq i32 %2, 1
%358 = icmp ult double* %26, %218
%359 = icmp ugt double* %217, %1
%360 = and i1 %358, %359
%361 = icmp ult double* %26, %222
%362 = icmp ult double* %24, %217
%363 = and i1 %361, %362
%364 = or i1 %360, %363
%365 = icmp ult double* %26, %224
%366 = icmp ult double* %19, %217
%367 = and i1 %365, %366
%368 = or i1 %364, %367
%369 = icmp ult double* %26, %228
%370 = icmp ult double* %25, %217
%371 = and i1 %369, %370
%372 = or i1 %368, %371
%373 = and i64 %184, 4294967294
%374 = icmp eq i64 %373, %184
%375 = icmp eq i32 %2, 1
%376 = icmp ult double* %27, %198
%377 = icmp ugt double* %197, %1
%378 = and i1 %376, %377
%379 = icmp ult double* %27, %202
%380 = icmp ult double* %24, %197
%381 = and i1 %379, %380
%382 = or i1 %378, %381
%383 = icmp ult double* %27, %204
%384 = icmp ult double* %19, %197
%385 = and i1 %383, %384
%386 = or i1 %382, %385
%387 = icmp ult double* %27, %208
%388 = icmp ult double* %25, %197
%389 = and i1 %387, %388
%390 = or i1 %386, %389
%391 = icmp ult double* %27, %212
%392 = icmp ult double* %26, %197
%393 = and i1 %391, %392
%394 = or i1 %390, %393
%395 = and i64 %184, 4294967294
%396 = icmp eq i64 %395, %184
%397 = and i64 %192, 1
%398 = icmp eq i64 %275, 0
%399 = and i64 %192, 4294967294
%400 = icmp eq i64 %397, 0
br label %401
401: ; preds = %181, %1034
%402 = phi i32 [ 1, %181 ], [ %1044, %1034 ]
%403 = phi double [ %4, %181 ], [ %1043, %1034 ]
br i1 %31, label %404, label %449
404: ; preds = %401
%405 = fmul double %403, 5.000000e-01
%406 = fdiv double 1.000000e+00, %405
br label %407
407: ; preds = %437, %404
%408 = phi i64 [ 0, %404 ], [ %443, %437 ]
br i1 %285, label %428, label %409
409: ; preds = %407, %409
%410 = phi i64 [ %425, %409 ], [ 0, %407 ]
%411 = phi i64 [ %426, %409 ], [ 0, %407 ]
%412 = mul nsw i64 %410, %20
%413 = add nsw i64 %412, %408
%414 = getelementptr inbounds double, double* %21, i64 %413
%415 = load double, double* %414
%416 = fneg double %415
%417 = getelementptr inbounds double, double* %9, i64 %413
store double %416, double* %417
%418 = or i64 %410, 1
%419 = mul nsw i64 %418, %20
%420 = add nsw i64 %419, %408
%421 = getelementptr inbounds double, double* %21, i64 %420
%422 = load double, double* %421
%423 = fneg double %422
%424 = getelementptr inbounds double, double* %9, i64 %420
store double %423, double* %424
%425 = add nuw nsw i64 %410, 2
%426 = add i64 %411, 2
%427 = icmp eq i64 %426, %286
br i1 %427, label %428, label %409
428: ; preds = %409, %407
%429 = phi i64 [ 0, %407 ], [ %425, %409 ]
br i1 %287, label %437, label %430
430: ; preds = %428
%431 = mul nsw i64 %429, %20
%432 = add nsw i64 %431, %408
%433 = getelementptr inbounds double, double* %21, i64 %432
%434 = load double, double* %433
%435 = fneg double %434
%436 = getelementptr inbounds double, double* %9, i64 %432
store double %435, double* %436
br label %437
437: ; preds = %428, %430
%438 = mul nsw i64 %408, %20
%439 = add nsw i64 %438, %408
%440 = getelementptr inbounds double, double* %9, i64 %439
%441 = load double, double* %440
%442 = fadd double %406, %441
store double %442, double* %440
%443 = add nuw nsw i64 %408, 1
%444 = icmp eq i64 %443, %184
br i1 %444, label %445, label %407
445: ; preds = %437
%446 = call i32 (double*, i32, i32, i32*, i32*, ...) bitcast (i32 (...)* @sgefa to i32 (double*, i32, i32, i32*, i32*, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, i32* %14)
%447 = load i32, i32* %14
%448 = icmp eq i32 %447, -1
br i1 %448, label %453, label %541
449: ; preds = %401
%450 = call i32 (double*, i32, i32, i32*, i32*, ...) bitcast (i32 (...)* @sgefa to i32 (double*, i32, i32, i32*, i32*, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, i32* %14)
%451 = load i32, i32* %14
%452 = icmp eq i32 %451, -1
br i1 %452, label %559, label %541
453: ; preds = %445
br i1 %31, label %454, label %559
454: ; preds = %453
%455 = fmul double %403, 5.000000e-01
%456 = select i1 %288, i1 true, i1 %295
br i1 %456, label %527, label %457
457: ; preds = %454
%458 = insertelement <2 x double> poison, double %455, i64 0
%459 = shufflevector <2 x double> %458, <2 x double> poison, <2 x i32> zeroinitializer
%460 = insertelement <2 x double> poison, double %455, i64 0
%461 = shufflevector <2 x double> %460, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %298, label %505, label %462
462: ; preds = %457, %462
%463 = phi i64 [ %502, %462 ], [ 0, %457 ]
%464 = phi i64 [ %503, %462 ], [ 0, %457 ]
%465 = getelementptr inbounds double, double* %22, i64 %463
%466 = bitcast double* %465 to <2 x double>*
%467 = load <2 x double>, <2 x double>* %466
%468 = getelementptr inbounds double, double* %465, i64 2
%469 = bitcast double* %468 to <2 x double>*
%470 = load <2 x double>, <2 x double>* %469
%471 = getelementptr inbounds double, double* %19, i64 %463
%472 = bitcast double* %471 to <2 x double>*
%473 = load <2 x double>, <2 x double>* %472
%474 = getelementptr inbounds double, double* %471, i64 2
%475 = bitcast double* %474 to <2 x double>*
%476 = load <2 x double>, <2 x double>* %475
%477 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %459, <2 x double> %473, <2 x double> %467)
%478 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %461, <2 x double> %476, <2 x double> %470)
%479 = getelementptr inbounds double, double* %24, i64 %463
%480 = bitcast double* %479 to <2 x double>*
store <2 x double> %477, <2 x double>* %480
%481 = getelementptr inbounds double, double* %479, i64 2
%482 = bitcast double* %481 to <2 x double>*
store <2 x double> %478, <2 x double>* %482
%483 = or i64 %463, 4
%484 = getelementptr inbounds double, double* %22, i64 %483
%485 = bitcast double* %484 to <2 x double>*
%486 = load <2 x double>, <2 x double>* %485
%487 = getelementptr inbounds double, double* %484, i64 2
%488 = bitcast double* %487 to <2 x double>*
%489 = load <2 x double>, <2 x double>* %488
%490 = getelementptr inbounds double, double* %19, i64 %483
%491 = bitcast double* %490 to <2 x double>*
%492 = load <2 x double>, <2 x double>* %491
%493 = getelementptr inbounds double, double* %490, i64 2
%494 = bitcast double* %493 to <2 x double>*
%495 = load <2 x double>, <2 x double>* %494
%496 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %459, <2 x double> %492, <2 x double> %486)
%497 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %461, <2 x double> %495, <2 x double> %489)
%498 = getelementptr inbounds double, double* %24, i64 %483
%499 = bitcast double* %498 to <2 x double>*
store <2 x double> %496, <2 x double>* %499
%500 = getelementptr inbounds double, double* %498, i64 2
%501 = bitcast double* %500 to <2 x double>*
store <2 x double> %497, <2 x double>* %501
%502 = add nuw i64 %463, 8
%503 = add i64 %464, 2
%504 = icmp eq i64 %503, %299
br i1 %504, label %505, label %462
505: ; preds = %462, %457
%506 = phi i64 [ 0, %457 ], [ %502, %462 ]
br i1 %300, label %526, label %507
507: ; preds = %505
%508 = getelementptr inbounds double, double* %22, i64 %506
%509 = bitcast double* %508 to <2 x double>*
%510 = load <2 x double>, <2 x double>* %509
%511 = getelementptr inbounds double, double* %508, i64 2
%512 = bitcast double* %511 to <2 x double>*
%513 = load <2 x double>, <2 x double>* %512
%514 = getelementptr inbounds double, double* %19, i64 %506
%515 = bitcast double* %514 to <2 x double>*
%516 = load <2 x double>, <2 x double>* %515
%517 = getelementptr inbounds double, double* %514, i64 2
%518 = bitcast double* %517 to <2 x double>*
%519 = load <2 x double>, <2 x double>* %518
%520 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %459, <2 x double> %516, <2 x double> %510)
%521 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %461, <2 x double> %519, <2 x double> %513)
%522 = getelementptr inbounds double, double* %24, i64 %506
%523 = bitcast double* %522 to <2 x double>*
store <2 x double> %520, <2 x double>* %523
%524 = getelementptr inbounds double, double* %522, i64 2
%525 = bitcast double* %524 to <2 x double>*
store <2 x double> %521, <2 x double>* %525
br label %526
526: ; preds = %505, %507
br i1 %301, label %561, label %527
527: ; preds = %454, %526
%528 = phi i64 [ 0, %454 ], [ %296, %526 ]
%529 = xor i64 %528, -1
br i1 %303, label %538, label %530
530: ; preds = %527
%531 = getelementptr inbounds double, double* %22, i64 %528
%532 = load double, double* %531
%533 = getelementptr inbounds double, double* %19, i64 %528
%534 = load double, double* %533
%535 = call double @llvm.fmuladd.f64(double %455, double %534, double %532)
%536 = getelementptr inbounds double, double* %24, i64 %528
store double %535, double* %536
%537 = or i64 %528, 1
br label %538
538: ; preds = %530, %527
%539 = phi i64 [ %528, %527 ], [ %537, %530 ]
%540 = icmp eq i64 %529, %304
br i1 %540, label %561, label %542
541: ; preds = %449, %445
store i32 -1, i32* %11
br label %1047
542: ; preds = %538, %542
%543 = phi i64 [ %557, %542 ], [ %539, %538 ]
%544 = getelementptr inbounds double, double* %22, i64 %543
%545 = load double, double* %544
%546 = getelementptr inbounds double, double* %19, i64 %543
%547 = load double, double* %546
%548 = call double @llvm.fmuladd.f64(double %455, double %547, double %545)
%549 = getelementptr inbounds double, double* %24, i64 %543
store double %548, double* %549
%550 = add nuw nsw i64 %543, 1
%551 = getelementptr inbounds double, double* %22, i64 %550
%552 = load double, double* %551
%553 = getelementptr inbounds double, double* %19, i64 %550
%554 = load double, double* %553
%555 = call double @llvm.fmuladd.f64(double %455, double %554, double %552)
%556 = getelementptr inbounds double, double* %24, i64 %550
store double %555, double* %556
%557 = add nuw nsw i64 %543, 2
%558 = icmp eq i64 %557, %185
br i1 %558, label %561, label %542
559: ; preds = %453, %449
%560 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %24, i32 0)
br label %662
561: ; preds = %538, %542, %526
%562 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %24, i32 0)
br i1 %31, label %563, label %662
563: ; preds = %561
%564 = select i1 %305, i1 true, i1 %312
br i1 %564, label %631, label %565
565: ; preds = %563
br i1 %315, label %609, label %566
566: ; preds = %565, %566
%567 = phi i64 [ %606, %566 ], [ 0, %565 ]
%568 = phi i64 [ %607, %566 ], [ 0, %565 ]
%569 = getelementptr inbounds double, double* %28, i64 %567
%570 = bitcast double* %569 to <2 x double>*
%571 = load <2 x double>, <2 x double>* %570
%572 = getelementptr inbounds double, double* %569, i64 2
%573 = bitcast double* %572 to <2 x double>*
%574 = load <2 x double>, <2 x double>* %573
%575 = getelementptr inbounds double, double* %24, i64 %567
%576 = bitcast double* %575 to <2 x double>*
%577 = load <2 x double>, <2 x double>* %576
%578 = getelementptr inbounds double, double* %575, i64 2
%579 = bitcast double* %578 to <2 x double>*
%580 = load <2 x double>, <2 x double>* %579
%581 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %577, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %571)
%582 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %580, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %574)
%583 = getelementptr inbounds double, double* %0, i64 %567
%584 = bitcast double* %583 to <2 x double>*
store <2 x double> %581, <2 x double>* %584
%585 = getelementptr inbounds double, double* %583, i64 2
%586 = bitcast double* %585 to <2 x double>*
store <2 x double> %582, <2 x double>* %586
%587 = or i64 %567, 4
%588 = getelementptr inbounds double, double* %28, i64 %587
%589 = bitcast double* %588 to <2 x double>*
%590 = load <2 x double>, <2 x double>* %589
%591 = getelementptr inbounds double, double* %588, i64 2
%592 = bitcast double* %591 to <2 x double>*
%593 = load <2 x double>, <2 x double>* %592
%594 = getelementptr inbounds double, double* %24, i64 %587
%595 = bitcast double* %594 to <2 x double>*
%596 = load <2 x double>, <2 x double>* %595
%597 = getelementptr inbounds double, double* %594, i64 2
%598 = bitcast double* %597 to <2 x double>*
%599 = load <2 x double>, <2 x double>* %598
%600 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %596, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %590)
%601 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %599, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %593)
%602 = getelementptr inbounds double, double* %0, i64 %587
%603 = bitcast double* %602 to <2 x double>*
store <2 x double> %600, <2 x double>* %603
%604 = getelementptr inbounds double, double* %602, i64 2
%605 = bitcast double* %604 to <2 x double>*
store <2 x double> %601, <2 x double>* %605
%606 = add nuw i64 %567, 8
%607 = add i64 %568, 2
%608 = icmp eq i64 %607, %316
br i1 %608, label %609, label %566
609: ; preds = %566, %565
%610 = phi i64 [ 0, %565 ], [ %606, %566 ]
br i1 %317, label %630, label %611
611: ; preds = %609
%612 = getelementptr inbounds double, double* %28, i64 %610
%613 = bitcast double* %612 to <2 x double>*
%614 = load <2 x double>, <2 x double>* %613
%615 = getelementptr inbounds double, double* %612, i64 2
%616 = bitcast double* %615 to <2 x double>*
%617 = load <2 x double>, <2 x double>* %616
%618 = getelementptr inbounds double, double* %24, i64 %610
%619 = bitcast double* %618 to <2 x double>*
%620 = load <2 x double>, <2 x double>* %619
%621 = getelementptr inbounds double, double* %618, i64 2
%622 = bitcast double* %621 to <2 x double>*
%623 = load <2 x double>, <2 x double>* %622
%624 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %620, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %614)
%625 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %623, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %617)
%626 = getelementptr inbounds double, double* %0, i64 %610
%627 = bitcast double* %626 to <2 x double>*
store <2 x double> %624, <2 x double>* %627
%628 = getelementptr inbounds double, double* %626, i64 2
%629 = bitcast double* %628 to <2 x double>*
store <2 x double> %625, <2 x double>* %629
br label %630
630: ; preds = %609, %611
br i1 %318, label %665, label %631
631: ; preds = %563, %630
%632 = phi i64 [ 0, %563 ], [ %313, %630 ]
%633 = xor i64 %632, -1
br i1 %320, label %642, label %634
634: ; preds = %631
%635 = getelementptr inbounds double, double* %28, i64 %632
%636 = load double, double* %635
%637 = getelementptr inbounds double, double* %24, i64 %632
%638 = load double, double* %637
%639 = call double @llvm.fmuladd.f64(double %638, double 2.000000e+00, double %636)
%640 = getelementptr inbounds double, double* %0, i64 %632
store double %639, double* %640
%641 = or i64 %632, 1
br label %642
642: ; preds = %634, %631
%643 = phi i64 [ %632, %631 ], [ %641, %634 ]
%644 = icmp eq i64 %633, %321
br i1 %644, label %665, label %645
645: ; preds = %642, %645
%646 = phi i64 [ %660, %645 ], [ %643, %642 ]
%647 = getelementptr inbounds double, double* %28, i64 %646
%648 = load double, double* %647
%649 = getelementptr inbounds double, double* %24, i64 %646
%650 = load double, double* %649
%651 = call double @llvm.fmuladd.f64(double %650, double 2.000000e+00, double %648)
%652 = getelementptr inbounds double, double* %0, i64 %646
store double %651, double* %652
%653 = add nuw nsw i64 %646, 1
%654 = getelementptr inbounds double, double* %28, i64 %653
%655 = load double, double* %654
%656 = getelementptr inbounds double, double* %24, i64 %653
%657 = load double, double* %656
%658 = call double @llvm.fmuladd.f64(double %657, double 2.000000e+00, double %655)
%659 = getelementptr inbounds double, double* %0, i64 %653
store double %658, double* %659
%660 = add nuw nsw i64 %646, 2
%661 = icmp eq i64 %660, %186
br i1 %661, label %665, label %645
662: ; preds = %559, %561
%663 = fadd double %30, %403
store double %663, double* %3
%664 = call i32 (double, double*, double*, i32, ...) bitcast (i32 (...)* @rhs to i32 (double, double*, double*, i32, ...)*)(double %663, double* %0, double* %1, i32 %2)
br label %749
665: ; preds = %642, %645, %630
%666 = fadd double %30, %403
store double %666, double* %3
%667 = call i32 (double, double*, double*, i32, ...) bitcast (i32 (...)* @rhs to i32 (double, double*, double*, i32, ...)*)(double %666, double* %0, double* %1, i32 %2)
br i1 %31, label %668, label %749
668: ; preds = %665
%669 = fmul double %403, -1.500000e+00
%670 = select i1 %322, i1 true, i1 %333
br i1 %670, label %732, label %671
671: ; preds = %668
%672 = insertelement <2 x double> poison, double %669, i64 0
%673 = shufflevector <2 x double> %672, <2 x double> poison, <2 x i32> zeroinitializer
%674 = insertelement <2 x double> poison, double %403, i64 0
%675 = shufflevector <2 x double> %674, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %336, label %713, label %676
676: ; preds = %671, %676
%677 = phi i64 [ %710, %676 ], [ 0, %671 ]
%678 = phi i64 [ %711, %676 ], [ 0, %671 ]
%679 = getelementptr inbounds double, double* %1, i64 %677
%680 = bitcast double* %679 to <2 x double>*
%681 = load <2 x double>, <2 x double>* %680
%682 = getelementptr inbounds double, double* %19, i64 %677
%683 = bitcast double* %682 to <2 x double>*
%684 = load <2 x double>, <2 x double>* %683
%685 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %673, <2 x double> %684, <2 x double> %681)
%686 = getelementptr inbounds double, double* %24, i64 %677
%687 = bitcast double* %686 to <2 x double>*
%688 = load <2 x double>, <2 x double>* %687
%689 = fmul <2 x double> %688, <double 8.000000e+00, double 8.000000e+00>
%690 = fdiv <2 x double> %689, %675
%691 = fsub <2 x double> %685, %690
%692 = getelementptr inbounds double, double* %25, i64 %677
%693 = bitcast double* %692 to <2 x double>*
store <2 x double> %691, <2 x double>* %693
%694 = or i64 %677, 2
%695 = getelementptr inbounds double, double* %1, i64 %694
%696 = bitcast double* %695 to <2 x double>*
%697 = load <2 x double>, <2 x double>* %696
%698 = getelementptr inbounds double, double* %19, i64 %694
%699 = bitcast double* %698 to <2 x double>*
%700 = load <2 x double>, <2 x double>* %699
%701 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %673, <2 x double> %700, <2 x double> %697)
%702 = getelementptr inbounds double, double* %24, i64 %694
%703 = bitcast double* %702 to <2 x double>*
%704 = load <2 x double>, <2 x double>* %703
%705 = fmul <2 x double> %704, <double 8.000000e+00, double 8.000000e+00>
%706 = fdiv <2 x double> %705, %675
%707 = fsub <2 x double> %701, %706
%708 = getelementptr inbounds double, double* %25, i64 %694
%709 = bitcast double* %708 to <2 x double>*
store <2 x double> %707, <2 x double>* %709
%710 = add nuw i64 %677, 4
%711 = add nuw i64 %678, 2
%712 = icmp eq i64 %711, %337
br i1 %712, label %713, label %676
713: ; preds = %676, %671
%714 = phi i64 [ 0, %671 ], [ %710, %676 ]
br i1 %338, label %731, label %715
715: ; preds = %713
%716 = getelementptr inbounds double, double* %1, i64 %714
%717 = bitcast double* %716 to <2 x double>*
%718 = load <2 x double>, <2 x double>* %717
%719 = getelementptr inbounds double, double* %19, i64 %714
%720 = bitcast double* %719 to <2 x double>*
%721 = load <2 x double>, <2 x double>* %720
%722 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %673, <2 x double> %721, <2 x double> %718)
%723 = getelementptr inbounds double, double* %24, i64 %714
%724 = bitcast double* %723 to <2 x double>*
%725 = load <2 x double>, <2 x double>* %724
%726 = fmul <2 x double> %725, <double 8.000000e+00, double 8.000000e+00>
%727 = fdiv <2 x double> %726, %675
%728 = fsub <2 x double> %722, %727
%729 = getelementptr inbounds double, double* %25, i64 %714
%730 = bitcast double* %729 to <2 x double>*
store <2 x double> %728, <2 x double>* %730
br label %731
731: ; preds = %713, %715
br i1 %339, label %752, label %732
732: ; preds = %668, %731
%733 = phi i64 [ 0, %668 ], [ %334, %731 ]
br label %734
734: ; preds = %732, %734
%735 = phi i64 [ %747, %734 ], [ %733, %732 ]
%736 = getelementptr inbounds double, double* %1, i64 %735
%737 = load double, double* %736
%738 = getelementptr inbounds double, double* %19, i64 %735
%739 = load double, double* %738
%740 = call double @llvm.fmuladd.f64(double %669, double %739, double %737)
%741 = getelementptr inbounds double, double* %24, i64 %735
%742 = load double, double* %741
%743 = fmul double %742, 8.000000e+00
%744 = fdiv double %743, %403
%745 = fsub double %740, %744
%746 = getelementptr inbounds double, double* %25, i64 %735
store double %745, double* %746
%747 = add nuw nsw i64 %735, 1
%748 = icmp eq i64 %747, %187
br i1 %748, label %752, label %734
749: ; preds = %662, %665
%750 = phi double [ %666, %665 ], [ %663, %662 ]
%751 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %25, i32 0)
br label %827
752: ; preds = %734, %731
%753 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %25, i32 0)
br i1 %31, label %754, label %827
754: ; preds = %752
%755 = select i1 %340, i1 true, i1 %351
br i1 %755, label %787, label %756
756: ; preds = %754, %756
%757 = phi i64 [ %784, %756 ], [ 0, %754 ]
%758 = getelementptr inbounds double, double* %28, i64 %757
%759 = bitcast double* %758 to <2 x double>*
%760 = load <2 x double>, <2 x double>* %759
%761 = getelementptr inbounds double, double* %758, i64 2
%762 = bitcast double* %761 to <2 x double>*
%763 = load <2 x double>, <2 x double>* %762
%764 = getelementptr inbounds double, double* %24, i64 %757
%765 = bitcast double* %764 to <2 x double>*
%766 = load <2 x double>, <2 x double>* %765
%767 = getelementptr inbounds double, double* %764, i64 2
%768 = bitcast double* %767 to <2 x double>*
%769 = load <2 x double>, <2 x double>* %768
%770 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %766, <2 x double> <double 1.920000e+00, double 1.920000e+00>, <2 x double> %760)
%771 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %769, <2 x double> <double 1.920000e+00, double 1.920000e+00>, <2 x double> %763)
%772 = getelementptr inbounds double, double* %25, i64 %757
%773 = bitcast double* %772 to <2 x double>*
%774 = load <2 x double>, <2 x double>* %773
%775 = getelementptr inbounds double, double* %772, i64 2
%776 = bitcast double* %775 to <2 x double>*
%777 = load <2 x double>, <2 x double>* %776
%778 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %774, <2 x double> <double 2.400000e-01, double 2.400000e-01>, <2 x double> %770)
%779 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %777, <2 x double> <double 2.400000e-01, double 2.400000e-01>, <2 x double> %771)
%780 = getelementptr inbounds double, double* %0, i64 %757
%781 = bitcast double* %780 to <2 x double>*
store <2 x double> %778, <2 x double>* %781
%782 = getelementptr inbounds double, double* %780, i64 2
%783 = bitcast double* %782 to <2 x double>*
store <2 x double> %779, <2 x double>* %783
%784 = add nuw i64 %757, 4
%785 = icmp eq i64 %784, %352
br i1 %785, label %786, label %756
786: ; preds = %756
br i1 %353, label %827, label %787
787: ; preds = %754, %786
%788 = phi i64 [ 0, %754 ], [ %352, %786 ]
%789 = xor i64 %788, -1
br i1 %355, label %801, label %790
790: ; preds = %787
%791 = getelementptr inbounds double, double* %28, i64 %788
%792 = load double, double* %791
%793 = getelementptr inbounds double, double* %24, i64 %788
%794 = load double, double* %793
%795 = call double @llvm.fmuladd.f64(double %794, double 1.920000e+00, double %792)
%796 = getelementptr inbounds double, double* %25, i64 %788
%797 = load double, double* %796
%798 = call double @llvm.fmuladd.f64(double %797, double 2.400000e-01, double %795)
%799 = getelementptr inbounds double, double* %0, i64 %788
store double %798, double* %799
%800 = or i64 %788, 1
br label %801
801: ; preds = %790, %787
%802 = phi i64 [ %788, %787 ], [ %800, %790 ]
%803 = icmp eq i64 %789, %356
br i1 %803, label %827, label %804
804: ; preds = %801, %804
%805 = phi i64 [ %825, %804 ], [ %802, %801 ]
%806 = getelementptr inbounds double, double* %28, i64 %805
%807 = load double, double* %806
%808 = getelementptr inbounds double, double* %24, i64 %805
%809 = load double, double* %808
%810 = call double @llvm.fmuladd.f64(double %809, double 1.920000e+00, double %807)
%811 = getelementptr inbounds double, double* %25, i64 %805
%812 = load double, double* %811
%813 = call double @llvm.fmuladd.f64(double %812, double 2.400000e-01, double %810)
%814 = getelementptr inbounds double, double* %0, i64 %805
store double %813, double* %814
%815 = add nuw nsw i64 %805, 1
%816 = getelementptr inbounds double, double* %28, i64 %815
%817 = load double, double* %816
%818 = getelementptr inbounds double, double* %24, i64 %815
%819 = load double, double* %818
%820 = call double @llvm.fmuladd.f64(double %819, double 1.920000e+00, double %817)
%821 = getelementptr inbounds double, double* %25, i64 %815
%822 = load double, double* %821
%823 = call double @llvm.fmuladd.f64(double %822, double 2.400000e-01, double %820)
%824 = getelementptr inbounds double, double* %0, i64 %815
store double %823, double* %824
%825 = add nuw nsw i64 %805, 2
%826 = icmp eq i64 %825, %188
br i1 %826, label %827, label %804
827: ; preds = %801, %804, %786, %749, %752
%828 = phi double [ %750, %749 ], [ %666, %752 ], [ %666, %786 ], [ %666, %804 ], [ %666, %801 ]
%829 = call double @llvm.fmuladd.f64(double %403, double 6.000000e-01, double %30)
store double %829, double* %3
%830 = call i32 (double, double*, double*, i32, ...) bitcast (i32 (...)* @rhs to i32 (double, double*, double*, i32, ...)*)(double %829, double* %0, double* %1, i32 %2)
br i1 %31, label %833, label %831
831: ; preds = %827
%832 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %26, i32 0)
br label %946
833: ; preds = %827
%834 = fmul double %403, 2.420000e+00
%835 = select i1 %357, i1 true, i1 %372
br i1 %835, label %865, label %836
836: ; preds = %833
%837 = insertelement <2 x double> poison, double %834, i64 0
%838 = shufflevector <2 x double> %837, <2 x double> poison, <2 x i32> zeroinitializer
%839 = insertelement <2 x double> poison, double %403, i64 0
%840 = shufflevector <2 x double> %839, <2 x double> poison, <2 x i32> zeroinitializer
br label %841
841: ; preds = %841, %836
%842 = phi i64 [ 0, %836 ], [ %862, %841 ]
%843 = getelementptr inbounds double, double* %1, i64 %842
%844 = bitcast double* %843 to <2 x double>*
%845 = load <2 x double>, <2 x double>* %844
%846 = getelementptr inbounds double, double* %19, i64 %842
%847 = bitcast double* %846 to <2 x double>*
%848 = load <2 x double>, <2 x double>* %847
%849 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %838, <2 x double> %848, <2 x double> %845)
%850 = getelementptr inbounds double, double* %24, i64 %842
%851 = bitcast double* %850 to <2 x double>*
%852 = load <2 x double>, <2 x double>* %851
%853 = getelementptr inbounds double, double* %25, i64 %842
%854 = bitcast double* %853 to <2 x double>*
%855 = load <2 x double>, <2 x double>* %854
%856 = fmul <2 x double> %855, <double 2.400000e+00, double 2.400000e+00>
%857 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %852, <2 x double> <double 1.488000e+01, double 1.488000e+01>, <2 x double> %856)
%858 = fdiv <2 x double> %857, %840
%859 = fadd <2 x double> %849, %858
%860 = getelementptr inbounds double, double* %26, i64 %842
%861 = bitcast double* %860 to <2 x double>*
store <2 x double> %859, <2 x double>* %861
%862 = add nuw i64 %842, 2
%863 = icmp eq i64 %862, %373
br i1 %863, label %864, label %841
864: ; preds = %841
br i1 %374, label %885, label %865
865: ; preds = %833, %864
%866 = phi i64 [ 0, %833 ], [ %373, %864 ]
br label %867
867: ; preds = %865, %867
%868 = phi i64 [ %883, %867 ], [ %866, %865 ]
%869 = getelementptr inbounds double, double* %1, i64 %868
%870 = load double, double* %869
%871 = getelementptr inbounds double, double* %19, i64 %868
%872 = load double, double* %871
%873 = call double @llvm.fmuladd.f64(double %834, double %872, double %870)
%874 = getelementptr inbounds double, double* %24, i64 %868
%875 = load double, double* %874
%876 = getelementptr inbounds double, double* %25, i64 %868
%877 = load double, double* %876
%878 = fmul double %877, 2.400000e+00
%879 = call double @llvm.fmuladd.f64(double %875, double 1.488000e+01, double %878)
%880 = fdiv double %879, %403
%881 = fadd double %873, %880
%882 = getelementptr inbounds double, double* %26, i64 %868
store double %881, double* %882
%883 = add nuw nsw i64 %868, 1
%884 = icmp eq i64 %883, %189
br i1 %884, label %885, label %867
885: ; preds = %867, %864
%886 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %26, i32 0)
br i1 %31, label %887, label %946
887: ; preds = %885
%888 = fmul double %403, 1.160000e-01
%889 = select i1 %375, i1 true, i1 %394
br i1 %889, label %923, label %890
890: ; preds = %887
%891 = insertelement <2 x double> poison, double %888, i64 0
%892 = shufflevector <2 x double> %891, <2 x double> poison, <2 x i32> zeroinitializer
%893 = insertelement <2 x double> poison, double %403, i64 0
%894 = shufflevector <2 x double> %893, <2 x double> poison, <2 x i32> zeroinitializer
br label %895
895: ; preds = %895, %890
%896 = phi i64 [ 0, %890 ], [ %920, %895 ]
%897 = getelementptr inbounds double, double* %1, i64 %896
%898 = bitcast double* %897 to <2 x double>*
%899 = load <2 x double>, <2 x double>* %898
%900 = getelementptr inbounds double, double* %19, i64 %896
%901 = bitcast double* %900 to <2 x double>*
%902 = load <2 x double>, <2 x double>* %901
%903 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %892, <2 x double> %902, <2 x double> %899)
%904 = getelementptr inbounds double, double* %24, i64 %896
%905 = bitcast double* %904 to <2 x double>*
%906 = load <2 x double>, <2 x double>* %905
%907 = getelementptr inbounds double, double* %25, i64 %896
%908 = bitcast double* %907 to <2 x double>*
%909 = load <2 x double>, <2 x double>* %908
%910 = fmul <2 x double> %909, <double -4.320000e-01, double -4.320000e-01>
%911 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %906, <2 x double> <double -8.960000e-01, double -8.960000e-01>, <2 x double> %910)
%912 = getelementptr inbounds double, double* %26, i64 %896
%913 = bitcast double* %912 to <2 x double>*
%914 = load <2 x double>, <2 x double>* %913
%915 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %914, <2 x double> <double -4.000000e-01, double -4.000000e-01>, <2 x double> %911)
%916 = fdiv <2 x double> %915, %894
%917 = fadd <2 x double> %903, %916
%918 = getelementptr inbounds double, double* %27, i64 %896
%919 = bitcast double* %918 to <2 x double>*
store <2 x double> %917, <2 x double>* %919
%920 = add nuw i64 %896, 2
%921 = icmp eq i64 %920, %395
br i1 %921, label %922, label %895
922: ; preds = %895
br i1 %396, label %948, label %923
923: ; preds = %887, %922
%924 = phi i64 [ 0, %887 ], [ %395, %922 ]
br label %925
925: ; preds = %923, %925
%926 = phi i64 [ %944, %925 ], [ %924, %923 ]
%927 = getelementptr inbounds double, double* %1, i64 %926
%928 = load double, double* %927
%929 = getelementptr inbounds double, double* %19, i64 %926
%930 = load double, double* %929
%931 = call double @llvm.fmuladd.f64(double %888, double %930, double %928)
%932 = getelementptr inbounds double, double* %24, i64 %926
%933 = load double, double* %932
%934 = getelementptr inbounds double, double* %25, i64 %926
%935 = load double, double* %934
%936 = fmul double %935, -4.320000e-01
%937 = call double @llvm.fmuladd.f64(double %933, double -8.960000e-01, double %936)
%938 = getelementptr inbounds double, double* %26, i64 %926
%939 = load double, double* %938
%940 = call double @llvm.fmuladd.f64(double %939, double -4.000000e-01, double %937)
%941 = fdiv double %940, %403
%942 = fadd double %931, %941
%943 = getelementptr inbounds double, double* %27, i64 %926
store double %942, double* %943
%944 = add nuw nsw i64 %926, 1
%945 = icmp eq i64 %944, %190
br i1 %945, label %948, label %925
946: ; preds = %831, %885
%947 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %27, i32 0)
br label %978
948: ; preds = %925, %922
%949 = call i32 (double*, i32, i32, i32*, double*, i32, ...) bitcast (i32 (...)* @sgesl to i32 (double*, i32, i32, i32*, double*, i32, ...)*)(double* %9, i32 %2, i32 %2, i32* %183, double* %27, i32 0)
br i1 %31, label %950, label %978
950: ; preds = %948, %950
%951 = phi i64 [ %976, %950 ], [ 0, %948 ]
%952 = getelementptr inbounds double, double* %28, i64 %951
%953 = load double, double* %952
%954 = getelementptr inbounds double, double* %24, i64 %951
%955 = load double, double* %954
%956 = call double @llvm.fmuladd.f64(double %955, double 0x4000E38E38E38E39, double %953)
%957 = getelementptr inbounds double, double* %25, i64 %951
%958 = load double, double* %957
%959 = call double @llvm.fmuladd.f64(double %958, double 5.000000e-01, double %956)
%960 = getelementptr inbounds double, double* %26, i64 %951
%961 = load double, double* %960
%962 = call double @llvm.fmuladd.f64(double %961, double 0x3FCDA12F684BDA13, double %959)
%963 = getelementptr inbounds double, double* %27, i64 %951
%964 = load double, double* %963
%965 = call double @llvm.fmuladd.f64(double %964, double 0x3FF284BDA12F684C, double %962)
%966 = getelementptr inbounds double, double* %0, i64 %951
store double %965, double* %966
%967 = load double, double* %954
%968 = load double, double* %957
%969 = fmul double %968, 0x3FC8E38E38E38E39
%970 = call double @llvm.fmuladd.f64(double %967, double 0x3FD425ED097B425F, double %969)
%971 = load double, double* %960
%972 = call double @llvm.fmuladd.f64(double %971, double 0.000000e+00, double %970)
%973 = load double, double* %963
%974 = call double @llvm.fmuladd.f64(double %973, double 0x3FF284BDA12F684C, double %972)
%975 = getelementptr inbounds double, double* %23, i64 %951
store double %974, double* %975
%976 = add nuw nsw i64 %951, 1
%977 = icmp eq i64 %976, %191
br i1 %977, label %978, label %950
978: ; preds = %950, %946, %948
store double %828, double* %3
%979 = fcmp oeq double %828, %30
br i1 %979, label %982, label %980
980: ; preds = %978
br i1 %31, label %981, label %1020
981: ; preds = %980
br i1 %398, label %1007, label %983
982: ; preds = %978
store i32 1, i32* %11
br label %1047
983: ; preds = %981, %983
%984 = phi i64 [ %1004, %983 ], [ 0, %981 ]
%985 = phi double [ %1003, %983 ], [ 0.000000e+00, %981 ]
%986 = phi i64 [ %1005, %983 ], [ 0, %981 ]
%987 = getelementptr inbounds double, double* %23, i64 %984
%988 = load double, double* %987
%989 = getelementptr inbounds double, double* %6, i64 %984
%990 = load double, double* %989
%991 = fdiv double %988, %990
%992 = call double @llvm.fabs.f64(double %991)
%993 = fcmp ogt double %985, %992
%994 = select i1 %993, double %985, double %992
%995 = or i64 %984, 1
%996 = getelementptr inbounds double, double* %23, i64 %995
%997 = load double, double* %996
%998 = getelementptr inbounds double, double* %6, i64 %995
%999 = load double, double* %998
%1000 = fdiv double %997, %999
%1001 = call double @llvm.fabs.f64(double %1000)
%1002 = fcmp ogt double %994, %1001
%1003 = select i1 %1002, double %994, double %1001
%1004 = add nuw nsw i64 %984, 2
%1005 = add i64 %986, 2
%1006 = icmp eq i64 %1005, %399
br i1 %1006, label %1007, label %983
1007: ; preds = %983, %981
%1008 = phi double [ undef, %981 ], [ %1003, %983 ]
%1009 = phi i64 [ 0, %981 ], [ %1004, %983 ]
%1010 = phi double [ 0.000000e+00, %981 ], [ %1003, %983 ]
br i1 %400, label %1020, label %1011
1011: ; preds = %1007
%1012 = getelementptr inbounds double, double* %23, i64 %1009
%1013 = load double, double* %1012
%1014 = getelementptr inbounds double, double* %6, i64 %1009
%1015 = load double, double* %1014
%1016 = fdiv double %1013, %1015
%1017 = call double @llvm.fabs.f64(double %1016)
%1018 = fcmp ogt double %1010, %1017
%1019 = select i1 %1018, double %1010, double %1017
br label %1020
1020: ; preds = %1011, %1007, %980
%1021 = phi double [ 0.000000e+00, %980 ], [ %1008, %1007 ], [ %1019, %1011 ]
%1022 = fdiv double %1021, %5
%1023 = fcmp ugt double %1022, 1.000000e+00
br i1 %1023, label %1034, label %1024
1024: ; preds = %1020
store double %403, double* %7
%1025 = fcmp ogt double %1022, 1.296000e-01
br i1 %1025, label %1026, label %1030
1026: ; preds = %1024
%1027 = fmul double %403, 9.000000e-01
%1028 = call double @pow(double %1022, double -2.500000e-01)
%1029 = fmul double %1027, %1028
br label %1032
1030: ; preds = %1024
%1031 = fmul double %403, 1.500000e+00
br label %1032
1032: ; preds = %1030, %1026
%1033 = phi double [ %1029, %1026 ], [ %1031, %1030 ]
store double %1033, double* %8
br label %1047
1034: ; preds = %1020
%1035 = fmul double %403, 9.000000e-01
%1036 = call double @pow(double %1022, double 0xBFD5555555555555)
%1037 = fmul double %1035, %1036
store double %1037, double* %8
%1038 = fcmp ult double %403, 0.000000e+00
%1039 = fmul double %403, 5.000000e-01
%1040 = fcmp olt double %1037, %1039
%1041 = fcmp ogt double %1037, %1039
%1042 = select i1 %1038, i1 %1040, i1 %1041
%1043 = select i1 %1042, double %1037, double %1039
%1044 = add nuw nsw i32 %402, 1
%1045 = icmp eq i32 %1044, 41
br i1 %1045, label %1046, label %401
1046: ; preds = %1034
store i32 4, i32* %11
br label %1047
1047: ; preds = %1046, %1032, %982, %541
%1048 = phi i32 [ -1, %541 ], [ -1, %982 ], [ 0, %1032 ], [ -1, %1046 ]
ret i32 %1048
}