#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double pow(double, double);
double sqrt(double);
double rq_pricing_finite_differences_equity_bermudan(
    short call, double S, double X, double r_dom, double r_for, double sigma,
    double tau_e, double tau_d, double tau_ex_start, double tau_ex_end,
    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;
    if (time >= tau_ex_start && time <= tau_ex_end)
      can_exercise = 1;
    count = 0;
    for (s_i = 0; s_i < s_steps; ++s_i)
      value[s_i] = vold[s_i];
    tmp = vold[0] / b[0];
    if (can_exercise)
      tmp = ((tmp) > (ivalue[0]) ? (tmp) : (ivalue[0]));
    value[0] = tmp;
    s_i = s_steps;
    value[s_i] = (2.0 * value[s_i - 1] - value[s_i - 2]);
    do {
      l2norm = 0.0;
      l2err = 0.0;
      s_i = s_steps;
      tmp = (2 * value[s_i - 1] - value[s_i - 2]);
      tmp = value[s_i] + omega * (tmp - value[s_i]);
      tmp = ((tmp) > (0.0) ? (tmp) : (0.0));
      value[s_i] = tmp;
      for (s_i = 1; s_i < s_steps; ++s_i) {
        tmp = (vold[s_i] - value[s_i - 1] * a[s_i] - value[s_i + 1] * c[s_i]) /
              b[s_i];
        tmp = value[s_i] + omega * (tmp - value[s_i]);
        if (can_exercise)
          tmp = ((tmp) > (ivalue[s_i]) ? (tmp) : (ivalue[s_i]));
        else
          tmp = ((tmp) > (0.0) ? (tmp) : (0.0));
        l2norm += tmp * tmp;
        l2err += (value[s_i] - tmp) * (value[s_i] - tmp);
        value[s_i] = tmp;
      }
      ++count;
      l2err = sqrt(l2err);
      l2norm = sqrt(l2norm);
      if (l2norm < 0.1)
        l2norm = 0.1;
    } while (l2err > eps * l2norm && count < 1000);
    its = count;
    if (l2err > eps * l2norm) {
      *err = -10;
      return 0.0;
    }
    if (oldits < its)
      domega *= -0.9;
    omega += domega;
    oldits = its;
    tvalue[t_i - 1] = value[time_index];
    if (t_i > 1) {
      int j;
      for (j = 0; j < s_steps; ++j)
        vold[j] = value[j];
    }
  }
  result = tvalue[0];
  return result;
}


x86 assembly (clang, -O0):
<rq_pricing_finite_differences_equity_bermudan>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %di,%ax
mov    0x40(%rbp),%rdi
mov    0x38(%rbp),%rdi
mov    0x30(%rbp),%rdi
mov    0x28(%rbp),%rdi
mov    0x20(%rbp),%rdi
mov    0x18(%rbp),%rdi
movsd  0x10(%rbp),%xmm8
mov    %ax,-0xa(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
movsd  %xmm3,-0x30(%rbp)
movsd  %xmm4,-0x38(%rbp)
movsd  %xmm5,-0x40(%rbp)
movsd  %xmm6,-0x48(%rbp)
movsd  %xmm7,-0x50(%rbp)
mov    %esi,-0x54(%rbp)
mov    %edx,-0x58(%rbp)
mov    %rcx,-0x60(%rbp)
mov    %r8,-0x68(%rbp)
mov    %r9,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x80(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xe75(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movq   $0x0,-0x90(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x80(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0xddc(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0xdc4(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0xdac(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0xd94(%rip),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    0x40(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    12db <rq_pricing_finite_differences_equity_bermudan+0x1bb>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
cvtsi2sdl -0xa4(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1288 <rq_pricing_finite_differences_equity_bermudan+0x168>
cmpw   $0x0,-0xa(%rbp)
je     13af <rq_pricing_finite_differences_equity_bermudan+0x28f>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    13aa <rq_pricing_finite_differences_equity_bermudan+0x28a>
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x20(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1331 <rq_pricing_finite_differences_equity_bermudan+0x211>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    134e <rq_pricing_finite_differences_equity_bermudan+0x22e>
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    12f0 <rq_pricing_finite_differences_equity_bermudan+0x1d0>
jmp    1478 <rq_pricing_finite_differences_equity_bermudan+0x358>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1473 <rq_pricing_finite_differences_equity_bermudan+0x353>
movsd  -0x20(%rbp),%xmm1
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    13fa <rq_pricing_finite_differences_equity_bermudan+0x2da>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
jmp    1417 <rq_pricing_finite_differences_equity_bermudan+0x2f7>
movsd  -0x20(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    13b9 <rq_pricing_finite_differences_equity_bermudan+0x299>
jmp    1478 <rq_pricing_finite_differences_equity_bermudan+0x358>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x110(%rbp),%xmm1
ff
call   1030 <pow@plt>
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0xb04(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0xac9(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1722 <rq_pricing_finite_differences_equity_bermudan+0x602>
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x110(%rbp),%xmm1
ff
call   1030 <pow@plt>
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x9e9(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x971(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x92e(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1575 <rq_pricing_finite_differences_equity_bermudan+0x455>
movsd  -0x18(%rbp),%xmm0
mov    -0x60(%rbp),%rax
subsd  (%rax),%xmm0
movaps 0x90a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0xdc(%rbp)
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    17dc <rq_pricing_finite_differences_equity_bermudan+0x6bc>
movsd  -0x18(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xa4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x8bf(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     17c3 <rq_pricing_finite_differences_equity_bermudan+0x6a3>
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0xa4(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    17c8 <rq_pricing_finite_differences_equity_bermudan+0x6a8>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1756 <rq_pricing_finite_differences_equity_bermudan+0x636>
movl   $0x7d0,-0x108(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0xe0(%rbp)
cmpl   $0x0,-0xe0(%rbp)
jle    1ed8 <rq_pricing_finite_differences_equity_bermudan+0xdb8>
movl   $0x0,-0x11c(%rbp)
cvtsi2sdl -0xe0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
ucomisd -0x50(%rbp),%xmm0
jb     1852 <rq_pricing_finite_differences_equity_bermudan+0x732>
movsd  -0x140(%rbp),%xmm1
ff
movsd  0x10(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1852 <rq_pricing_finite_differences_equity_bermudan+0x732>
movl   $0x1,-0x11c(%rbp)
movl   $0x0,-0x120(%rbp)
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    18a9 <rq_pricing_finite_differences_equity_bermudan+0x789>
mov    -0x70(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1866 <rq_pricing_finite_differences_equity_bermudan+0x746>
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
cmpl   $0x0,-0x11c(%rbp)
je     1919 <rq_pricing_finite_differences_equity_bermudan+0x7f9>
movsd  -0x128(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    18f9 <rq_pricing_finite_differences_equity_bermudan+0x7d9>
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1909 <rq_pricing_finite_differences_equity_bermudan+0x7e9>
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x7c(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xe4(%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    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x7c(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xe4(%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,-0x128(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a65 <rq_pricing_finite_differences_equity_bermudan+0x945>
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
jmp    1a75 <rq_pricing_finite_differences_equity_bermudan+0x955>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
jmp    1a75 <rq_pricing_finite_differences_equity_bermudan+0x955>
movsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1cf9 <rq_pricing_finite_differences_equity_bermudan+0xbd9>
mov    -0x70(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
movslq -0xe4(%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    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xe4(%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    0x28(%rbp),%rax
movslq -0xe4(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
cmpl   $0x0,-0x11c(%rbp)
je     1c13 <rq_pricing_finite_differences_equity_bermudan+0xaf3>
movsd  -0x128(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1be6 <rq_pricing_finite_differences_equity_bermudan+0xac6>
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1bfe <rq_pricing_finite_differences_equity_bermudan+0xade>
mov    0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1c5d <rq_pricing_finite_differences_equity_bermudan+0xb3d>
movsd  -0x128(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c3d <rq_pricing_finite_differences_equity_bermudan+0xb1d>
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
jmp    1c4d <rq_pricing_finite_differences_equity_bermudan+0xb2d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
jmp    1c4d <rq_pricing_finite_differences_equity_bermudan+0xb2d>
movsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x128(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x128(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1aa7 <rq_pricing_finite_differences_equity_bermudan+0x987>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
movsd  -0x138(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0x130(%rbp)
ff
movsd  0x2f6(%rip),%xmm0
ucomisd -0x130(%rbp),%xmm0
ff
jbe    1d58 <rq_pricing_finite_differences_equity_bermudan+0xc38>
movsd  0x2e0(%rip),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1d5d <rq_pricing_finite_differences_equity_bermudan+0xc3d>
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0x179(%rbp)
jbe    1d9a <rq_pricing_finite_differences_equity_bermudan+0xc7a>
cmpl   $0x3e8,-0x120(%rbp)
setl   %al
mov    %al,-0x179(%rbp)
mov    -0x179(%rbp),%al
test   $0x1,%al
jne    198b <rq_pricing_finite_differences_equity_bermudan+0x86b>
mov    -0x120(%rbp),%eax
mov    %eax,-0x104(%rbp)
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    1ded <rq_pricing_finite_differences_equity_bermudan+0xccd>
mov    0x40(%rbp),%rax
movl   $0xfffffff6,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1eef <rq_pricing_finite_differences_equity_bermudan+0xdcf>
mov    -0x108(%rbp),%eax
cmp    -0x104(%rbp),%eax
jge    1e17 <rq_pricing_finite_differences_equity_bermudan+0xcf7>
movsd  0x231(%rip),%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x104(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x68(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0xe0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xe0(%rbp)
jle    1ebf <rq_pricing_finite_differences_equity_bermudan+0xd9f>
movl   $0x0,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1eba <rq_pricing_finite_differences_equity_bermudan+0xd9a>
mov    -0x68(%rbp),%rax
movslq -0x144(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x144(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    1e77 <rq_pricing_finite_differences_equity_bermudan+0xd57>
jmp    1ebf <rq_pricing_finite_differences_equity_bermudan+0xd9f>
jmp    1ec4 <rq_pricing_finite_differences_equity_bermudan+0xda4>
mov    -0xe0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe0(%rbp)
jmp    17ef <rq_pricing_finite_differences_equity_bermudan+0x6cf>
mov    0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rq_pricing_finite_differences_equity_bermudan>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,%r14
mov    %r8,%rbx
movq   %xmm7,0xd0(%rsp)
mov    0x140(%rsp),%rax
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
movsd  0x1e9f(%rip),%xmm13
mulsd  %xmm1,%xmm13
lea    -0x1(%rdx),%r15d
cvtsi2sd %r15,%xmm6
divsd  %xmm6,%xmm13
xorps  %xmm6,%xmm6
cvtsi2sd %esi,%xmm6
divsd  %xmm6,%xmm5
movapd %xmm5,0x40(%rsp)
mulsd  %xmm4,%xmm4
movapd %xmm2,%xmm8
subsd  %xmm3,%xmm8
movl   $0x0,(%rax)
mov    %edx,%r12d
mov    %rdx,0x20(%rsp)
test   %edx,%edx
mov    %r12,0x18(%rsp)
jle    17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
cmpl   $0x4,0x20(%rsp)
jae    11bc <rq_pricing_finite_differences_equity_bermudan+0xac>
xor    %edx,%edx
jmp    12e7 <rq_pricing_finite_differences_equity_bermudan+0x1d7>
mov    %r12d,%edx
and    $0xfffffffc,%edx
movapd %xmm13,%xmm3
unpcklpd %xmm13,%xmm3
lea    -0x4(%rdx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     14af <rq_pricing_finite_differences_equity_bermudan+0x39f>
movabs $0x7ffffffffffffffc,%r10
ff ff 7f
or     $0x2,%r10
and    %r9,%r10
movdqa 0x1e53(%rip),%xmm7
xor    %eax,%eax
movdqa 0x1e58(%rip),%xmm9
xorpd  %xmm14,%xmm14
movdqa 0x1e5a(%rip),%xmm10
movdqa 0x1e61(%rip),%xmm11
movdqa 0x1e68(%rip),%xmm12
nopl   0x0(%rax,%rax,1)
movdqa %xmm7,%xmm5
cvtdq2pd %xmm7,%xmm6
paddd  %xmm9,%xmm5
cvtdq2pd %xmm5,%xmm5
mulpd  %xmm3,%xmm6
addpd  %xmm14,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm14,%xmm5
movupd %xmm6,(%rcx,%rax,8)
movupd %xmm5,0x10(%rcx,%rax,8)
movdqa %xmm7,%xmm5
paddd  %xmm10,%xmm5
movdqa %xmm7,%xmm6
cvtdq2pd %xmm5,%xmm5
paddd  %xmm11,%xmm6
cvtdq2pd %xmm6,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm14,%xmm5
mulpd  %xmm3,%xmm6
addpd  %xmm14,%xmm6
movupd %xmm5,0x20(%rcx,%rax,8)
movupd %xmm6,0x30(%rcx,%rax,8)
add    $0x8,%rax
paddd  %xmm12,%xmm7
add    $0xfffffffffffffffe,%r10
jne    1230 <rq_pricing_finite_differences_equity_bermudan+0x120>
test   $0x1,%r9b
je     12da <rq_pricing_finite_differences_equity_bermudan+0x1ca>
cvtdq2pd %xmm7,%xmm5
paddd  0x1da9(%rip),%xmm7
cvtdq2pd %xmm7,%xmm6
mulpd  %xmm3,%xmm5
pxor   %xmm7,%xmm7
addpd  %xmm7,%xmm5
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm5,(%rcx,%rax,8)
movupd %xmm6,0x10(%rcx,%rax,8)
cmp    %r12,%rdx
mov    0x118(%rsp),%r10
je     130e <rq_pricing_finite_differences_equity_bermudan+0x1fe>
xorpd  %xmm3,%xmm3
nopl   0x0(%rax,%rax,1)
xorps  %xmm5,%xmm5
cvtsi2sd %edx,%xmm5
mulsd  %xmm13,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    12f0 <rq_pricing_finite_differences_equity_bermudan+0x1e0>
test   %di,%di
je     132c <rq_pricing_finite_differences_equity_bermudan+0x21c>
cmpl   $0x0,0x20(%rsp)
jle    17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
cmpl   $0x4,0x20(%rsp)
jae    1349 <rq_pricing_finite_differences_equity_bermudan+0x239>
xor    %edx,%edx
jmp    1744 <rq_pricing_finite_differences_equity_bermudan+0x634>
cmpl   $0x0,0x20(%rsp)
jle    17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
cmpl   $0x4,0x20(%rsp)
jae    14c8 <rq_pricing_finite_differences_equity_bermudan+0x3b8>
xor    %edx,%edx
jmp    1678 <rq_pricing_finite_differences_equity_bermudan+0x568>
mov    %r15,0x8(%rsp)
mov    %esi,0x10(%rsp)
lea    (%r14,%r12,8),%rdx
cmp    %rbx,%rdx
seta   0x28(%rsp)
lea    (%rbx,%r12,8),%rdi
cmp    %r14,%rdi
seta   %sil
lea    (%r10,%r12,8),%r13
cmp    %rbx,%r13
mov    %r12,%rax
seta   %r12b
cmp    %r10,%rdi
seta   %r15b
lea    (%rcx,%rax,8),%rax
cmp    %rbx,%rax
seta   %r8b
cmp    %rcx,%rdi
seta   %dil
cmp    %r14,%r13
seta   %r9b
cmp    %r10,%rdx
seta   0x38(%rsp)
cmp    %r14,%rax
mov    %r10,%rbp
seta   %r10b
cmp    %rcx,%rdx
seta   0x30(%rsp)
cmp    %rbp,%rax
seta   %r11b
cmp    %rcx,%r13
seta   %al
xor    %edx,%edx
test   %sil,0x28(%rsp)
jne    1716 <rq_pricing_finite_differences_equity_bermudan+0x606>
and    %r15b,%r12b
jne    1716 <rq_pricing_finite_differences_equity_bermudan+0x606>
and    %dil,%r8b
jne    1716 <rq_pricing_finite_differences_equity_bermudan+0x606>
and    0x38(%rsp),%r9b
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jne    1633 <rq_pricing_finite_differences_equity_bermudan+0x523>
and    0x30(%rsp),%r10b
jne    1633 <rq_pricing_finite_differences_equity_bermudan+0x523>
and    %al,%r11b
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
jne    1744 <rq_pricing_finite_differences_equity_bermudan+0x634>
mov    %r12d,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
lea    0x0(,%r12,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd (%rcx,%rdi,1),%xmm5
movupd 0x10(%rcx,%rdi,1),%xmm6
subpd  %xmm3,%xmm5
subpd  %xmm3,%xmm6
pxor   %xmm7,%xmm7
maxpd  %xmm5,%xmm7
xorpd  %xmm5,%xmm5
maxpd  %xmm6,%xmm5
movupd %xmm7,(%rbx,%rdi,1)
movupd %xmm5,0x10(%rbx,%rdi,1)
movupd %xmm7,(%r14,%rdi,1)
movupd %xmm5,0x10(%r14,%rdi,1)
movupd %xmm7,(%r10,%rdi,1)
movupd %xmm5,0x10(%r10,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rax
jne    1450 <rq_pricing_finite_differences_equity_bermudan+0x340>
cmp    %r12,%rdx
jne    1744 <rq_pricing_finite_differences_equity_bermudan+0x634>
jmp    17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
movdqa 0x1b99(%rip),%xmm7
xor    %eax,%eax
test   $0x1,%r9b
jne    12ab <rq_pricing_finite_differences_equity_bermudan+0x19b>
jmp    12da <rq_pricing_finite_differences_equity_bermudan+0x1ca>
mov    %r15,0x8(%rsp)
mov    %esi,0x10(%rsp)
lea    (%r14,%r12,8),%rdx
cmp    %rbx,%rdx
seta   0x28(%rsp)
lea    (%rbx,%r12,8),%rsi
cmp    %r14,%rsi
seta   %al
lea    (%r10,%r12,8),%r8
cmp    %rbx,%r8
seta   %r15b
cmp    %r10,%rsi
mov    %r12,%rdi
seta   %r12b
lea    (%rcx,%rdi,8),%rdi
cmp    %rbx,%rdi
seta   %r13b
cmp    %rcx,%rsi
seta   0x38(%rsp)
cmp    %r14,%r8
seta   %r9b
cmp    %r10,%rdx
seta   %sil
cmp    %r14,%rdi
mov    %r10,%rbp
seta   %r10b
cmp    %rcx,%rdx
seta   0x30(%rsp)
cmp    %rbp,%rdi
seta   %r11b
cmp    %rcx,%r8
seta   %dil
xor    %edx,%edx
test   %al,0x28(%rsp)
jne    2319 <rq_pricing_finite_differences_equity_bermudan+0x1209>
mov    %esi,%eax
and    %r12b,%r15b
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jne    234c <rq_pricing_finite_differences_equity_bermudan+0x123c>
and    0x38(%rsp),%r13b
mov    0x18(%rsp),%r12
jne    1658 <rq_pricing_finite_differences_equity_bermudan+0x548>
and    %al,%r9b
jne    1658 <rq_pricing_finite_differences_equity_bermudan+0x548>
and    0x30(%rsp),%r10b
jne    1658 <rq_pricing_finite_differences_equity_bermudan+0x548>
and    %dil,%r11b
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
jne    1678 <rq_pricing_finite_differences_equity_bermudan+0x568>
mov    %r12d,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
lea    0x0(,%r12,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd (%rcx,%rdi,1),%xmm5
movupd 0x10(%rcx,%rdi,1),%xmm6
movapd %xmm3,%xmm7
subpd  %xmm5,%xmm7
movapd %xmm3,%xmm5
subpd  %xmm6,%xmm5
xorpd  %xmm6,%xmm6
maxpd  %xmm7,%xmm6
xorpd  %xmm7,%xmm7
maxpd  %xmm5,%xmm7
movupd %xmm6,(%rbx,%rdi,1)
movupd %xmm7,0x10(%rbx,%rdi,1)
movupd %xmm6,(%r14,%rdi,1)
movupd %xmm7,0x10(%r14,%rdi,1)
movupd %xmm6,(%r10,%rdi,1)
movupd %xmm7,0x10(%r10,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rax
jne    15d0 <rq_pricing_finite_differences_equity_bermudan+0x4c0>
cmp    %r12,%rdx
jne    1678 <rq_pricing_finite_differences_equity_bermudan+0x568>
jmp    17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
jmp    1744 <rq_pricing_finite_differences_equity_bermudan+0x634>
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    %rdx,%rax
not    %rax
test   $0x1,%r12b
je     16aa <rq_pricing_finite_differences_equity_bermudan+0x59a>
movapd %xmm1,%xmm3
subsd  (%rcx,%rdx,8),%xmm3
xorpd  %xmm5,%xmm5
maxsd  %xmm3,%xmm5
movsd  %xmm5,(%rbx,%rdx,8)
movsd  %xmm5,(%r14,%rdx,8)
movsd  %xmm5,(%r10,%rdx,8)
or     $0x1,%rdx
add    %r12,%rax
je     17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm1,%xmm3
subsd  (%rcx,%rdx,8),%xmm3
xorpd  %xmm5,%xmm5
maxsd  %xmm3,%xmm5
movsd  %xmm5,(%rbx,%rdx,8)
movsd  %xmm5,(%r14,%rdx,8)
movsd  %xmm5,(%r10,%rdx,8)
movapd %xmm1,%xmm3
subsd  0x8(%rcx,%rdx,8),%xmm3
xorpd  %xmm5,%xmm5
maxsd  %xmm3,%xmm5
movsd  %xmm5,0x8(%rbx,%rdx,8)
movsd  %xmm5,0x8(%r14,%rdx,8)
movsd  %xmm5,0x8(%r10,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r12
jne    16c0 <rq_pricing_finite_differences_equity_bermudan+0x5b0>
jmp    17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
mov    %rdx,%rax
not    %rax
test   $0x1,%r12b
je     1776 <rq_pricing_finite_differences_equity_bermudan+0x666>
movsd  (%rcx,%rdx,8),%xmm3
subsd  %xmm1,%xmm3
xorpd  %xmm5,%xmm5
maxsd  %xmm3,%xmm5
movsd  %xmm5,(%rbx,%rdx,8)
movsd  %xmm5,(%r14,%rdx,8)
movsd  %xmm5,(%r10,%rdx,8)
or     $0x1,%rdx
add    %r12,%rax
je     17d1 <rq_pricing_finite_differences_equity_bermudan+0x6c1>
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm3
subsd  %xmm1,%xmm3
xorpd  %xmm5,%xmm5
maxsd  %xmm3,%xmm5
movsd  %xmm5,(%rbx,%rdx,8)
movsd  %xmm5,(%r14,%rdx,8)
movsd  %xmm5,(%r10,%rdx,8)
movsd  0x8(%rcx,%rdx,8),%xmm3
subsd  %xmm1,%xmm3
xorpd  %xmm5,%xmm5
maxsd  %xmm3,%xmm5
movsd  %xmm5,0x8(%rbx,%rdx,8)
movsd  %xmm5,0x8(%r14,%rdx,8)
movsd  %xmm5,0x8(%r10,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r12
jne    1780 <rq_pricing_finite_differences_equity_bermudan+0x670>
movsd  (%rcx),%xmm1
divsd  %xmm13,%xmm1
movq   $0x0,0x0(%rbp)
movapd %xmm4,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm8,%xmm1
addsd  %xmm3,%xmm1
addsd  %xmm2,%xmm3
movapd 0x40(%rsp),%xmm5
mulsd  %xmm5,%xmm3
addsd  0x17fb(%rip),%xmm3
movsd  %xmm3,(%r11)
mulsd  %xmm5,%xmm1
mulsd  0x17f2(%rip),%xmm1
movsd  %xmm1,(%r8)
cmpl   $0x2,0x20(%rsp)
jl     1919 <rq_pricing_finite_differences_equity_bermudan+0x809>
lea    -0x1(%r12),%r9
mov    $0x1,%edi
cmp    $0x2,%r9
jae    1921 <rq_pricing_finite_differences_equity_bermudan+0x811>
movapd 0x40(%rsp),%xmm1
movapd 0x184f(%rip),%xmm10
movsd  0x17bf(%rip),%xmm3
movsd  0x17a6(%rip),%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rdi,8),%xmm6
divsd  %xmm13,%xmm6
movapd %xmm4,%xmm7
mulsd  %xmm6,%xmm7
movapd %xmm8,%xmm5
mulsd  %xmm6,%xmm5
mulsd  %xmm6,%xmm7
movapd %xmm7,%xmm6
subsd  %xmm5,%xmm6
xorpd  %xmm10,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm3,%xmm6
movsd  %xmm6,0x0(%rbp,%rdi,8)
movapd %xmm7,%xmm6
addsd  %xmm2,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm9,%xmm6
movsd  %xmm6,(%r11,%rdi,8)
addsd  %xmm5,%xmm7
xorpd  %xmm10,%xmm7
mulsd  %xmm1,%xmm7
mulsd  %xmm3,%xmm7
movsd  %xmm7,(%r8,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r12
jne    1870 <rq_pricing_finite_differences_equity_bermudan+0x760>
xor    %r13d,%r13d
cmpl   $0x2,0x20(%rsp)
jl     1bc5 <rq_pricing_finite_differences_equity_bermudan+0xab5>
movapd %xmm0,%xmm1
subsd  (%rcx),%xmm1
andpd  0x17d1(%rip),%xmm1
jne    1b0b <rq_pricing_finite_differences_equity_bermudan+0x9fb>
mov    $0x1,%edi
test   $0x1,%r9b
jne    1baa <rq_pricing_finite_differences_equity_bermudan+0xa9a>
jmp    1bc2 <rq_pricing_finite_differences_equity_bermudan+0xab2>
xor    %r13d,%r13d
jmp    1bc5 <rq_pricing_finite_differences_equity_bermudan+0xab5>
mov    %r9,0x28(%rsp)
mov    %r15,0x8(%rsp)
mov    %esi,0x10(%rsp)
lea    0x8(%rbp),%rdx
lea    0x0(,%r12,8),%rsi
add    %rbp,%rsi
lea    0x8(%r11),%rax
lea    (%r11,%r12,8),%r15
mov    %r12,%rbp
lea    0x8(%r8),%r12
lea    (%r8,%rbp,8),%r8
lea    0x8(%rcx),%r9
lea    (%rcx,%rbp,8),%r11
cmp    %r15,%rdx
setb   %bpl
cmp    %rsi,%rax
setb   0x38(%rsp)
cmp    %r8,%rdx
setb   %r13b
cmp    %rsi,%r12
setb   0x30(%rsp)
cmp    %r11,%rdx
setb   %dl
cmp    %rsi,%r9
setb   %sil
cmp    %r8,%rax
setb   %r10b
cmp    %r15,%r12
setb   0x70(%rsp)
cmp    %r11,%rax
setb   %al
cmp    %r15,%r9
setb   0x60(%rsp)
cmp    %r11,%r12
setb   %r15b
cmp    %r8,%r9
setb   %r12b
test   %bpl,0x38(%rsp)
jne    22db <rq_pricing_finite_differences_equity_bermudan+0x11cb>
and    0x30(%rsp),%r13b
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x28(%rsp),%r9
jne    22ba <rq_pricing_finite_differences_equity_bermudan+0x11aa>
and    %sil,%dl
jne    22ba <rq_pricing_finite_differences_equity_bermudan+0x11aa>
and    0x70(%rsp),%r10b
jne    22ba <rq_pricing_finite_differences_equity_bermudan+0x11aa>
and    0x60(%rsp),%al
mov    0x118(%rsp),%r10
jne    22b2 <rq_pricing_finite_differences_equity_bermudan+0x11a2>
and    %r12b,%r15b
movapd 0x40(%rsp),%xmm1
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jne    1848 <rq_pricing_finite_differences_equity_bermudan+0x738>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
mov    %r9,%rdi
or     $0x1,%rdi
movapd %xmm13,%xmm9
unpcklpd %xmm13,%xmm9
movapd %xmm4,%xmm10
unpcklpd %xmm4,%xmm10
movapd %xmm8,%xmm12
unpcklpd %xmm8,%xmm12
movapd %xmm1,%xmm7
unpcklpd %xmm1,%xmm7
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
xor    %edx,%edx
movapd 0x1634(%rip),%xmm14
movapd 0x163b(%rip),%xmm15
movapd 0x1642(%rip),%xmm11
xchg   %ax,%ax
movupd 0x8(%rcx,%rdx,8),%xmm6
divpd  %xmm9,%xmm6
movapd %xmm10,%xmm1
mulpd  %xmm6,%xmm1
movapd %xmm12,%xmm3
mulpd  %xmm6,%xmm3
mulpd  %xmm6,%xmm1
movapd %xmm1,%xmm6
subpd  %xmm3,%xmm6
xorpd  %xmm14,%xmm6
mulpd  %xmm7,%xmm6
mulpd  %xmm15,%xmm6
movupd %xmm6,0x8(%rbp,%rdx,8)
movapd %xmm1,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm7,%xmm6
addpd  %xmm11,%xmm6
movupd %xmm6,0x8(%r11,%rdx,8)
addpd  %xmm3,%xmm1
xorpd  %xmm14,%xmm1
mulpd  %xmm7,%xmm1
mulpd  %xmm15,%xmm1
movupd %xmm1,0x8(%r8,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1a80 <rq_pricing_finite_differences_equity_bermudan+0x970>
cmp    %rax,%r9
movapd 0x40(%rsp),%xmm1
jne    1848 <rq_pricing_finite_differences_equity_bermudan+0x738>
jmp    18e1 <rq_pricing_finite_differences_equity_bermudan+0x7d1>
mov    %r9,0x28(%rsp)
and    $0xfffffffffffffffe,%r9
xor    %r13d,%r13d
mov    $0x1,%edi
movapd 0x15ac(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm0,%xmm3
subsd  (%rcx,%rdi,8),%xmm3
andpd  %xmm2,%xmm3
ucomisd %xmm3,%xmm1
movapd %xmm3,%xmm4
cmpnlesd %xmm1,%xmm4
movapd %xmm4,%xmm5
andnpd %xmm3,%xmm5
andpd  %xmm1,%xmm4
orpd   %xmm5,%xmm4
mov    %edi,%edx
cmovb  %r13d,%edx
movapd %xmm0,%xmm3
subsd  0x8(%rcx,%rdi,8),%xmm3
andpd  %xmm2,%xmm3
lea    0x1(%rdi),%rax
ucomisd %xmm3,%xmm4
movapd %xmm3,%xmm1
cmpnlesd %xmm4,%xmm1
movapd %xmm1,%xmm5
andpd  %xmm4,%xmm5
andnpd %xmm3,%xmm1
orpd   %xmm5,%xmm1
mov    %eax,%r13d
cmovb  %edx,%r13d
add    $0x2,%rdi
cmp    %r9,%rax
jne    1b30 <rq_pricing_finite_differences_equity_bermudan+0xa20>
mov    0x28(%rsp),%r9
test   $0x1,%r9b
je     1bc2 <rq_pricing_finite_differences_equity_bermudan+0xab2>
subsd  (%rcx,%rdi,8),%xmm0
andpd  0x1519(%rip),%xmm0
ucomisd %xmm0,%xmm1
cmovb  %r13d,%edi
mov    %edi,%r13d
movslq %r13d,%r13
movapd 0x40(%rsp),%xmm1
test   %esi,%esi
jle    2280 <rq_pricing_finite_differences_equity_bermudan+0x1170>
movslq %r15d,%rax
mov    %rax,0x28(%rsp)
mov    0x20(%rsp),%rcx
lea    -0x2(%rcx),%eax
cltq
mov    %rax,0x38(%rsp)
movslq %ecx,%rdi
lea    (%r14,%r12,8),%rax
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xb0(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xa8(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %rbx,%rax
seta   %al
lea    (%rbx,%r12,8),%rcx
cmp    %r14,%rcx
seta   %cl
mov    %esi,%esi
and    %al,%cl
mov    %cl,0x7(%rsp)
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rdx,%rax
mov    %rdx,0xb8(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x88(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %rax,0x58(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0x98(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x90(%rsp)
mov    %rcx,0xc0(%rsp)
shl    $0x5,%rcx
mov    %rcx,0xa0(%rsp)
lea    -0x8(,%r12,8),%r15
ff
movsd  0x138f(%rip),%xmm6
movsd  0x138f(%rip),%xmm2
xorpd  %xmm7,%xmm7
mov    $0x7d0,%eax
mov    %rdi,0x30(%rsp)
mov    %r13,0xc8(%rsp)
jmp    1cd2 <rq_pricing_finite_differences_equity_bermudan+0xbc2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  %xmm2,%xmm6
lea    -0x1(%r9),%rsi
cmp    $0x1,%r9
jle    2280 <rq_pricing_finite_differences_equity_bermudan+0x1170>
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd  %xmm1,%xmm0
ucomisd 0xd0(%rsp),%xmm0
setb   %cl
movsd  0x110(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    %eax,0x6c(%rsp)
setb   %r13b
or     %cl,%r13b
cmpl   $0x0,0x20(%rsp)
mov    0x58(%rsp),%rdx
jle    1e9b <rq_pricing_finite_differences_equity_bermudan+0xd8b>
cmpl   $0x4,0x20(%rsp)
setb   %al
or     0x7(%rsp),%al
je     1d30 <rq_pricing_finite_differences_equity_bermudan+0xc20>
xor    %eax,%eax
jmp    1e24 <rq_pricing_finite_differences_equity_bermudan+0xd14>
cs nopw 0x0(%rax,%rax,1)
cmpq   $0xc,0xa8(%rsp)
jae    1d3f <rq_pricing_finite_differences_equity_bermudan+0xc2f>
xor    %eax,%eax
jmp    1db4 <rq_pricing_finite_differences_equity_bermudan+0xca4>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups 0x20(%r14,%rax,8),%xmm0
movups 0x30(%r14,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rax,8)
movups %xmm1,0x30(%rbx,%rax,8)
movups 0x40(%r14,%rax,8),%xmm0
movups 0x50(%r14,%rax,8),%xmm1
movups %xmm0,0x40(%rbx,%rax,8)
movups %xmm1,0x50(%rbx,%rax,8)
movupd 0x60(%r14,%rax,8),%xmm0
movupd 0x70(%r14,%rax,8),%xmm1
movupd %xmm0,0x60(%rbx,%rax,8)
movupd %xmm1,0x70(%rbx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1d50 <rq_pricing_finite_differences_equity_bermudan+0xc40>
cmpq   $0x0,0xc0(%rsp)
mov    0xa0(%rsp),%r9
je     1e0f <rq_pricing_finite_differences_equity_bermudan+0xcff>
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x90(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   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    1df0 <rq_pricing_finite_differences_equity_bermudan+0xce0>
mov    0xb0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
mov    0x58(%rsp),%rdx
je     1e9b <rq_pricing_finite_differences_equity_bermudan+0xd8b>
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %rdx,%rdx
je     1e55 <rq_pricing_finite_differences_equity_bermudan+0xd45>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1e40 <rq_pricing_finite_differences_equity_bermudan+0xd30>
cmp    $0x3,%rcx
jb     1e9b <rq_pricing_finite_differences_equity_bermudan+0xd8b>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1e60 <rq_pricing_finite_differences_equity_bermudan+0xd50>
movsd  (%r14),%xmm0
divsd  (%r11),%xmm0
test   %r13b,%r13b
movsd  %xmm2,0x60(%rsp)
jne    1eb5 <rq_pricing_finite_differences_equity_bermudan+0xda5>
maxsd  (%r10),%xmm0
movsd  %xmm0,(%rbx)
mov    0x28(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
mov    0x38(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm2
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
xor    %r12d,%r12d
mov    %rsi,0x10(%rsp)
movsd  %xmm6,0x8(%rsp)
nopl   0x0(%rax)
addsd  %xmm0,%xmm0
subsd  %xmm2,%xmm0
subsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
maxsd  %xmm7,%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
xorpd  %xmm5,%xmm5
cmpl   $0x2,0x20(%rsp)
jl     1fb4 <rq_pricing_finite_differences_equity_bermudan+0xea4>
movsd  (%rbx),%xmm3
movsd  0x8(%rbx),%xmm0
xorpd  %xmm4,%xmm4
xor    %eax,%eax
jmp    1f98 <rq_pricing_finite_differences_equity_bermudan+0xe88>
nopl   (%rax)
mulsd  0x8(%rbp,%rax,1),%xmm3
movsd  0x8(%r14,%rax,1),%xmm5
subsd  %xmm3,%xmm5
movsd  0x10(%rbx,%rax,1),%xmm2
movsd  0x8(%r8,%rax,1),%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm5
divsd  0x8(%r11,%rax,1),%xmm5
subsd  %xmm0,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm0,%xmm5
maxsd  %xmm4,%xmm5
subsd  %xmm5,%xmm0
movsd  %xmm5,0x8(%rbx,%rax,1)
movapd %xmm5,%xmm3
unpcklpd %xmm0,%xmm5
mulpd  %xmm5,%xmm5
movapd %xmm5,%xmm4
addpd  %xmm1,%xmm4
add    $0x8,%rax
movapd %xmm2,%xmm0
cmp    %rax,%r15
je     1fb0 <rq_pricing_finite_differences_equity_bermudan+0xea0>
movapd %xmm4,%xmm1
xorpd  %xmm4,%xmm4
test   %r13b,%r13b
jne    1f30 <rq_pricing_finite_differences_equity_bermudan+0xe20>
movsd  0x8(%r10,%rax,1),%xmm4
jmp    1f30 <rq_pricing_finite_differences_equity_bermudan+0xe20>
xchg   %ax,%ax
addpd  %xmm1,%xmm5
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
ucomisd %xmm7,%xmm0
jb     1ff0 <rq_pricing_finite_differences_equity_bermudan+0xee0>
xorps  %xmm2,%xmm2
sqrtsd %xmm0,%xmm2
ucomisd %xmm7,%xmm5
jae    200f <rq_pricing_finite_differences_equity_bermudan+0xeff>
movapd %xmm5,%xmm0
movsd  %xmm2,0x70(%rsp)
call   1030 <sqrt@plt>
movsd  0x70(%rsp),%xmm2
xorpd  %xmm7,%xmm7
jmp    2016 <rq_pricing_finite_differences_equity_bermudan+0xf06>
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     1fcf <rq_pricing_finite_differences_equity_bermudan+0xebf>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    0x30(%rsp),%rdi
mov    0x10(%rsp),%r9
movsd  0x8(%rsp),%xmm6
movsd  0xfe2(%rip),%xmm1
maxsd  %xmm0,%xmm1
lea    0x1(%r12),%eax
mulsd  0xfd9(%rip),%xmm1
ucomisd %xmm1,%xmm2
jbe    2090 <rq_pricing_finite_differences_equity_bermudan+0xf80>
cmp    $0x3e6,%r12d
ja     2090 <rq_pricing_finite_differences_equity_bermudan+0xf80>
mov    0x28(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
mov    0x38(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm2
movsd  (%rbx,%rdi,8),%xmm1
mov    %eax,%r12d
jmp    1ef0 <rq_pricing_finite_differences_equity_bermudan+0xde0>
nop
ucomisd %xmm1,%xmm2
ja     228e <rq_pricing_finite_differences_equity_bermudan+0x117e>
movsd  0x60(%rsp),%xmm2
movapd %xmm2,%xmm0
mulsd  0xf94(%rip),%xmm0
cmp    %r12d,0x6c(%rsp)
ja     20b7 <rq_pricing_finite_differences_equity_bermudan+0xfa7>
movapd %xmm0,%xmm2
mov    0xc8(%rsp),%r13
movsd  (%rbx,%r13,8),%xmm0
lea    -0x1(%r9),%ecx
mov    0x138(%rsp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
cmp    $0x2,%r9
movapd 0x40(%rsp),%xmm1
mov    0x18(%rsp),%r12
jl     2280 <rq_pricing_finite_differences_equity_bermudan+0x1170>
cmpl   $0x0,0x20(%rsp)
jle    1cc0 <rq_pricing_finite_differences_equity_bermudan+0xbb0>
cmpl   $0x4,0x20(%rsp)
setb   %cl
or     0x7(%rsp),%cl
je     2110 <rq_pricing_finite_differences_equity_bermudan+0x1000>
xor    %ecx,%ecx
jmp    21fe <rq_pricing_finite_differences_equity_bermudan+0x10ee>
nopl   0x0(%rax,%rax,1)
cmpq   $0xc,0xa8(%rsp)
jae    211f <rq_pricing_finite_differences_equity_bermudan+0x100f>
xor    %ecx,%ecx
jmp    2194 <rq_pricing_finite_differences_equity_bermudan+0x1084>
mov    0x88(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%rbx,%rcx,8),%xmm0
movups 0x10(%rbx,%rcx,8),%xmm1
movups %xmm0,(%r14,%rcx,8)
movups %xmm1,0x10(%r14,%rcx,8)
movups 0x20(%rbx,%rcx,8),%xmm0
movups 0x30(%rbx,%rcx,8),%xmm1
movups %xmm0,0x20(%r14,%rcx,8)
movups %xmm1,0x30(%r14,%rcx,8)
movups 0x40(%rbx,%rcx,8),%xmm0
movups 0x50(%rbx,%rcx,8),%xmm1
movups %xmm0,0x40(%r14,%rcx,8)
movups %xmm1,0x50(%r14,%rcx,8)
movupd 0x60(%rbx,%rcx,8),%xmm0
movupd 0x70(%rbx,%rcx,8),%xmm1
movupd %xmm0,0x60(%r14,%rcx,8)
movupd %xmm1,0x70(%r14,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2130 <rq_pricing_finite_differences_equity_bermudan+0x1020>
testb  $0x3,0xb8(%rsp)
03
mov    0xa0(%rsp),%r12
je     21df <rq_pricing_finite_differences_equity_bermudan+0x10cf>
mov    0x90(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0x98(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
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,%r12
jne    21c0 <rq_pricing_finite_differences_equity_bermudan+0x10b0>
mov    0xb0(%rsp),%rdx
mov    %rdx,%rcx
mov    0x18(%rsp),%r12
cmp    %r12,%rdx
movapd 0x40(%rsp),%xmm1
je     1cc0 <rq_pricing_finite_differences_equity_bermudan+0xbb0>
mov    %rcx,%rdx
not    %rdx
add    %r12,%rdx
test   $0x3,%r12b
je     2235 <rq_pricing_finite_differences_equity_bermudan+0x1125>
mov    0x58(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2220 <rq_pricing_finite_differences_equity_bermudan+0x1110>
cmp    $0x3,%rdx
jb     1cc0 <rq_pricing_finite_differences_equity_bermudan+0xbb0>
nop
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r12
jne    2240 <rq_pricing_finite_differences_equity_bermudan+0x1130>
jmp    1cc0 <rq_pricing_finite_differences_equity_bermudan+0xbb0>
mov    0x138(%rsp),%rax
movsd  (%rax),%xmm0
jmp    22a0 <rq_pricing_finite_differences_equity_bermudan+0x1190>
mov    0x140(%rsp),%rax
movl   $0xfffffff6,(%rax)
xorpd  %xmm0,%xmm0
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movapd 0x40(%rsp),%xmm1
jmp    22c8 <rq_pricing_finite_differences_equity_bermudan+0x11b8>
movapd 0x40(%rsp),%xmm1
mov    0x118(%rsp),%r10
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jmp    1848 <rq_pricing_finite_differences_equity_bermudan+0x738>
movapd 0x40(%rsp),%xmm1
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
mov    0x28(%rsp),%r9
jmp    1848 <rq_pricing_finite_differences_equity_bermudan+0x738>
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%esi
mov    0x8(%rsp),%r15
jmp    1678 <rq_pricing_finite_differences_equity_bermudan+0x568>
mov    0x130(%rsp),%r8
mov    0x128(%rsp),%r11
mov    0x120(%rsp),%rbp
mov    0x118(%rsp),%r10
mov    0x18(%rsp),%r12
jmp    1678 <rq_pricing_finite_differences_equity_bermudan+0x568>

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

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