double rq_pricing_finite_differences_equity_american(
    short call, double S, double X, double r_dom, double r_for, double sigma,
    double tau_e, double tau_d, unsigned num_timesteps, unsigned num_values,
    double *mesh, double *value, double *vold, double *ivalue, double *a,
    double *b, double *c, double *tvalue, int *err) {
  double result = 0.0;
  int s_steps = num_values;
  int t_steps = num_timesteps;
  double hibarrier = 2.50 * X;
  double lobarrier = 0.0;
  double ds = (hibarrier - lobarrier) / (num_values - 1);
  double dt = tau_e / (double)t_steps;
  int i;
  double vol2 = sigma * sigma;
  double ss;
  double se;
  double rate1 = r_dom;
  double cost_carry = r_dom - r_for;
  double del;
  int time_index;
  int t_i;
  int s_i;
  double omega = 1.03E0;
  double domega = 1.0E-2;
  double eps = 1.0E-5;
  int its;
  int oldits;
  double elasticity = 1.0;
  *err = 0;
  for (i = 0; i < s_steps; ++i)
    mesh[i] = lobarrier + (ds * (double)i);
  if (call) {
    for (i = 0; i < s_steps; ++i) {
      value[i] = ((0.0) > (mesh[i] - X) ? (0.0) : (mesh[i] - X));
      ivalue[i] = vold[i] = value[i];
    }
  } else {
    for (i = 0; i < s_steps; ++i) {
      value[i] = ((0.0) > (X - mesh[i]) ? (0.0) : (X - mesh[i]));
      ivalue[i] = vold[i] = value[i];
    }
  }
  ss = mesh[0] / ds;
  se = pow(mesh[0], elasticity) / ds;
  a[0] = 0;
  b[0] = 1.0 + (vol2 * se * se + rate1) * dt;
  c[0] = -(vol2 * se * se + cost_carry * ss) * dt / 2.0;
  for (i = 1; i < s_steps; ++i) {
    ss = mesh[i] / ds;
    se = pow(mesh[i], elasticity) / ds;
    a[i] = -(vol2 * se * se - cost_carry * ss) * dt / 2.0;
    b[i] = 1.0 + (vol2 * se * se + rate1) * dt;
    c[i] = -(vol2 * se * se + cost_carry * ss) * dt / 2.0;
  }
  del = fabs(S - mesh[0]);
  time_index = 0;
  for (i = 1; i < s_steps; i++) {
    double new_del = fabs(S - mesh[i]);
    if (new_del <= del) {
      del = new_del;
      time_index = i;
    }
  }
  oldits = 1000 + 1000;
  for (t_i = t_steps; t_i > 0; t_i--) {
    int can_exercise = 0;
    int count;
    double tmp;
    double l2norm;
    double l2err;
    double time = (double)t_i * dt;
    count = 0;
    for (s_i = 0; s_i < s_steps; ++s_i)
      value[s_i] = vold[s_i];
    tmp = vold[0] / b[0];
    if (can_exercise)
      tmp = ((tmp) > (ivalue[0]) ? (tmp) : (ivalue[0]));
    value[0] = tmp;
    s_i = s_steps;
    value[s_i] = (2.0 * value[s_i - 1] - value[s_i - 2]);
    do {
      l2norm = 0.0;
      l2err = 0.0;
      s_i = s_steps;
      tmp = (2 * value[s_i - 1] - value[s_i - 2]);
      tmp = value[s_i] + omega * (tmp - value[s_i]);
      tmp = ((tmp) > (0.0) ? (tmp) : (0.0));
      value[s_i] = tmp;
      for (s_i = 1; s_i < s_steps; ++s_i) {
        tmp = (vold[s_i] - value[s_i - 1] * a[s_i] - value[s_i + 1] * c[s_i]) /
              b[s_i];
        tmp = value[s_i] + omega * (tmp - value[s_i]);
        if (can_exercise)
          tmp = ((tmp) > (ivalue[s_i]) ? (tmp) : (ivalue[s_i]));
        else
          tmp = ((tmp) > (0.0) ? (tmp) : (0.0));
        l2norm += tmp * tmp;
        l2err += (value[s_i] - tmp) * (value[s_i] - tmp);
        value[s_i] = tmp;
      }
      ++count;
      l2err = sqrt(l2err);
      l2norm = sqrt(l2norm);
      if (l2norm < 0.1)
        l2norm = 0.1;
    } while (l2err > eps * l2norm && count < 1000);
    its = count;
    if (l2err > eps * l2norm) {
      *err = -10;
      return 0.0;
    }
    if (oldits < its)
      domega *= -0.9;
    omega += domega;
    oldits = its;
    tvalue[t_i - 1] = value[time_index];
    if (t_i > 1) {
      int j;
      for (j = 0; j < s_steps; ++j)
        vold[j] = value[j];
    }
  }
  result = tvalue[0];
  return result;
}


x86 assembly (clang, -O0):
<rq_pricing_finite_differences_equity_american>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %di,%ax
mov    0x38(%rbp),%rdi
mov    0x30(%rbp),%rdi
mov    0x28(%rbp),%rdi
mov    0x20(%rbp),%rdi
mov    0x18(%rbp),%rdi
mov    0x10(%rbp),%rdi
mov    %ax,-0xa(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
movsd  %xmm3,-0x30(%rbp)
movsd  %xmm4,-0x38(%rbp)
movsd  %xmm5,-0x40(%rbp)
movsd  %xmm6,-0x48(%rbp)
mov    %esi,-0x4c(%rbp)
mov    %edx,-0x50(%rbp)
mov    %rcx,-0x58(%rbp)
mov    %r8,-0x60(%rbp)
mov    %r9,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x78(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xe80(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xded(%rip),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  0xdd5(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0xdbd(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0xda5(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    0x38(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    12ca <rq_pricing_finite_differences_equity_american+0x1aa>
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
cvtsi2sdl -0x9c(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1277 <rq_pricing_finite_differences_equity_american+0x157>
cmpw   $0x0,-0xa(%rbp)
je     139e <rq_pricing_finite_differences_equity_american+0x27e>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1399 <rq_pricing_finite_differences_equity_american+0x279>
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x20(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1320 <rq_pricing_finite_differences_equity_american+0x200>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    133d <rq_pricing_finite_differences_equity_american+0x21d>
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    12df <rq_pricing_finite_differences_equity_american+0x1bf>
jmp    1467 <rq_pricing_finite_differences_equity_american+0x347>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1462 <rq_pricing_finite_differences_equity_american+0x342>
movsd  -0x20(%rbp),%xmm1
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    13e9 <rq_pricing_finite_differences_equity_american+0x2c9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    1406 <rq_pricing_finite_differences_equity_american+0x2e6>
movsd  -0x20(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    13a8 <rq_pricing_finite_differences_equity_american+0x288>
jmp    1467 <rq_pricing_finite_differences_equity_american+0x347>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x108(%rbp),%xmm1
ff
call   1030 <pow@plt>
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0xb15(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  0xada(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1711 <rq_pricing_finite_differences_equity_american+0x5f1>
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x108(%rbp),%xmm1
ff
call   1030 <pow@plt>
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  0x9fa(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x982(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  0x93f(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1564 <rq_pricing_finite_differences_equity_american+0x444>
movsd  -0x18(%rbp),%xmm0
mov    -0x58(%rbp),%rax
subsd  (%rax),%xmm0
movaps 0x91b(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0xd4(%rbp)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    17cb <rq_pricing_finite_differences_equity_american+0x6ab>
movsd  -0x18(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x8d0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     17b2 <rq_pricing_finite_differences_equity_american+0x692>
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x9c(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    17b7 <rq_pricing_finite_differences_equity_american+0x697>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1745 <rq_pricing_finite_differences_equity_american+0x625>
movl   $0x7d0,-0x100(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0x0,-0xd8(%rbp)
jle    1e93 <rq_pricing_finite_differences_equity_american+0xd73>
movl   $0x0,-0x114(%rbp)
cvtsi2sdl -0xd8(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x118(%rbp)
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1864 <rq_pricing_finite_differences_equity_american+0x744>
mov    -0x68(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1821 <rq_pricing_finite_differences_equity_american+0x701>
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x20(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
cmpl   $0x0,-0x114(%rbp)
je     18d4 <rq_pricing_finite_differences_equity_american+0x7b4>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    18b4 <rq_pricing_finite_differences_equity_american+0x794>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
jmp    18c4 <rq_pricing_finite_differences_equity_american+0x7a4>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x60(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x74(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x60(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a20 <rq_pricing_finite_differences_equity_american+0x900>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1a30 <rq_pricing_finite_differences_equity_american+0x910>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1a30 <rq_pricing_finite_differences_equity_american+0x910>
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1cb4 <rq_pricing_finite_differences_equity_american+0xb94>
mov    -0x68(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x60(%rbp),%rax
mov    -0xdc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0xdc(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
cmpl   $0x0,-0x114(%rbp)
je     1bce <rq_pricing_finite_differences_equity_american+0xaae>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0xdc(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1ba1 <rq_pricing_finite_differences_equity_american+0xa81>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
jmp    1bb9 <rq_pricing_finite_differences_equity_american+0xa99>
mov    0x10(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
jmp    1c18 <rq_pricing_finite_differences_equity_american+0xaf8>
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1bf8 <rq_pricing_finite_differences_equity_american+0xad8>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1c08 <rq_pricing_finite_differences_equity_american+0xae8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1c08 <rq_pricing_finite_differences_equity_american+0xae8>
movsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x120(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x120(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1a62 <rq_pricing_finite_differences_equity_american+0x942>
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
movsd  -0x130(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0x128(%rbp)
ff
movsd  0x33b(%rip),%xmm0
ucomisd -0x128(%rbp),%xmm0
ff
jbe    1d13 <rq_pricing_finite_differences_equity_american+0xbf3>
movsd  0x325(%rip),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1d18 <rq_pricing_finite_differences_equity_american+0xbf8>
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0x171(%rbp)
jbe    1d55 <rq_pricing_finite_differences_equity_american+0xc35>
cmpl   $0x3e8,-0x118(%rbp)
setl   %al
mov    %al,-0x171(%rbp)
mov    -0x171(%rbp),%al
test   $0x1,%al
jne    1946 <rq_pricing_finite_differences_equity_american+0x826>
mov    -0x118(%rbp),%eax
mov    %eax,-0xfc(%rbp)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    1da8 <rq_pricing_finite_differences_equity_american+0xc88>
mov    0x38(%rbp),%rax
movl   $0xfffffff6,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1eaa <rq_pricing_finite_differences_equity_american+0xd8a>
mov    -0x100(%rbp),%eax
cmp    -0xfc(%rbp),%eax
jge    1dd2 <rq_pricing_finite_differences_equity_american+0xcb2>
movsd  0x276(%rip),%xmm0
mulsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0xfc(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xd8(%rbp)
jle    1e7a <rq_pricing_finite_differences_equity_american+0xd5a>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1e75 <rq_pricing_finite_differences_equity_american+0xd55>
mov    -0x60(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    1e32 <rq_pricing_finite_differences_equity_american+0xd12>
jmp    1e7a <rq_pricing_finite_differences_equity_american+0xd5a>
jmp    1e7f <rq_pricing_finite_differences_equity_american+0xd5f>
mov    -0xd8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd8(%rbp)
jmp    17de <rq_pricing_finite_differences_equity_american+0x6be>
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rq_pricing_finite_differences_equity_american>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,%r14
mov    %r8,%rbx
mov    0x138(%rsp),%rax
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%r12
mov    0x118(%rsp),%rbp
movsd  0x1eb0(%rip),%xmm10
mulsd  %xmm1,%xmm10
lea    -0x1(%rdx),%r15d
cvtsi2sd %r15,%xmm6
divsd  %xmm6,%xmm10
xorps  %xmm6,%xmm6
cvtsi2sd %esi,%xmm6
divsd  %xmm6,%xmm5
mulsd  %xmm4,%xmm4
movapd %xmm2,%xmm12
subsd  %xmm3,%xmm12
movl   $0x0,(%rax)
mov    %edx,%r13d
mov    %rdx,0x20(%rsp)
test   %edx,%edx
mov    %r13,0x30(%rsp)
jle    1761 <rq_pricing_finite_differences_equity_american+0x651>
cmpl   $0x4,0x20(%rsp)
jae    11a5 <rq_pricing_finite_differences_equity_american+0x95>
xor    %edx,%edx
jmp    12da <rq_pricing_finite_differences_equity_american+0x1ca>
movapd %xmm12,%xmm8
mov    %r13d,%edx
and    $0xfffffffc,%edx
movapd %xmm10,%xmm15
unpcklpd %xmm10,%xmm15
lea    -0x4(%rdx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     1491 <rq_pricing_finite_differences_equity_american+0x381>
movabs $0x7ffffffffffffffc,%r10
ff ff 7f
or     $0x2,%r10
and    %r9,%r10
movdqa 0x1e65(%rip),%xmm6
xor    %eax,%eax
movdqa 0x1e6a(%rip),%xmm9
xorpd  %xmm14,%xmm14
movdqa 0x1e6c(%rip),%xmm11
movdqa 0x1e73(%rip),%xmm12
movdqa 0x1e7a(%rip),%xmm13
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm6,%xmm7
cvtdq2pd %xmm6,%xmm3
paddd  %xmm9,%xmm7
cvtdq2pd %xmm7,%xmm7
mulpd  %xmm15,%xmm3
addpd  %xmm14,%xmm3
mulpd  %xmm15,%xmm7
addpd  %xmm14,%xmm7
movupd %xmm3,(%rcx,%rax,8)
movupd %xmm7,0x10(%rcx,%rax,8)
movdqa %xmm6,%xmm3
paddd  %xmm11,%xmm3
movdqa %xmm6,%xmm7
cvtdq2pd %xmm3,%xmm3
paddd  %xmm12,%xmm7
cvtdq2pd %xmm7,%xmm7
mulpd  %xmm15,%xmm3
addpd  %xmm14,%xmm3
mulpd  %xmm15,%xmm7
addpd  %xmm14,%xmm7
movupd %xmm3,0x20(%rcx,%rax,8)
movupd %xmm7,0x30(%rcx,%rax,8)
add    $0x8,%rax
paddd  %xmm13,%xmm6
add    $0xfffffffffffffffe,%r10
jne    1220 <rq_pricing_finite_differences_equity_american+0x110>
test   $0x1,%r9b
je     12d0 <rq_pricing_finite_differences_equity_american+0x1c0>
cvtdq2pd %xmm6,%xmm3
paddd  0x1db5(%rip),%xmm6
cvtdq2pd %xmm6,%xmm6
mulpd  %xmm15,%xmm3
xorpd  %xmm7,%xmm7
addpd  %xmm7,%xmm3
mulpd  %xmm15,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm3,(%rcx,%rax,8)
movupd %xmm6,0x10(%rcx,%rax,8)
cmp    %r13,%rdx
movapd %xmm8,%xmm12
je     12fe <rq_pricing_finite_differences_equity_american+0x1ee>
xorpd  %xmm3,%xmm3
xchg   %ax,%ax
xorps  %xmm6,%xmm6
cvtsi2sd %edx,%xmm6
mulsd  %xmm10,%xmm6
addsd  %xmm3,%xmm6
movsd  %xmm6,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r13
jne    12e0 <rq_pricing_finite_differences_equity_american+0x1d0>
mov    0x110(%rsp),%r9
test   %di,%di
je     1324 <rq_pricing_finite_differences_equity_american+0x214>
cmpl   $0x0,0x20(%rsp)
jle    1761 <rq_pricing_finite_differences_equity_american+0x651>
cmpl   $0x4,0x20(%rsp)
jae    1341 <rq_pricing_finite_differences_equity_american+0x231>
xor    %edi,%edi
jmp    1622 <rq_pricing_finite_differences_equity_american+0x512>
cmpl   $0x0,0x20(%rsp)
jle    1761 <rq_pricing_finite_differences_equity_american+0x651>
cmpl   $0x4,0x20(%rsp)
jae    14aa <rq_pricing_finite_differences_equity_american+0x39a>
xor    %edi,%edi
jmp    16cf <rq_pricing_finite_differences_equity_american+0x5bf>
mov    %r15,0x8(%rsp)
mov    %esi,0x10(%rsp)
lea    (%r14,%r13,8),%rdi
cmp    %rbx,%rdi
seta   %bpl
lea    (%rbx,%r13,8),%rsi
cmp    %r14,%rsi
seta   0x28(%rsp)
mov    %r13,%rdx
lea    (%r9,%r13,8),%r13
cmp    %rbx,%r13
seta   %al
cmp    %r9,%rsi
seta   0x60(%rsp)
lea    (%rcx,%rdx,8),%rdx
cmp    %rbx,%rdx
seta   %r8b
cmp    %rcx,%rsi
seta   %sil
cmp    %r14,%r13
seta   %r10b
cmp    %r9,%rdi
seta   0x50(%rsp)
cmp    %r14,%rdx
seta   %r11b
cmp    %rcx,%rdi
seta   0x40(%rsp)
cmp    %r9,%rdx
seta   %r15b
cmp    %rcx,%r13
seta   %dl
xor    %edi,%edi
test   %bpl,0x28(%rsp)
jne    21fd <rq_pricing_finite_differences_equity_american+0x10ed>
and    0x60(%rsp),%al
mov    0x30(%rsp),%r13
jne    1609 <rq_pricing_finite_differences_equity_american+0x4f9>
and    %sil,%r8b
jne    1609 <rq_pricing_finite_differences_equity_american+0x4f9>
and    0x50(%rsp),%r10b
jne    1609 <rq_pricing_finite_differences_equity_american+0x4f9>
and    0x40(%rsp),%r11b
jne    1609 <rq_pricing_finite_differences_equity_american+0x4f9>
and    %dl,%r15b
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jne    1622 <rq_pricing_finite_differences_equity_american+0x512>
mov    %r13d,%edi
and    $0xfffffffc,%edi
movapd %xmm1,%xmm9
unpcklpd %xmm1,%xmm9
lea    0x0(,%r13,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %edx,%edx
xchg   %ax,%ax
movupd (%rcx,%rdx,1),%xmm6
movupd 0x10(%rcx,%rdx,1),%xmm7
subpd  %xmm9,%xmm6
subpd  %xmm9,%xmm7
xorpd  %xmm3,%xmm3
maxpd  %xmm6,%xmm3
xorpd  %xmm6,%xmm6
maxpd  %xmm7,%xmm6
movupd %xmm3,(%rbx,%rdx,1)
movupd %xmm6,0x10(%rbx,%rdx,1)
movupd %xmm3,(%r14,%rdx,1)
movupd %xmm6,0x10(%r14,%rdx,1)
movupd %xmm3,(%r9,%rdx,1)
movupd %xmm6,0x10(%r9,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rax
jne    1430 <rq_pricing_finite_differences_equity_american+0x320>
cmp    %r13,%rdi
jne    1622 <rq_pricing_finite_differences_equity_american+0x512>
jmp    1761 <rq_pricing_finite_differences_equity_american+0x651>
movdqa 0x1bb7(%rip),%xmm6
xor    %eax,%eax
test   $0x1,%r9b
jne    129f <rq_pricing_finite_differences_equity_american+0x18f>
jmp    12d0 <rq_pricing_finite_differences_equity_american+0x1c0>
mov    %r15,0x8(%rsp)
mov    %esi,0x10(%rsp)
lea    (%r14,%r13,8),%rdi
cmp    %rbx,%rdi
seta   %bpl
lea    (%rbx,%r13,8),%rsi
cmp    %r14,%rsi
seta   0x28(%rsp)
mov    %r13,%rdx
lea    (%r9,%r13,8),%r13
cmp    %rbx,%r13
seta   %al
cmp    %r9,%rsi
seta   0x60(%rsp)
lea    (%rcx,%rdx,8),%rdx
cmp    %rbx,%rdx
seta   %r8b
cmp    %rcx,%rsi
seta   %sil
cmp    %r14,%r13
seta   %r10b
cmp    %r9,%rdi
seta   0x50(%rsp)
cmp    %r14,%rdx
seta   %r11b
cmp    %rcx,%rdi
seta   0x40(%rsp)
cmp    %r9,%rdx
seta   %r15b
cmp    %rcx,%r13
seta   %dl
xor    %edi,%edi
test   %bpl,0x28(%rsp)
jne    2217 <rq_pricing_finite_differences_equity_american+0x1107>
and    0x60(%rsp),%al
mov    0x30(%rsp),%r13
jne    16b6 <rq_pricing_finite_differences_equity_american+0x5a6>
and    %sil,%r8b
jne    16b6 <rq_pricing_finite_differences_equity_american+0x5a6>
and    0x50(%rsp),%r10b
jne    16b6 <rq_pricing_finite_differences_equity_american+0x5a6>
and    0x40(%rsp),%r11b
jne    16b6 <rq_pricing_finite_differences_equity_american+0x5a6>
and    %dl,%r15b
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jne    16cf <rq_pricing_finite_differences_equity_american+0x5bf>
mov    %r13d,%edi
and    $0xfffffffc,%edi
movapd %xmm1,%xmm9
unpcklpd %xmm1,%xmm9
lea    0x0(,%r13,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd (%rcx,%rdx,1),%xmm6
movupd 0x10(%rcx,%rdx,1),%xmm7
movapd %xmm9,%xmm3
subpd  %xmm6,%xmm3
movapd %xmm9,%xmm6
subpd  %xmm7,%xmm6
xorpd  %xmm7,%xmm7
maxpd  %xmm3,%xmm7
xorpd  %xmm3,%xmm3
maxpd  %xmm6,%xmm3
movupd %xmm7,(%rbx,%rdx,1)
movupd %xmm3,0x10(%rbx,%rdx,1)
movupd %xmm7,(%r14,%rdx,1)
movupd %xmm3,0x10(%r14,%rdx,1)
movupd %xmm7,(%r9,%rdx,1)
movupd %xmm3,0x10(%r9,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rax
jne    15a0 <rq_pricing_finite_differences_equity_american+0x490>
cmp    %r13,%rdi
jne    16cf <rq_pricing_finite_differences_equity_american+0x5bf>
jmp    1761 <rq_pricing_finite_differences_equity_american+0x651>
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
mov    %rdi,%rax
not    %rax
test   $0x1,%r13b
je     1654 <rq_pricing_finite_differences_equity_american+0x544>
movsd  (%rcx,%rdi,8),%xmm3
subsd  %xmm1,%xmm3
pxor   %xmm6,%xmm6
maxsd  %xmm3,%xmm6
movsd  %xmm6,(%rbx,%rdi,8)
movsd  %xmm6,(%r14,%rdi,8)
movsd  %xmm6,(%r9,%rdi,8)
or     $0x1,%rdi
add    %r13,%rax
je     1761 <rq_pricing_finite_differences_equity_american+0x651>
nopl   (%rax)
movsd  (%rcx,%rdi,8),%xmm3
subsd  %xmm1,%xmm3
xorpd  %xmm6,%xmm6
maxsd  %xmm3,%xmm6
movsd  %xmm6,(%rbx,%rdi,8)
movsd  %xmm6,(%r14,%rdi,8)
movsd  %xmm6,(%r9,%rdi,8)
movsd  0x8(%rcx,%rdi,8),%xmm3
subsd  %xmm1,%xmm3
xorpd  %xmm6,%xmm6
maxsd  %xmm3,%xmm6
movsd  %xmm6,0x8(%rbx,%rdi,8)
movsd  %xmm6,0x8(%r14,%rdi,8)
movsd  %xmm6,0x8(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r13
jne    1660 <rq_pricing_finite_differences_equity_american+0x550>
jmp    1761 <rq_pricing_finite_differences_equity_american+0x651>
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
mov    %rdi,%rax
not    %rax
test   $0x1,%r13b
je     1701 <rq_pricing_finite_differences_equity_american+0x5f1>
movapd %xmm1,%xmm3
subsd  (%rcx,%rdi,8),%xmm3
pxor   %xmm6,%xmm6
maxsd  %xmm3,%xmm6
movsd  %xmm6,(%rbx,%rdi,8)
movsd  %xmm6,(%r14,%rdi,8)
movsd  %xmm6,(%r9,%rdi,8)
or     $0x1,%rdi
add    %r13,%rax
je     1761 <rq_pricing_finite_differences_equity_american+0x651>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm1,%xmm3
subsd  (%rcx,%rdi,8),%xmm3
xorpd  %xmm6,%xmm6
maxsd  %xmm3,%xmm6
movsd  %xmm6,(%rbx,%rdi,8)
movsd  %xmm6,(%r14,%rdi,8)
movsd  %xmm6,(%r9,%rdi,8)
movapd %xmm1,%xmm3
subsd  0x8(%rcx,%rdi,8),%xmm3
xorpd  %xmm6,%xmm6
maxsd  %xmm3,%xmm6
movsd  %xmm6,0x8(%rbx,%rdi,8)
movsd  %xmm6,0x8(%r14,%rdi,8)
movsd  %xmm6,0x8(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r13
jne    1710 <rq_pricing_finite_differences_equity_american+0x600>
movsd  (%rcx),%xmm1
divsd  %xmm10,%xmm1
movq   $0x0,0x0(%rbp)
movapd %xmm4,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm12,%xmm1
addsd  %xmm3,%xmm1
addsd  %xmm2,%xmm3
mulsd  %xmm5,%xmm3
addsd  0x1871(%rip),%xmm3
movsd  %xmm3,(%r12)
mulsd  %xmm5,%xmm1
mulsd  0x1867(%rip),%xmm1
movsd  %xmm1,(%r11)
cmpl   $0x2,0x20(%rsp)
jl     188a <rq_pricing_finite_differences_equity_american+0x77a>
lea    -0x1(%r13),%r10
mov    $0x1,%edi
cmp    $0x2,%r10
jae    1891 <rq_pricing_finite_differences_equity_american+0x781>
movapd 0x18cb(%rip),%xmm9
movsd  0x183b(%rip),%xmm3
movsd  0x1822(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm7
divsd  %xmm10,%xmm7
movapd %xmm4,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm12,%xmm6
mulsd  %xmm7,%xmm6
mulsd  %xmm7,%xmm1
movapd %xmm1,%xmm7
subsd  %xmm6,%xmm7
xorpd  %xmm9,%xmm7
mulsd  %xmm5,%xmm7
mulsd  %xmm3,%xmm7
movsd  %xmm7,0x0(%rbp,%rdi,8)
movapd %xmm1,%xmm7
addsd  %xmm2,%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm8,%xmm7
movsd  %xmm7,(%r12,%rdi,8)
addsd  %xmm6,%xmm1
xorpd  %xmm9,%xmm1
mulsd  %xmm5,%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,(%r11,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r13
jne    17f0 <rq_pricing_finite_differences_equity_american+0x6e0>
xor    %eax,%eax
cmpl   $0x2,0x20(%rsp)
jl     188a <rq_pricing_finite_differences_equity_american+0x77a>
movapd %xmm0,%xmm1
subsd  (%rcx),%xmm1
andpd  0x1856(%rip),%xmm1
jne    1a9b <rq_pricing_finite_differences_equity_american+0x98b>
mov    $0x1,%edi
jmp    1b2d <rq_pricing_finite_differences_equity_american+0xa1d>
xor    %eax,%eax
jmp    1b4b <rq_pricing_finite_differences_equity_american+0xa3b>
mov    %r10,0x28(%rsp)
mov    %r15,0x8(%rsp)
mov    %esi,0x10(%rsp)
lea    0x8(%rbp),%rdx
lea    0x0(,%r13,8),%rsi
add    %rbp,%rsi
lea    0x8(%r12),%rax
lea    (%r12,%r13,8),%r15
lea    0x8(%r11),%r8
lea    (%r11,%r13,8),%r9
lea    0x8(%rcx),%r11
lea    (%rcx,%r13,8),%r10
cmp    %r15,%rdx
setb   %bpl
cmp    %rsi,%rax
setb   0x60(%rsp)
cmp    %r9,%rdx
setb   %r13b
cmp    %rsi,%r8
setb   0x50(%rsp)
cmp    %r10,%rdx
setb   %dl
cmp    %rsi,%r11
setb   0x40(%rsp)
cmp    %r9,%rax
setb   %sil
cmp    %r15,%r8
setb   0x80(%rsp)
cmp    %r10,%rax
setb   %al
cmp    %r15,%r11
setb   0x38(%rsp)
cmp    %r10,%r8
setb   %r15b
cmp    %r9,%r11
setb   %r8b
test   %bpl,0x60(%rsp)
jne    21c2 <rq_pricing_finite_differences_equity_american+0x10b2>
and    0x50(%rsp),%r13b
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x28(%rsp),%r10
jne    21ea <rq_pricing_finite_differences_equity_american+0x10da>
and    0x40(%rsp),%dl
mov    0x30(%rsp),%r13
jne    21ef <rq_pricing_finite_differences_equity_american+0x10df>
and    0x80(%rsp),%sil
jne    21ef <rq_pricing_finite_differences_equity_american+0x10df>
and    0x38(%rsp),%al
jne    21ef <rq_pricing_finite_differences_equity_american+0x10df>
and    %r8b,%r15b
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jne    17cc <rq_pricing_finite_differences_equity_american+0x6bc>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
mov    %r10,%rdi
or     $0x1,%rdi
movapd %xmm10,%xmm9
unpcklpd %xmm10,%xmm9
movapd %xmm4,0x60(%rsp)
movapd %xmm4,%xmm11
unpcklpd %xmm4,%xmm11
movapd %xmm12,0x40(%rsp)
movapd %xmm12,%xmm8
unpcklpd %xmm12,%xmm8
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
movapd %xmm2,0x50(%rsp)
movapd %xmm2,%xmm1
unpcklpd %xmm2,%xmm1
xor    %edx,%edx
movapd 0x16c1(%rip),%xmm14
movapd 0x16c8(%rip),%xmm15
movapd 0x16cf(%rip),%xmm13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x8(%rcx,%rdx,8),%xmm3
divpd  %xmm9,%xmm3
movapd %xmm11,%xmm7
mulpd  %xmm3,%xmm7
movapd %xmm8,%xmm12
mulpd  %xmm3,%xmm12
mulpd  %xmm3,%xmm7
movapd %xmm7,%xmm3
subpd  %xmm12,%xmm3
xorpd  %xmm14,%xmm3
mulpd  %xmm6,%xmm3
mulpd  %xmm15,%xmm3
movupd %xmm3,0x8(%rbp,%rdx,8)
movapd %xmm7,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm13,%xmm3
movupd %xmm3,0x8(%r12,%rdx,8)
addpd  %xmm12,%xmm7
xorpd  %xmm14,%xmm7
mulpd  %xmm6,%xmm7
mulpd  %xmm15,%xmm7
movupd %xmm7,0x8(%r11,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1a00 <rq_pricing_finite_differences_equity_american+0x8f0>
cmp    %rax,%r10
movapd 0x60(%rsp),%xmm4
movapd 0x50(%rsp),%xmm2
movapd 0x40(%rsp),%xmm12
jne    17cc <rq_pricing_finite_differences_equity_american+0x6bc>
jmp    1861 <rq_pricing_finite_differences_equity_american+0x751>
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xor    %eax,%eax
mov    $0x1,%edi
movapd 0x161f(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm5
subsd  (%rcx,%rdi,8),%xmm5
andpd  %xmm2,%xmm5
ucomisd %xmm5,%xmm1
mov    %edi,%edx
cmovb  %eax,%edx
movapd %xmm5,%xmm3
cmpnlesd %xmm1,%xmm3
movapd %xmm3,%xmm4
andnpd %xmm5,%xmm4
andpd  %xmm1,%xmm3
orpd   %xmm4,%xmm3
movapd %xmm0,%xmm5
subsd  0x8(%rcx,%rdi,8),%xmm5
andpd  %xmm2,%xmm5
lea    0x1(%rdi),%r9
ucomisd %xmm5,%xmm3
mov    %r9d,%eax
cmovb  %edx,%eax
movapd %xmm5,%xmm1
cmpnlesd %xmm3,%xmm1
movapd %xmm1,%xmm4
andpd  %xmm3,%xmm4
andnpd %xmm5,%xmm1
orpd   %xmm4,%xmm1
add    $0x2,%rdi
cmp    %r8,%r9
jne    1ac0 <rq_pricing_finite_differences_equity_american+0x9b0>
test   $0x1,%r10b
je     1b49 <rq_pricing_finite_differences_equity_american+0xa39>
subsd  (%rcx,%rdi,8),%xmm0
andpd  0x1590(%rip),%xmm0
ucomisd %xmm0,%xmm1
cmovb  %eax,%edi
mov    %edi,%eax
cltq
mov    %rax,0x70(%rsp)
test   %esi,%esi
jle    2190 <rq_pricing_finite_differences_equity_american+0x1080>
movslq %r15d,%rax
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%rcx
lea    -0x2(%rcx),%eax
cltq
mov    %rax,0x28(%rsp)
movslq %ecx,%rdi
lea    (%r14,%r13,8),%rax
mov    %r13d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xb8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xb0(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %rbx,%rax
seta   %al
lea    (%rbx,%r13,8),%rcx
cmp    %r14,%rcx
seta   %cl
mov    %esi,%esi
mov    %rsi,0x38(%rsp)
and    %al,%cl
mov    %cl,0x1f(%rsp)
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rdx,%rax
mov    %rdx,0xc0(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x98(%rsp)
mov    %r13d,%r8d
and    $0x3,%r8d
lea    0x10(%rbx),%rax
mov    %rax,0xa8(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0xa0(%rsp)
mov    %rcx,0xc8(%rsp)
mov    %rcx,%r9
shl    $0x5,%r9
lea    -0x8(,%r13,8),%r15
ff
movsd  0x140e(%rip),%xmm6
movsd  0x140e(%rip),%xmm2
xorpd  %xmm7,%xmm7
mov    $0x7d0,%eax
mov    %rdi,0x60(%rsp)
mov    %r8,0x50(%rsp)
mov    %r9,0x40(%rsp)
jmp    1c5c <rq_pricing_finite_differences_equity_american+0xb4c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addsd  %xmm2,%xmm6
mov    0x38(%rsp),%rdx
lea    -0x1(%rdx),%rcx
cmp    $0x1,%rdx
mov    %rcx,0x38(%rsp)
jle    2190 <rq_pricing_finite_differences_equity_american+0x1080>
mov    %eax,0x7c(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    1dcb <rq_pricing_finite_differences_equity_american+0xcbb>
cmpl   $0x4,0x20(%rsp)
setb   %al
or     0x1f(%rsp),%al
je     1c80 <rq_pricing_finite_differences_equity_american+0xb70>
xor    %eax,%eax
jmp    1d5f <rq_pricing_finite_differences_equity_american+0xc4f>
cmpq   $0xc,0xb0(%rsp)
jae    1c8f <rq_pricing_finite_differences_equity_american+0xb7f>
xor    %eax,%eax
jmp    1d04 <rq_pricing_finite_differences_equity_american+0xbf4>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups 0x20(%r14,%rax,8),%xmm0
movups 0x30(%r14,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rax,8)
movups %xmm1,0x30(%rbx,%rax,8)
movups 0x40(%r14,%rax,8),%xmm0
movups 0x50(%r14,%rax,8),%xmm1
movups %xmm0,0x40(%rbx,%rax,8)
movups %xmm1,0x50(%rbx,%rax,8)
movupd 0x60(%r14,%rax,8),%xmm0
movupd 0x70(%r14,%rax,8),%xmm1
movupd %xmm0,0x60(%rbx,%rax,8)
movupd %xmm1,0x70(%rbx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1ca0 <rq_pricing_finite_differences_equity_american+0xb90>
cmpq   $0x0,0xc8(%rsp)
je     1d4f <rq_pricing_finite_differences_equity_american+0xc3f>
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r9
jne    1d30 <rq_pricing_finite_differences_equity_american+0xc20>
mov    0xb8(%rsp),%rcx
mov    %rcx,%rax
cmp    %r13,%rcx
je     1dcb <rq_pricing_finite_differences_equity_american+0xcbb>
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
test   %r8,%r8
je     1d85 <rq_pricing_finite_differences_equity_american+0xc75>
mov    %r8,%rdx
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1d70 <rq_pricing_finite_differences_equity_american+0xc60>
cmp    $0x3,%rcx
jb     1dcb <rq_pricing_finite_differences_equity_american+0xcbb>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    1d90 <rq_pricing_finite_differences_equity_american+0xc80>
movsd  %xmm2,0xd0(%rsp)
movsd  (%r14),%xmm0
divsd  (%r12),%xmm0
movsd  %xmm0,(%rbx)
mov    0x8(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
mov    0x28(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm2
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
xor    %r13d,%r13d
movsd  %xmm6,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  %xmm0,%xmm0
subsd  %xmm2,%xmm0
subsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
maxsd  %xmm7,%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
xorpd  %xmm5,%xmm5
cmpl   $0x2,0x20(%rsp)
jl     1ed0 <rq_pricing_finite_differences_equity_american+0xdc0>
movsd  (%rbx),%xmm4
movsd  0x8(%rbx),%xmm0
xorpd  %xmm3,%xmm3
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mulsd  0x8(%rbp,%rax,1),%xmm4
movsd  0x8(%r14,%rax,1),%xmm5
subsd  %xmm4,%xmm5
movsd  0x10(%rbx,%rax,1),%xmm1
movsd  0x8(%r11,%rax,1),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm5
divsd  0x8(%r12,%rax,1),%xmm5
movapd %xmm3,%xmm2
subsd  %xmm0,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm0,%xmm5
maxsd  %xmm7,%xmm5
subsd  %xmm5,%xmm0
movsd  %xmm5,0x8(%rbx,%rax,1)
movapd %xmm5,%xmm4
unpcklpd %xmm0,%xmm5
mulpd  %xmm5,%xmm5
movapd %xmm5,%xmm3
addpd  %xmm2,%xmm3
add    $0x8,%rax
movapd %xmm1,%xmm0
cmp    %rax,%r15
jne    1e60 <rq_pricing_finite_differences_equity_american+0xd50>
addpd  %xmm2,%xmm5
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
ucomisd %xmm7,%xmm0
jb     1f10 <rq_pricing_finite_differences_equity_american+0xe00>
xorps  %xmm2,%xmm2
sqrtsd %xmm0,%xmm2
ucomisd %xmm7,%xmm5
jae    1f35 <rq_pricing_finite_differences_equity_american+0xe25>
movapd %xmm5,%xmm0
movsd  %xmm2,0x80(%rsp)
call   1030 <sqrt@plt>
movsd  0x80(%rsp),%xmm2
xorpd  %xmm7,%xmm7
jmp    1f3c <rq_pricing_finite_differences_equity_american+0xe2c>
nopl   0x0(%rax)
movapd %xmm5,0x80(%rsp)
call   1030 <sqrt@plt>
movapd 0x80(%rsp),%xmm5
xorpd  %xmm7,%xmm7
movapd %xmm0,%xmm2
ucomisd %xmm7,%xmm5
jb     1eeb <rq_pricing_finite_differences_equity_american+0xddb>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x60(%rsp),%rdi
mov    0x50(%rsp),%r8
mov    0x40(%rsp),%r9
movsd  0x10(%rsp),%xmm6
movsd  0x10c7(%rip),%xmm1
maxsd  %xmm0,%xmm1
lea    0x1(%r13),%eax
mulsd  0x10bf(%rip),%xmm1
ucomisd %xmm1,%xmm2
jbe    1fb0 <rq_pricing_finite_differences_equity_american+0xea0>
cmp    $0x3e6,%r13d
ja     1fb0 <rq_pricing_finite_differences_equity_american+0xea0>
mov    0x8(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
mov    0x28(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm2
movsd  (%rbx,%rdi,8),%xmm1
mov    %eax,%r13d
jmp    1e20 <rq_pricing_finite_differences_equity_american+0xd10>
nopl   0x0(%rax)
ucomisd %xmm1,%xmm2
ja     219e <rq_pricing_finite_differences_equity_american+0x108e>
movsd  0xd0(%rsp),%xmm2
movapd %xmm2,%xmm0
mulsd  0x1071(%rip),%xmm0
cmp    %r13d,0x7c(%rsp)
ja     1fda <rq_pricing_finite_differences_equity_american+0xeca>
movapd %xmm0,%xmm2
mov    0x70(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
mov    0x38(%rsp),%rsi
lea    -0x1(%rsi),%ecx
mov    0x130(%rsp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
cmp    $0x2,%rsi
mov    0x30(%rsp),%r13
jl     2190 <rq_pricing_finite_differences_equity_american+0x1080>
cmpl   $0x0,0x20(%rsp)
jle    1c40 <rq_pricing_finite_differences_equity_american+0xb30>
cmpl   $0x4,0x20(%rsp)
setb   %cl
or     0x1f(%rsp),%cl
je     2030 <rq_pricing_finite_differences_equity_american+0xf20>
xor    %ecx,%ecx
jmp    2113 <rq_pricing_finite_differences_equity_american+0x1003>
nopl   0x0(%rax,%rax,1)
cmpq   $0xc,0xb0(%rsp)
jae    203f <rq_pricing_finite_differences_equity_american+0xf2f>
xor    %ecx,%ecx
jmp    20b4 <rq_pricing_finite_differences_equity_american+0xfa4>
mov    0x98(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%rbx,%rcx,8),%xmm0
movups 0x10(%rbx,%rcx,8),%xmm1
movups %xmm0,(%r14,%rcx,8)
movups %xmm1,0x10(%r14,%rcx,8)
movups 0x20(%rbx,%rcx,8),%xmm0
movups 0x30(%rbx,%rcx,8),%xmm1
movups %xmm0,0x20(%r14,%rcx,8)
movups %xmm1,0x30(%r14,%rcx,8)
movups 0x40(%rbx,%rcx,8),%xmm0
movups 0x50(%rbx,%rcx,8),%xmm1
movups %xmm0,0x40(%r14,%rcx,8)
movups %xmm1,0x50(%r14,%rcx,8)
movupd 0x60(%rbx,%rcx,8),%xmm0
movupd 0x70(%rbx,%rcx,8),%xmm1
movupd %xmm0,0x60(%r14,%rcx,8)
movupd %xmm1,0x70(%r14,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2050 <rq_pricing_finite_differences_equity_american+0xf40>
testb  $0x3,0xc0(%rsp)
03
je     20ff <rq_pricing_finite_differences_equity_american+0xfef>
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0xa8(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r9
jne    20e0 <rq_pricing_finite_differences_equity_american+0xfd0>
mov    0xb8(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r13,%rdx
je     1c40 <rq_pricing_finite_differences_equity_american+0xb30>
mov    %rcx,%rdx
not    %rdx
add    %r13,%rdx
test   $0x3,%r13b
je     2145 <rq_pricing_finite_differences_equity_american+0x1035>
mov    %r8,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2130 <rq_pricing_finite_differences_equity_american+0x1020>
cmp    $0x3,%rdx
jb     1c40 <rq_pricing_finite_differences_equity_american+0xb30>
nop
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    2150 <rq_pricing_finite_differences_equity_american+0x1040>
jmp    1c40 <rq_pricing_finite_differences_equity_american+0xb30>
mov    0x130(%rsp),%rax
movsd  (%rax),%xmm0
jmp    21b0 <rq_pricing_finite_differences_equity_american+0x10a0>
mov    0x138(%rsp),%rax
movl   $0xfffffff6,(%rax)
xorpd  %xmm0,%xmm0
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x30(%rsp),%r13
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
mov    0x28(%rsp),%r10
jmp    17cc <rq_pricing_finite_differences_equity_american+0x6bc>
mov    0x30(%rsp),%r13
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jmp    17cc <rq_pricing_finite_differences_equity_american+0x6bc>
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x30(%rsp),%r13
jmp    1619 <rq_pricing_finite_differences_equity_american+0x509>
mov    0x128(%rsp),%r11
mov    0x118(%rsp),%rbp
mov    0x30(%rsp),%r13
jmp    16c6 <rq_pricing_finite_differences_equity_american+0x5b6>

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

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