double rq_pricing_finite_differences_fxo_barrier(
    short in, short call, double S, double X, double H, double r_dom,
    double r_for, double sigma, double tau_e, double tau_d, double *bar_defs,
    unsigned short num_bar_defs, 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_fxo_barrier>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %cx,%ax
mov    %si,%cx
mov    %di,%si
mov    0x50(%rbp),%rdi
mov    0x48(%rbp),%rdi
mov    0x40(%rbp),%rdi
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    %si,-0xa(%rbp)
mov    %cx,-0xc(%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)
movsd  %xmm7,-0x50(%rbp)
mov    %rdx,-0x58(%rbp)
mov    %ax,-0x5a(%rbp)
mov    %r8d,-0x60(%rbp)
mov    %r9d,-0x64(%rbp)
movq   $0x0,-0x70(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x78(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xe67(%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    -0x64(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
cvtsi2sdl -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xdd4(%rip),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  0xdbc(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0xda4(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0xd8c(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    0x50(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    12e3 <rq_pricing_finite_differences_fxo_barrier+0x1c3>
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
cvtsi2sdl -0x9c(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
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    1290 <rq_pricing_finite_differences_fxo_barrier+0x170>
cmpw   $0x0,-0xc(%rbp)
je     13b7 <rq_pricing_finite_differences_fxo_barrier+0x297>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    13b2 <rq_pricing_finite_differences_fxo_barrier+0x292>
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x20(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1339 <rq_pricing_finite_differences_fxo_barrier+0x219>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    1356 <rq_pricing_finite_differences_fxo_barrier+0x236>
mov    0x10(%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    0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
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    12f8 <rq_pricing_finite_differences_fxo_barrier+0x1d8>
jmp    1480 <rq_pricing_finite_differences_fxo_barrier+0x360>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    147b <rq_pricing_finite_differences_fxo_barrier+0x35b>
movsd  -0x20(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1402 <rq_pricing_finite_differences_fxo_barrier+0x2e2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    141f <rq_pricing_finite_differences_fxo_barrier+0x2ff>
movsd  -0x20(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
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    13c1 <rq_pricing_finite_differences_fxo_barrier+0x2a1>
jmp    1480 <rq_pricing_finite_differences_fxo_barrier+0x360>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x10(%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    0x30(%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  0xafc(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x38(%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  0xac1(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    172a <rq_pricing_finite_differences_fxo_barrier+0x60a>
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x10(%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
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  0x9e1(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x30(%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  0x969(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x38(%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  0x926(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    157d <rq_pricing_finite_differences_fxo_barrier+0x45d>
movsd  -0x18(%rbp),%xmm0
mov    0x10(%rbp),%rax
subsd  (%rax),%xmm0
movaps 0x902(%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    17e4 <rq_pricing_finite_differences_fxo_barrier+0x6c4>
movsd  -0x18(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x8b7(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     17cb <rq_pricing_finite_differences_fxo_barrier+0x6ab>
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x9c(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    17d0 <rq_pricing_finite_differences_fxo_barrier+0x6b0>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    175e <rq_pricing_finite_differences_fxo_barrier+0x63e>
movl   $0x7d0,-0x100(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0x0,-0xd8(%rbp)
jle    1eac <rq_pricing_finite_differences_fxo_barrier+0xd8c>
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    187d <rq_pricing_finite_differences_fxo_barrier+0x75d>
mov    0x20(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    183a <rq_pricing_finite_differences_fxo_barrier+0x71a>
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x38(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
cmpl   $0x0,-0x114(%rbp)
je     18ed <rq_pricing_finite_differences_fxo_barrier+0x7cd>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    18cd <rq_pricing_finite_differences_fxo_barrier+0x7ad>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
jmp    18dd <rq_pricing_finite_differences_fxo_barrier+0x7bd>
mov    0x28(%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    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    0x18(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%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    0x18(%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    0x18(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%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    0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mov    0x18(%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    1a39 <rq_pricing_finite_differences_fxo_barrier+0x919>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1a49 <rq_pricing_finite_differences_fxo_barrier+0x929>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1a49 <rq_pricing_finite_differences_fxo_barrier+0x929>
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1ccd <rq_pricing_finite_differences_fxo_barrier+0xbad>
mov    0x20(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%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    0x18(%rbp),%rax
mov    -0xdc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%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    0x38(%rbp),%rax
movslq -0xdc(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mov    0x18(%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     1be7 <rq_pricing_finite_differences_fxo_barrier+0xac7>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0xdc(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1bba <rq_pricing_finite_differences_fxo_barrier+0xa9a>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
jmp    1bd2 <rq_pricing_finite_differences_fxo_barrier+0xab2>
mov    0x28(%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    1c31 <rq_pricing_finite_differences_fxo_barrier+0xb11>
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c11 <rq_pricing_finite_differences_fxo_barrier+0xaf1>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1c21 <rq_pricing_finite_differences_fxo_barrier+0xb01>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1c21 <rq_pricing_finite_differences_fxo_barrier+0xb01>
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    0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x120(%rbp),%xmm0
ff
mov    0x18(%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    0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1a7b <rq_pricing_finite_differences_fxo_barrier+0x95b>
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  0x322(%rip),%xmm0
ucomisd -0x128(%rbp),%xmm0
ff
jbe    1d2c <rq_pricing_finite_differences_fxo_barrier+0xc0c>
movsd  0x30c(%rip),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1d31 <rq_pricing_finite_differences_fxo_barrier+0xc11>
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    1d6e <rq_pricing_finite_differences_fxo_barrier+0xc4e>
cmpl   $0x3e8,-0x118(%rbp)
setl   %al
mov    %al,-0x171(%rbp)
mov    -0x171(%rbp),%al
test   $0x1,%al
jne    195f <rq_pricing_finite_differences_fxo_barrier+0x83f>
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    1dc1 <rq_pricing_finite_differences_fxo_barrier+0xca1>
mov    0x50(%rbp),%rax
movl   $0xfffffff6,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1ec3 <rq_pricing_finite_differences_fxo_barrier+0xda3>
mov    -0x100(%rbp),%eax
cmp    -0xfc(%rbp),%eax
jge    1deb <rq_pricing_finite_differences_fxo_barrier+0xccb>
movsd  0x25d(%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    0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xd8(%rbp)
jle    1e93 <rq_pricing_finite_differences_fxo_barrier+0xd73>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1e8e <rq_pricing_finite_differences_fxo_barrier+0xd6e>
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    1e4b <rq_pricing_finite_differences_fxo_barrier+0xd2b>
jmp    1e93 <rq_pricing_finite_differences_fxo_barrier+0xd73>
jmp    1e98 <rq_pricing_finite_differences_fxo_barrier+0xd78>
mov    -0xd8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd8(%rbp)
jmp    17f7 <rq_pricing_finite_differences_fxo_barrier+0x6d7>
mov    0x48(%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_fxo_barrier>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    0x150(%rsp),%rax
mov    0x140(%rsp),%rdi
mov    0x138(%rsp),%r13
mov    0x130(%rsp),%rbx
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r14
mov    0x110(%rsp),%r10
movsd  0x1e9e(%rip),%xmm10
mulsd  %xmm1,%xmm10
lea    -0x1(%r9),%r11d
cvtsi2sd %r11,%xmm2
divsd  %xmm2,%xmm10
xorps  %xmm2,%xmm2
cvtsi2sd %r8d,%xmm2
divsd  %xmm2,%xmm6
mulsd  %xmm5,%xmm5
movapd %xmm3,%xmm12
subsd  %xmm4,%xmm12
movl   $0x0,(%rax)
mov    %r9d,%r12d
mov    %r9,0x28(%rsp)
test   %r9d,%r9d
mov    %r12,0x30(%rsp)
jle    1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
cmpl   $0x4,0x28(%rsp)
jae    11b9 <rq_pricing_finite_differences_fxo_barrier+0xa9>
xor    %edx,%edx
jmp    12f0 <rq_pricing_finite_differences_fxo_barrier+0x1e0>
movapd %xmm12,%xmm8
mov    %r12d,%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     1552 <rq_pricing_finite_differences_fxo_barrier+0x442>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
or     $0x2,%rax
and    %r9,%rax
movdqa 0x1e51(%rip),%xmm2
xor    %ecx,%ecx
movdqa 0x1e56(%rip),%xmm9
xorpd  %xmm14,%xmm14
movdqa 0x1e58(%rip),%xmm11
movdqa 0x1e5f(%rip),%xmm12
movdqa 0x1e66(%rip),%xmm13
nopw   0x0(%rax,%rax,1)
movdqa %xmm2,%xmm7
cvtdq2pd %xmm2,%xmm4
paddd  %xmm9,%xmm7
cvtdq2pd %xmm7,%xmm7
mulpd  %xmm15,%xmm4
addpd  %xmm14,%xmm4
mulpd  %xmm15,%xmm7
addpd  %xmm14,%xmm7
movupd %xmm4,(%r10,%rcx,8)
movupd %xmm7,0x10(%r10,%rcx,8)
movdqa %xmm2,%xmm4
paddd  %xmm11,%xmm4
movdqa %xmm2,%xmm7
cvtdq2pd %xmm4,%xmm4
paddd  %xmm12,%xmm7
cvtdq2pd %xmm7,%xmm7
mulpd  %xmm15,%xmm4
addpd  %xmm14,%xmm4
mulpd  %xmm15,%xmm7
addpd  %xmm14,%xmm7
movupd %xmm4,0x20(%r10,%rcx,8)
movupd %xmm7,0x30(%r10,%rcx,8)
add    $0x8,%rcx
paddd  %xmm13,%xmm2
add    $0xfffffffffffffffe,%rax
jne    1230 <rq_pricing_finite_differences_fxo_barrier+0x120>
test   $0x1,%r9b
je     12e6 <rq_pricing_finite_differences_fxo_barrier+0x1d6>
cvtdq2pd %xmm2,%xmm4
paddd  0x1da1(%rip),%xmm2
cvtdq2pd %xmm2,%xmm2
mulpd  %xmm15,%xmm4
xorpd  %xmm7,%xmm7
addpd  %xmm7,%xmm4
mulpd  %xmm15,%xmm2
addpd  %xmm7,%xmm2
movupd %xmm4,(%r10,%rcx,8)
movupd %xmm2,0x10(%r10,%rcx,8)
cmp    %r12,%rdx
movapd %xmm8,%xmm12
je     131f <rq_pricing_finite_differences_fxo_barrier+0x20f>
pxor   %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm4,%xmm4
cvtsi2sd %edx,%xmm4
mulsd  %xmm10,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r10,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1300 <rq_pricing_finite_differences_fxo_barrier+0x1f0>
mov    0x128(%rsp),%rdx
test   %si,%si
je     1349 <rq_pricing_finite_differences_fxo_barrier+0x239>
cmpl   $0x0,0x28(%rsp)
jle    1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
cmpl   $0x4,0x28(%rsp)
jae    13f7 <rq_pricing_finite_differences_fxo_barrier+0x2e7>
xor    %esi,%esi
jmp    16dc <rq_pricing_finite_differences_fxo_barrier+0x5cc>
cmpl   $0x0,0x28(%rsp)
jle    1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
cmpl   $0x4,0x28(%rsp)
jae    156b <rq_pricing_finite_differences_fxo_barrier+0x45b>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
test   $0x1,%r12b
je     1394 <rq_pricing_finite_differences_fxo_barrier+0x284>
movapd %xmm1,%xmm2
subsd  (%r10,%rsi,8),%xmm2
xorpd  %xmm4,%xmm4
maxsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rsi,8)
movsd  %xmm4,0x0(%rbp,%rsi,8)
movsd  %xmm4,(%rdx,%rsi,8)
or     $0x1,%rsi
add    %r12,%rax
je     1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
nopl   (%rax)
movapd %xmm1,%xmm2
subsd  (%r10,%rsi,8),%xmm2
xorpd  %xmm4,%xmm4
maxsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rsi,8)
movsd  %xmm4,0x0(%rbp,%rsi,8)
movsd  %xmm4,(%rdx,%rsi,8)
movapd %xmm1,%xmm2
subsd  0x8(%r10,%rsi,8),%xmm2
xorpd  %xmm4,%xmm4
maxsd  %xmm2,%xmm4
movsd  %xmm4,0x8(%r14,%rsi,8)
movsd  %xmm4,0x8(%rbp,%rsi,8)
movsd  %xmm4,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    13a0 <rq_pricing_finite_differences_fxo_barrier+0x290>
jmp    1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
mov    %r11,0x8(%rsp)
mov    %r8d,0x10(%rsp)
lea    0x0(,%r12,8),%rsi
add    %rbp,%rsi
cmp    %r14,%rsi
seta   0x60(%rsp)
lea    (%r14,%r12,8),%rdi
cmp    %rbp,%rdi
seta   0x50(%rsp)
mov    %r12,%rax
lea    (%rdx,%r12,8),%r12
cmp    %r14,%r12
seta   %r9b
cmp    %rdx,%rdi
seta   0x20(%rsp)
lea    (%r10,%rax,8),%rax
cmp    %r14,%rax
seta   %r8b
cmp    %r10,%rdi
seta   0x40(%rsp)
cmp    %rbp,%r12
seta   %dil
cmp    %rdx,%rsi
seta   0x70(%rsp)
cmp    %rbp,%rax
seta   %r11b
cmp    %r10,%rsi
seta   0x38(%rsp)
cmp    %rdx,%rax
seta   %r15b
cmp    %r10,%r12
seta   %cl
xor    %esi,%esi
mov    0x50(%rsp),%al
test   %al,0x60(%rsp)
jne    2243 <rq_pricing_finite_differences_fxo_barrier+0x1133>
and    0x20(%rsp),%r9b
mov    0x30(%rsp),%r12
jne    16ca <rq_pricing_finite_differences_fxo_barrier+0x5ba>
and    0x40(%rsp),%r8b
jne    16ca <rq_pricing_finite_differences_fxo_barrier+0x5ba>
and    0x70(%rsp),%dil
jne    16ca <rq_pricing_finite_differences_fxo_barrier+0x5ba>
and    0x38(%rsp),%r11b
jne    16ca <rq_pricing_finite_differences_fxo_barrier+0x5ba>
mov    %ecx,%eax
and    %cl,%r15b
mov    0x140(%rsp),%rdi
mov    0x10(%rsp),%r8d
mov    0x8(%rsp),%r11
jne    16dc <rq_pricing_finite_differences_fxo_barrier+0x5cc>
mov    %r12d,%esi
and    $0xfffffffc,%esi
movapd %xmm1,%xmm9
unpcklpd %xmm1,%xmm9
lea    0x0(,%r12,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %ecx,%ecx
movupd (%r10,%rcx,1),%xmm4
movupd 0x10(%r10,%rcx,1),%xmm7
subpd  %xmm9,%xmm4
subpd  %xmm9,%xmm7
pxor   %xmm2,%xmm2
maxpd  %xmm4,%xmm2
xorpd  %xmm4,%xmm4
maxpd  %xmm7,%xmm4
movupd %xmm2,(%r14,%rcx,1)
movupd %xmm4,0x10(%r14,%rcx,1)
movupd %xmm2,0x0(%rbp,%rcx,1)
movupd %xmm4,0x10(%rbp,%rcx,1)
movupd %xmm2,(%rdx,%rcx,1)
movupd %xmm4,0x10(%rdx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rax
jne    14f0 <rq_pricing_finite_differences_fxo_barrier+0x3e0>
cmp    %r12,%rsi
jne    16dc <rq_pricing_finite_differences_fxo_barrier+0x5cc>
jmp    1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
movdqa 0x1af6(%rip),%xmm2
xor    %ecx,%ecx
test   $0x1,%r9b
jne    12b3 <rq_pricing_finite_differences_fxo_barrier+0x1a3>
jmp    12e6 <rq_pricing_finite_differences_fxo_barrier+0x1d6>
mov    %r11,0x8(%rsp)
mov    %r8d,0x10(%rsp)
lea    0x0(,%r12,8),%rsi
add    %rbp,%rsi
cmp    %r14,%rsi
seta   0x60(%rsp)
lea    (%r14,%r12,8),%rdi
cmp    %rbp,%rdi
seta   0x50(%rsp)
lea    (%rdx,%r12,8),%r8
cmp    %r14,%r8
seta   %r9b
cmp    %rdx,%rdi
seta   0x20(%rsp)
lea    (%r10,%r12,8),%rax
cmp    %r14,%rax
seta   %r12b
cmp    %r10,%rdi
seta   %dil
cmp    %rbp,%r8
seta   %cl
cmp    %rdx,%rsi
seta   0x40(%rsp)
cmp    %rbp,%rax
seta   %r11b
cmp    %r10,%rsi
seta   0x70(%rsp)
cmp    %rdx,%rax
seta   %r15b
cmp    %r10,%r8
seta   %r8b
xor    %esi,%esi
mov    0x50(%rsp),%al
test   %al,0x60(%rsp)
jne    19f2 <rq_pricing_finite_differences_fxo_barrier+0x8e2>
and    0x20(%rsp),%r9b
jne    19f2 <rq_pricing_finite_differences_fxo_barrier+0x8e2>
and    %dil,%r12b
jne    19f2 <rq_pricing_finite_differences_fxo_barrier+0x8e2>
and    0x40(%rsp),%cl
mov    0x30(%rsp),%r12
jne    19e8 <rq_pricing_finite_differences_fxo_barrier+0x8d8>
and    0x70(%rsp),%r11b
jne    19e8 <rq_pricing_finite_differences_fxo_barrier+0x8d8>
and    %r8b,%r15b
mov    0x140(%rsp),%rdi
mov    0x10(%rsp),%r8d
mov    0x8(%rsp),%r11
jne    1361 <rq_pricing_finite_differences_fxo_barrier+0x251>
mov    %r12d,%esi
and    $0xfffffffc,%esi
movapd %xmm1,%xmm9
unpcklpd %xmm1,%xmm9
lea    0x0(,%r12,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%r10,%rcx,1),%xmm4
movupd 0x10(%r10,%rcx,1),%xmm7
movapd %xmm9,%xmm2
subpd  %xmm4,%xmm2
movapd %xmm9,%xmm4
subpd  %xmm7,%xmm4
xorpd  %xmm7,%xmm7
maxpd  %xmm2,%xmm7
xorpd  %xmm2,%xmm2
maxpd  %xmm4,%xmm2
movupd %xmm7,(%r14,%rcx,1)
movupd %xmm2,0x10(%r14,%rcx,1)
movupd %xmm7,0x0(%rbp,%rcx,1)
movupd %xmm2,0x10(%rbp,%rcx,1)
movupd %xmm7,(%rdx,%rcx,1)
movupd %xmm2,0x10(%rdx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rax
jne    1660 <rq_pricing_finite_differences_fxo_barrier+0x550>
cmp    %r12,%rsi
jne    1361 <rq_pricing_finite_differences_fxo_barrier+0x251>
jmp    1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
mov    0x140(%rsp),%rdi
mov    0x10(%rsp),%r8d
mov    0x8(%rsp),%r11
mov    %rsi,%rax
not    %rax
test   $0x1,%r12b
je     170f <rq_pricing_finite_differences_fxo_barrier+0x5ff>
movsd  (%r10,%rsi,8),%xmm2
subsd  %xmm1,%xmm2
xorpd  %xmm4,%xmm4
maxsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rsi,8)
movsd  %xmm4,0x0(%rbp,%rsi,8)
movsd  %xmm4,(%rdx,%rsi,8)
or     $0x1,%rsi
add    %r12,%rax
je     1772 <rq_pricing_finite_differences_fxo_barrier+0x662>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r10,%rsi,8),%xmm2
subsd  %xmm1,%xmm2
xorpd  %xmm4,%xmm4
maxsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rsi,8)
movsd  %xmm4,0x0(%rbp,%rsi,8)
movsd  %xmm4,(%rdx,%rsi,8)
movsd  0x8(%r10,%rsi,8),%xmm2
subsd  %xmm1,%xmm2
xorpd  %xmm4,%xmm4
maxsd  %xmm2,%xmm4
movsd  %xmm4,0x8(%r14,%rsi,8)
movsd  %xmm4,0x8(%rbp,%rsi,8)
movsd  %xmm4,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    1720 <rq_pricing_finite_differences_fxo_barrier+0x610>
movsd  (%r10),%xmm1
divsd  %xmm10,%xmm1
movq   $0x0,(%rbx)
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm12,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm3,%xmm2
mulsd  %xmm6,%xmm2
addsd  0x1860(%rip),%xmm2
movsd  %xmm2,0x0(%r13)
mulsd  %xmm6,%xmm1
mulsd  0x1856(%rip),%xmm1
movsd  %xmm1,(%rdi)
cmpl   $0x2,0x28(%rsp)
jl     1ae7 <rq_pricing_finite_differences_fxo_barrier+0x9d7>
lea    -0x1(%r12),%r15
mov    $0x1,%esi
cmp    $0x2,%r15
jb     1a32 <rq_pricing_finite_differences_fxo_barrier+0x922>
mov    %r15,0x20(%rsp)
mov    %r11,0x8(%rsp)
mov    %r8d,0x10(%rsp)
lea    0x8(%rbx),%rdx
lea    (%rbx,%r12,8),%r9
lea    0x8(%r13),%rax
lea    0x0(%r13,%r12,8),%r15
mov    %r12,%rcx
lea    0x8(%rdi),%r12
lea    (%rdi,%rcx,8),%rdi
lea    0x8(%r10),%r8
lea    (%r10,%rcx,8),%r11
cmp    %r15,%rdx
setb   0x60(%rsp)
cmp    %r9,%rax
setb   0x50(%rsp)
cmp    %rdi,%rdx
setb   %cl
cmp    %r9,%r12
setb   0x40(%rsp)
cmp    %r11,%rdx
setb   %dl
cmp    %r9,%r8
setb   0x70(%rsp)
cmp    %rdi,%rax
setb   %bl
cmp    %r15,%r12
setb   0x38(%rsp)
cmp    %r11,%rax
setb   %r9b
cmp    %r15,%r8
setb   0x90(%rsp)
cmp    %r11,%r12
setb   %r15b
cmp    %rdi,%r8
setb   %r8b
mov    0x50(%rsp),%al
test   %al,0x60(%rsp)
jne    1a0e <rq_pricing_finite_differences_fxo_barrier+0x8fe>
and    0x40(%rsp),%cl
mov    0x140(%rsp),%rdi
mov    0x30(%rsp),%r12
jne    1a1b <rq_pricing_finite_differences_fxo_barrier+0x90b>
and    0x70(%rsp),%dl
jne    1a1b <rq_pricing_finite_differences_fxo_barrier+0x90b>
and    0x38(%rsp),%bl
jne    1a1b <rq_pricing_finite_differences_fxo_barrier+0x90b>
and    0x90(%rsp),%r9b
mov    0x130(%rsp),%rbx
jne    19d7 <rq_pricing_finite_differences_fxo_barrier+0x8c7>
and    %r8b,%r15b
mov    0x10(%rsp),%r8d
mov    0x8(%rsp),%r11
mov    0x20(%rsp),%r15
jne    1a32 <rq_pricing_finite_differences_fxo_barrier+0x922>
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    %r15,%rsi
or     $0x1,%rsi
movapd %xmm10,%xmm9
unpcklpd %xmm10,%xmm9
movapd %xmm5,0x60(%rsp)
movapd %xmm5,%xmm11
unpcklpd %xmm5,%xmm11
movapd %xmm12,0x40(%rsp)
movapd %xmm12,%xmm8
unpcklpd %xmm12,%xmm8
movapd %xmm6,%xmm2
unpcklpd %xmm6,%xmm2
movapd %xmm3,0x50(%rsp)
movapd %xmm3,%xmm1
unpcklpd %xmm3,%xmm1
xor    %ecx,%ecx
movapd 0x1775(%rip),%xmm14
movapd 0x177c(%rip),%xmm15
movapd 0x1783(%rip),%xmm13
nopl   (%rax)
movupd 0x8(%r10,%rcx,8),%xmm4
divpd  %xmm9,%xmm4
movapd %xmm11,%xmm7
mulpd  %xmm4,%xmm7
movapd %xmm8,%xmm12
mulpd  %xmm4,%xmm12
mulpd  %xmm4,%xmm7
movapd %xmm7,%xmm4
subpd  %xmm12,%xmm4
xorpd  %xmm14,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm15,%xmm4
movupd %xmm4,0x8(%rbx,%rcx,8)
movapd %xmm7,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm13,%xmm4
movupd %xmm4,0x8(%r13,%rcx,8)
addpd  %xmm12,%xmm7
xorpd  %xmm14,%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm15,%xmm7
movupd %xmm7,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1940 <rq_pricing_finite_differences_fxo_barrier+0x830>
cmp    %rax,%r15
movapd 0x60(%rsp),%xmm5
movapd 0x50(%rsp),%xmm3
movapd 0x40(%rsp),%xmm12
jne    1a32 <rq_pricing_finite_differences_fxo_barrier+0x922>
jmp    1ac1 <rq_pricing_finite_differences_fxo_barrier+0x9b1>
mov    0x10(%rsp),%r8d
mov    0x8(%rsp),%r11
mov    0x20(%rsp),%r15
jmp    1a32 <rq_pricing_finite_differences_fxo_barrier+0x922>
mov    0x140(%rsp),%rdi
jmp    19ff <rq_pricing_finite_differences_fxo_barrier+0x8ef>
mov    0x140(%rsp),%rdi
mov    0x30(%rsp),%r12
mov    0x10(%rsp),%r8d
mov    0x8(%rsp),%r11
jmp    1361 <rq_pricing_finite_differences_fxo_barrier+0x251>
mov    0x140(%rsp),%rdi
mov    0x30(%rsp),%r12
mov    0x10(%rsp),%r8d
mov    0x8(%rsp),%r11
mov    0x20(%rsp),%r15
mov    0x130(%rsp),%rbx
movapd 0x1665(%rip),%xmm9
movsd  0x15d5(%rip),%xmm2
movsd  0x15bc(%rip),%xmm8
nopl   0x0(%rax)
movsd  (%r10,%rsi,8),%xmm7
divsd  %xmm10,%xmm7
movapd %xmm5,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm12,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm7,%xmm1
movapd %xmm1,%xmm7
subsd  %xmm4,%xmm7
xorpd  %xmm9,%xmm7
mulsd  %xmm6,%xmm7
mulsd  %xmm2,%xmm7
movsd  %xmm7,(%rbx,%rsi,8)
movapd %xmm1,%xmm7
addsd  %xmm3,%xmm7
mulsd  %xmm6,%xmm7
addsd  %xmm8,%xmm7
movsd  %xmm7,0x0(%r13,%rsi,8)
addsd  %xmm4,%xmm1
xorpd  %xmm9,%xmm1
mulsd  %xmm6,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r12
jne    1a50 <rq_pricing_finite_differences_fxo_barrier+0x940>
xor    %ecx,%ecx
cmpl   $0x2,0x28(%rsp)
jl     1ae7 <rq_pricing_finite_differences_fxo_barrier+0x9d7>
movapd %xmm0,%xmm1
subsd  (%r10),%xmm1
andpd  0x15f5(%rip),%xmm1
jne    1aff <rq_pricing_finite_differences_fxo_barrier+0x9ef>
mov    $0x1,%esi
jmp    1b8e <rq_pricing_finite_differences_fxo_barrier+0xa7e>
xor    %eax,%eax
mov    %rax,0x88(%rsp)
test   %r8d,%r8d
jg     1bbf <rq_pricing_finite_differences_fxo_barrier+0xaaf>
jmp    2211 <rq_pricing_finite_differences_fxo_barrier+0x1101>
mov    %r15,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
mov    $0x1,%esi
movapd 0x15bb(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm0,%xmm5
subsd  (%r10,%rsi,8),%xmm5
andpd  %xmm2,%xmm5
ucomisd %xmm5,%xmm1
mov    %esi,%edx
cmovb  %ecx,%edx
movapd %xmm5,%xmm3
cmpnlesd %xmm1,%xmm3
movapd %xmm3,%xmm4
andnpd %xmm5,%xmm4
andpd  %xmm1,%xmm3
orpd   %xmm4,%xmm3
movapd %xmm0,%xmm5
subsd  0x8(%r10,%rsi,8),%xmm5
andpd  %xmm2,%xmm5
lea    0x1(%rsi),%rax
ucomisd %xmm5,%xmm3
mov    %eax,%ecx
cmovb  %edx,%ecx
movapd %xmm5,%xmm1
cmpnlesd %xmm3,%xmm1
movapd %xmm1,%xmm4
andpd  %xmm3,%xmm4
andnpd %xmm5,%xmm1
orpd   %xmm4,%xmm1
add    $0x2,%rsi
cmp    %r9,%rax
jne    1b20 <rq_pricing_finite_differences_fxo_barrier+0xa10>
test   $0x1,%r15b
je     1bab <rq_pricing_finite_differences_fxo_barrier+0xa9b>
subsd  (%r10,%rsi,8),%xmm0
andpd  0x152e(%rip),%xmm0
ucomisd %xmm0,%xmm1
cmovb  %ecx,%esi
mov    %esi,%ecx
movslq %ecx,%rcx
mov    %rcx,0x88(%rsp)
test   %r8d,%r8d
jle    2211 <rq_pricing_finite_differences_fxo_barrier+0x1101>
movslq %r11d,%rax
mov    %rax,0x8(%rsp)
mov    0x28(%rsp),%rcx
lea    -0x2(%rcx),%eax
cltq
mov    %rax,0x60(%rsp)
movslq %ecx,%rbx
lea    0x0(,%r12,8),%rax
add    %rbp,%rax
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xc0(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xb8(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %r14,%rax
seta   %al
lea    (%r14,%r12,8),%rcx
cmp    %rbp,%rcx
seta   %cl
mov    %r8d,%esi
mov    %rsi,0x38(%rsp)
and    %al,%cl
mov    %cl,0x1f(%rsp)
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rdx,%rax
mov    %rdx,0xc8(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0xa0(%rsp)
mov    %r12d,%r8d
and    $0x3,%r8d
lea    0x10(%r14),%rax
mov    %rax,0xb0(%rsp)
lea    0x10(%rbp),%rax
mov    %rax,0xa8(%rsp)
mov    %rcx,0xd0(%rsp)
mov    %rcx,%r9
shl    $0x5,%r9
lea    -0x8(,%r12,8),%r15
ff
movsd  0x139f(%rip),%xmm6
movsd  0x139f(%rip),%xmm2
xorpd  %xmm7,%xmm7
mov    $0x7d0,%eax
mov    %rbx,0x50(%rsp)
mov    %r8,0x20(%rsp)
mov    %r9,0x40(%rsp)
jmp    1ccc <rq_pricing_finite_differences_fxo_barrier+0xbbc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  %xmm2,%xmm6
mov    0x38(%rsp),%rdx
lea    -0x1(%rdx),%rcx
cmp    $0x1,%rdx
mov    %rcx,0x38(%rsp)
jle    2211 <rq_pricing_finite_differences_fxo_barrier+0x1101>
mov    %eax,0x9c(%rsp)
cmpl   $0x0,0x28(%rsp)
jle    1e4c <rq_pricing_finite_differences_fxo_barrier+0xd3c>
cmpl   $0x4,0x28(%rsp)
setb   %al
or     0x1f(%rsp),%al
je     1d00 <rq_pricing_finite_differences_fxo_barrier+0xbf0>
xor    %eax,%eax
jmp    1ddf <rq_pricing_finite_differences_fxo_barrier+0xccf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0xc,0xb8(%rsp)
jae    1d0f <rq_pricing_finite_differences_fxo_barrier+0xbff>
xor    %eax,%eax
jmp    1d85 <rq_pricing_finite_differences_fxo_barrier+0xc75>
mov    0xa0(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups 0x0(%rbp,%rax,8),%xmm0
movups 0x10(%rbp,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movups 0x20(%rbp,%rax,8),%xmm0
movups 0x30(%rbp,%rax,8),%xmm1
movups %xmm0,0x20(%r14,%rax,8)
movups %xmm1,0x30(%r14,%rax,8)
movups 0x40(%rbp,%rax,8),%xmm0
movups 0x50(%rbp,%rax,8),%xmm1
movups %xmm0,0x40(%r14,%rax,8)
movups %xmm1,0x50(%r14,%rax,8)
movupd 0x60(%rbp,%rax,8),%xmm0
movupd 0x70(%rbp,%rax,8),%xmm1
movupd %xmm0,0x60(%r14,%rax,8)
movupd %xmm1,0x70(%r14,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1d20 <rq_pricing_finite_differences_fxo_barrier+0xc10>
cmpq   $0x0,0xd0(%rsp)
je     1dcf <rq_pricing_finite_differences_fxo_barrier+0xcbf>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
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    1db0 <rq_pricing_finite_differences_fxo_barrier+0xca0>
mov    0xc0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     1e4c <rq_pricing_finite_differences_fxo_barrier+0xd3c>
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %r8,%r8
je     1e06 <rq_pricing_finite_differences_fxo_barrier+0xcf6>
mov    %r8,%rdx
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1df0 <rq_pricing_finite_differences_fxo_barrier+0xce0>
cmp    $0x3,%rcx
jb     1e4c <rq_pricing_finite_differences_fxo_barrier+0xd3c>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1e10 <rq_pricing_finite_differences_fxo_barrier+0xd00>
movsd  %xmm2,0x90(%rsp)
movsd  0x0(%rbp),%xmm0
divsd  0x0(%r13),%xmm0
movsd  %xmm0,(%r14)
mov    0x8(%rsp),%rax
movsd  (%r14,%rax,8),%xmm0
mov    0x60(%rsp),%rax
movsd  (%r14,%rax,8),%xmm2
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r14,%rbx,8)
xor    %r12d,%r12d
movsd  %xmm6,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
addsd  %xmm0,%xmm0
subsd  %xmm2,%xmm0
subsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
maxsd  %xmm7,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
xorpd  %xmm5,%xmm5
cmpl   $0x2,0x28(%rsp)
mov    0x130(%rsp),%rcx
jl     1f60 <rq_pricing_finite_differences_fxo_barrier+0xe50>
movsd  (%r14),%xmm4
movsd  0x8(%r14),%xmm0
xorpd  %xmm3,%xmm3
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mulsd  0x8(%rcx,%rax,1),%xmm4
movsd  0x8(%rbp,%rax,1),%xmm5
subsd  %xmm4,%xmm5
movsd  0x10(%r14,%rax,1),%xmm1
movsd  0x8(%rdi,%rax,1),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm5
divsd  0x8(%r13,%rax,1),%xmm5
movapd %xmm3,%xmm2
subsd  %xmm0,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm0,%xmm5
maxsd  %xmm7,%xmm5
subsd  %xmm5,%xmm0
movsd  %xmm5,0x8(%r14,%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    1ef0 <rq_pricing_finite_differences_fxo_barrier+0xde0>
addpd  %xmm2,%xmm5
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
ucomisd %xmm7,%xmm0
jb     1fa0 <rq_pricing_finite_differences_fxo_barrier+0xe90>
xorps  %xmm2,%xmm2
sqrtsd %xmm0,%xmm2
ucomisd %xmm7,%xmm5
jae    1fbf <rq_pricing_finite_differences_fxo_barrier+0xeaf>
movapd %xmm5,%xmm0
movsd  %xmm2,0x70(%rsp)
call   1030 <sqrt@plt>
movsd  0x70(%rsp),%xmm2
xorpd  %xmm7,%xmm7
jmp    1fc6 <rq_pricing_finite_differences_fxo_barrier+0xeb6>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm5,0x70(%rsp)
call   1030 <sqrt@plt>
movapd 0x70(%rsp),%xmm5
xorpd  %xmm7,%xmm7
movapd %xmm0,%xmm2
ucomisd %xmm7,%xmm5
jb     1f7b <rq_pricing_finite_differences_fxo_barrier+0xe6b>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
mov    0x140(%rsp),%rdi
mov    0x50(%rsp),%rbx
mov    0x20(%rsp),%r8
mov    0x40(%rsp),%r9
movsd  0x10(%rsp),%xmm6
movsd  0x1045(%rip),%xmm1
maxsd  %xmm0,%xmm1
lea    0x1(%r12),%eax
mulsd  0x103c(%rip),%xmm1
ucomisd %xmm1,%xmm2
jbe    2030 <rq_pricing_finite_differences_fxo_barrier+0xf20>
cmp    $0x3e6,%r12d
ja     2030 <rq_pricing_finite_differences_fxo_barrier+0xf20>
mov    0x8(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm0
mov    0x60(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm2
movsd  (%r14,%rbx,8),%xmm1
mov    %eax,%r12d
jmp    1ea0 <rq_pricing_finite_differences_fxo_barrier+0xd90>
nop
ucomisd %xmm1,%xmm2
ja     221f <rq_pricing_finite_differences_fxo_barrier+0x110f>
movsd  0x90(%rsp),%xmm2
movapd %xmm2,%xmm0
mulsd  0xff1(%rip),%xmm0
cmp    %r12d,0x9c(%rsp)
ja     205d <rq_pricing_finite_differences_fxo_barrier+0xf4d>
movapd %xmm0,%xmm2
mov    0x88(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm0
mov    0x38(%rsp),%rsi
lea    -0x1(%rsi),%ecx
mov    0x148(%rsp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
cmp    $0x2,%rsi
mov    0x30(%rsp),%r12
jl     2211 <rq_pricing_finite_differences_fxo_barrier+0x1101>
cmpl   $0x0,0x28(%rsp)
jle    1cb0 <rq_pricing_finite_differences_fxo_barrier+0xba0>
cmpl   $0x4,0x28(%rsp)
setb   %cl
or     0x1f(%rsp),%cl
je     20b0 <rq_pricing_finite_differences_fxo_barrier+0xfa0>
xor    %ecx,%ecx
jmp    2193 <rq_pricing_finite_differences_fxo_barrier+0x1083>
nop
cmpq   $0xc,0xb8(%rsp)
jae    20bf <rq_pricing_finite_differences_fxo_barrier+0xfaf>
xor    %ecx,%ecx
jmp    2135 <rq_pricing_finite_differences_fxo_barrier+0x1025>
mov    0xa0(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r14,%rcx,8),%xmm0
movups 0x10(%r14,%rcx,8),%xmm1
movups %xmm0,0x0(%rbp,%rcx,8)
movups %xmm1,0x10(%rbp,%rcx,8)
movups 0x20(%r14,%rcx,8),%xmm0
movups 0x30(%r14,%rcx,8),%xmm1
movups %xmm0,0x20(%rbp,%rcx,8)
movups %xmm1,0x30(%rbp,%rcx,8)
movups 0x40(%r14,%rcx,8),%xmm0
movups 0x50(%r14,%rcx,8),%xmm1
movups %xmm0,0x40(%rbp,%rcx,8)
movups %xmm1,0x50(%rbp,%rcx,8)
movupd 0x60(%r14,%rcx,8),%xmm0
movupd 0x70(%r14,%rcx,8),%xmm1
movupd %xmm0,0x60(%rbp,%rcx,8)
movupd %xmm1,0x70(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    20d0 <rq_pricing_finite_differences_fxo_barrier+0xfc0>
testb  $0x3,0xc8(%rsp)
03
je     217f <rq_pricing_finite_differences_fxo_barrier+0x106f>
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0xb0(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
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    2160 <rq_pricing_finite_differences_fxo_barrier+0x1050>
mov    0xc0(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r12,%rdx
je     1cb0 <rq_pricing_finite_differences_fxo_barrier+0xba0>
mov    %rcx,%rdx
not    %rdx
add    %r12,%rdx
test   $0x3,%r12b
je     21c6 <rq_pricing_finite_differences_fxo_barrier+0x10b6>
mov    %r8,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    21b0 <rq_pricing_finite_differences_fxo_barrier+0x10a0>
cmp    $0x3,%rdx
jb     1cb0 <rq_pricing_finite_differences_fxo_barrier+0xba0>
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r12
jne    21d0 <rq_pricing_finite_differences_fxo_barrier+0x10c0>
jmp    1cb0 <rq_pricing_finite_differences_fxo_barrier+0xba0>
mov    0x148(%rsp),%rax
movsd  (%rax),%xmm0
jmp    2231 <rq_pricing_finite_differences_fxo_barrier+0x1121>
mov    0x150(%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    0x140(%rsp),%rdi
mov    0x30(%rsp),%r12
jmp    16d2 <rq_pricing_finite_differences_fxo_barrier+0x5c2>

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

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