// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_evolve_background
int primordial_inflation_evolve_background(
                                           struct primordial * ppm,
                                           struct precision * ppr,
                                           double * y,
                                           double * dy,
                                           enum target_quantity target,
                                           double stop,
                                           short check_epsilon,
                                           enum integration_direction direction,
                                           enum time_definition time
                                           ) {

  struct primordial_inflation_parameters_and_workspace pipaw;
  struct generic_integrator_workspace gi;
  double tau_start,tau_end,dtau=0.;
  double H,dH,ddH,dddH;
  double epsilon,epsilon_old;
  double quantity=0.;
  double V,dV,ddV;
  double sign_dtau=0.;

  pipaw.ppm = ppm;

  pipaw.N = ppm->in_bg_size;

  if ((direction == backward) && ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end))) {
    // -1 to remove the differential equation for phi', since we stick to the attractor
    pipaw.N -= 1;
  }

  pipaw.integrate = direction;
  pipaw.time = time;

  switch (direction) {
  case forward:
    sign_dtau = 1.;
    break;
  case backward:
    sign_dtau = -1.;
    break;
  }

  class_call(initialize_generic_integrator(pipaw.N,&gi),
             gi.error_message,
             ppm->error_message);

  /* at starting point, compute eventually epsilon */

  if (check_epsilon == _TRUE_) {

    class_call(primordial_inflation_get_epsilon(ppm,
                                                y[ppm->index_in_phi],
                                                &epsilon),
               ppm->error_message,
               ppm->error_message);
  }

  /* at starting point, compute the stepsize dtau */

  tau_end = 0;

  class_call(primordial_inflation_derivs(tau_end,
                                         y,
                                         dy,
                                         &pipaw,
                                         ppm->error_message),
             ppm->error_message,
             ppm->error_message);

  // compute timestep (if time = conformal, dtau is the conformal time step,
  // if time = proper, dtau is in fact dt, the proper time step)
  if ((direction == forward) && ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end))) {
    dtau = ppr->primordial_inflation_bg_stepsize
      *MIN(y[ppm->index_in_a]/dy[ppm->index_in_a],fabs(y[ppm->index_in_dphi]/dy[ppm->index_in_dphi]));
  }
  else {
    // minus sign for backward in time
    dtau = sign_dtau * ppr->primordial_inflation_bg_stepsize*y[ppm->index_in_a]/dy[ppm->index_in_a];
  }

  /* expected value of target quantity after the next step */
  switch (target) {
  case _aH_:
    // next (approximate) value of aH after next step
    // (a+[da/dx]*dx) H = aH (1 + [da/dx] / a dx)
    // where dtau can be conformal or proper time
    quantity = dy[ppm->index_in_a] * (1.+ dy[ppm->index_in_a]/y[ppm->index_in_a] * dtau);
    if (time == conformal) quantity /= y[ppm->index_in_a];
    break;
  case _phi_:
    // next (approximate) value of phi after next step
    quantity = y[ppm->index_in_phi]+dy[ppm->index_in_phi]*dtau;
    break;
  case _end_inflation_:
    // in this case, the goal is to reach d2a/dt2 = 0 (end of accelerated expansion)
    stop = 0.;
    // current value of quantity = - d2a/dt2 /a = [- (a'/a)^2 + 3/2 8pi/3 phi'^2]/a^2
    quantity = -pow(dy[ppm->index_in_a]/y[ppm->index_in_a],2) + 4*_PI_ *  y[ppm->index_in_dphi] * y[ppm->index_in_dphi];
    if (time == conformal) quantity /= pow(y[ppm->index_in_a],2);

    // check that we are in the right case
    class_test(ppm->primordial_spec_type != inflation_V_end,
               ppm->error_message,
               "the target _end_inflation_ is only coded to work with inflation_V_end (but could be generalized if needed)");
    break;
  case _a_:
    // next (approximate) value of a after next step
    quantity = y[ppm->index_in_a]+dy[ppm->index_in_a]*dtau;
    break;
  }

  /* loop over time steps, checking that there will be no overshooting */

  while (sign_dtau*(quantity - stop) < 0.) {

    /* check that V(phi) or H(phi) do not take forbidden values
       (negative or positive derivative) */

    if ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end)) {
      class_call(primordial_inflation_check_potential(ppm,
                                                      y[ppm->index_in_phi],
                                                      &V,
                                                      &dV,
                                                      &ddV),
                 ppm->error_message,
                 ppm->error_message);
    }
    else {
      class_call(primordial_inflation_check_hubble(ppm,
                                                   y[ppm->index_in_phi],
                                                   &H,
                                                   &dH,
                                                   &ddH,
                                                   &dddH),
                 ppm->error_message,
                 ppm->error_message);
    }

    /* take one time step */

    tau_start = tau_end;

    tau_end = tau_start + dtau;

    // mind the fabs(...) below (works for both forward and backward integration)
    class_test(fabs(dtau/tau_start) < ppr->smallest_allowed_variation,
               ppm->error_message,
               "integration step: relative change in time =%e < machine precision : leads either to numerical error or infinite loop",dtau/tau_start);

    class_call(generic_integrator(primordial_inflation_derivs,
                                  tau_start,
                                  tau_end,
                                  y,
                                  &pipaw,
                                  ppr->primordial_inflation_tol_integration,
                                  ppr->smallest_allowed_variation,
                                  &gi),
               gi.error_message,
               ppm->error_message);

    /* eventually, check that epsilon is not becoming greater than one */

    if (check_epsilon == _TRUE_) {

      epsilon_old = epsilon;

      class_call_except(primordial_inflation_get_epsilon(ppm,
                                                         y[ppm->index_in_phi],
                                                         &epsilon),
                        ppm->error_message,
                        ppm->error_message,
                        cleanup_generic_integrator(&gi));

      class_test_except((epsilon > 1) && (epsilon_old <= 1),
                        ppm->error_message,
                        cleanup_generic_integrator(&gi),
                        "Inflaton evolution crosses the border from epsilon<1 to epsilon>1 at phi=%g. Inflation disrupted during the observable e-folds",
                        y[ppm->index_in_phi]);
    }

    /* recompute new value of next conformal time step */

    class_call(primordial_inflation_derivs(tau_end,
                                           y,
                                           dy,
                                           &pipaw,
                                           ppm->error_message),
               ppm->error_message,
               ppm->error_message);

    // compute timestep (if time = conformal, dtau is the conformal time step,
    // if time = proper, dtau is in fact dt, the proper time step)
    if ((direction == forward) && ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end))) {
      dtau = ppr->primordial_inflation_bg_stepsize
        *MIN(y[ppm->index_in_a]/dy[ppm->index_in_a],fabs(y[ppm->index_in_dphi]/dy[ppm->index_in_dphi]));
    }
    else {
      // minus sign for backward in time
      dtau = sign_dtau * ppr->primordial_inflation_bg_stepsize*y[ppm->index_in_a]/dy[ppm->index_in_a];
    }

    /* expected value of target quantity after the next step */

    switch (target) {
    case _aH_:
      // next (approximate) value of aH after next step
      // (a+[da/dx]*dx) H = aH (1 + [da/dx] / a dx)
      // where dtau can be conformal or proper time
      quantity = dy[ppm->index_in_a] * (1.+ dy[ppm->index_in_a]/y[ppm->index_in_a] * dtau);
      if (time == conformal) quantity /= y[ppm->index_in_a];
      break;
    case _phi_:
      // next (approximate) value of phi after next step
      quantity = y[ppm->index_in_phi]+dy[ppm->index_in_phi]*dtau;
      break;
    case _end_inflation_:
      // current value of quantity = - d2a/dt2 /a = [- (a'/a)^2 + 3/2 8pi/3 phi'^2]/a^2
      quantity = -pow(dy[ppm->index_in_a]/y[ppm->index_in_a],2) + 4*_PI_ *  y[ppm->index_in_dphi] * y[ppm->index_in_dphi];
      if (time == conformal) quantity /= pow(y[ppm->index_in_a],2);
      break;
    case _a_:
      // next (approximate) value of a after next step
      quantity = y[ppm->index_in_a]+dy[ppm->index_in_a]*dtau;
      break;
    }

  }

  /* won't use the integrator anymore */

  class_call(cleanup_generic_integrator(&gi),
             gi.error_message,
             ppm->error_message);

  /* Perform one last step with a simple trapezoidal integral. This
     will bring exactly phi or a forward to phi_stop or a_stop, or
     approximately aH forward to aH_stop, or approximately [-d2a/dt2
     /a] backward to zero. */

  switch (target) {
  case _aH_:
    switch (time){
    case proper:
      dtau = (stop/dy[ppm->index_in_a]-1.)/dy[ppm->index_in_a];
      break;
    case conformal:
      dtau = (stop/(dy[ppm->index_in_a]/y[ppm->index_in_a])-1.)/(dy[ppm->index_in_a]/y[ppm->index_in_a]);
      break;
    }
    break;
  case _phi_:
    dtau = (stop-y[ppm->index_in_phi])/dy[ppm->index_in_phi];
    break;
  case _end_inflation_:
    class_call(primordial_inflation_check_potential(ppm,y[ppm->index_in_phi],&V,&dV,&ddV),
               ppm->error_message,
               ppm->error_message);
    // We can easily pull back quantity=-d2a/dt2 /a by noticing that
    // d(quantity)/dtau = 8piG phi' phi'' / a^2 (exact relation!)
    // or
    // d(quantity)/dtau = 8piG phi^dot (a phi^dot)^dot = 8piG phi^dot (a^dot phi^dot+ a phi^dotdot)
    // By taking the step dtau = - quantity / [d(quantity)/dtau] we nearly reach quantity=0 (end of inflation), up to very good approximation
    switch (time){
    case proper:
      dtau = -quantity/(8.*_PI_*dy[ppm->index_in_phi]*(dy[ppm->index_in_a]*dy[ppm->index_in_phi]+y[ppm->index_in_a]*dy[ppm->index_in_dphi]));

      break;
    case conformal:
      dtau = -quantity/(8.*_PI_/y[ppm->index_in_a]/y[ppm->index_in_a]*dy[ppm->index_in_phi]*dy[ppm->index_in_dphi]);
      break;
    }
    break;
  case _a_:
    dtau = (stop-y[ppm->index_in_a])/dy[ppm->index_in_a];
    break;
  }

  y[ppm->index_in_a] += dy[ppm->index_in_a]*dtau;
  y[ppm->index_in_phi] += dy[ppm->index_in_phi]*dtau;
  if ((direction == forward) && ((ppm->primordial_spec_type == inflation_V)||(ppm->primordial_spec_type == inflation_V_end)))
    y[ppm->index_in_dphi] += dy[ppm->index_in_dphi]*dtau;

  // this last step updates also the dy[]
  class_call(primordial_inflation_derivs(tau_end,
                                         y,
                                         dy,
                                         &pipaw,
                                         ppm->error_message),
             ppm->error_message,
             ppm->error_message);

  // uncomment if you want to test that the routine really reached the point at which d2a/dt2=0
  /*
    if (target == _end_inflation_) {
    class_call(primordial_inflation_derivs(tau_end,
    y,
    dy,
    &pipaw,
    ppm->error_message),
    ppm->error_message,
    ppm->error_message);

    aH = dy[ppm->index_in_a]/y[ppm->index_in_a];
    quantity = (-aH*aH + 4*_PI_ *  y[ppm->index_in_dphi] * y[ppm->index_in_dphi])/y[ppm->index_in_a]/y[ppm->index_in_a];
    if (ppm->primordial_verbose>1)
    printf(" (-d2a/dt2 /a = %e)\n",quantity);
    }
  */

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1978, %rsp           # imm = 0x1978
movl %r9d, 0x3c(%rsp)
movsd %xmm0, 0x18(%rsp)
movl %r8d, %r13d
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x19b8(%rsp), %ecx
movq %rdi, 0x88(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x2fc(%rdi), %xmm0
movl 0x19b0(%rsp), %ebp
movsd %xmm0, 0x90(%rsp)
xorpd %xmm1, %xmm1
testl %ebp, %ebp
jne 0x9cf96
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9cf77
cmpl $0x2, %eax
jne 0x9cf8e
movsd 0x54869(%rip), %xmm1    # 0xf17e8
addsd %xmm1, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x9cf96
movsd 0x54852(%rip), %xmm1    # 0xf17e8
movl %ebp, 0xf8(%rsp)
movl %ecx, 0xfc(%rsp)
cmpl $0x1, %ebp
je 0x9cfb1
movsd %xmm1, 0x30(%rsp)
jmp 0x9cfbf
movsd 0x542a7(%rip), %xmm0    # 0xf1260
movsd %xmm0, 0x30(%rsp)
cvttsd2si 0x90(%rsp), %edi
leaq 0x908(%rsp), %rsi
callq 0xa15c
cmpl $0x1, %eax
jne 0x9d024
leaq 0x970(%rsp), %rcx
leaq 0x54407(%rip), %rsi     # 0xf13f0
leaq 0x7fc76(%rip), %rdx     # 0x11cc66
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x54024(%rip), %rsi     # 0xf1034
leaq 0x80058(%rip), %rdx     # 0x11d06f
movq %r14, %rdi
movl $0x848, %ecx            # imm = 0x848
jmp 0x9d0eb
cmpw $0x1, 0x3c(%rsp)
jne 0x9d08c
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x9f5a9
testl %eax, %eax
je 0x9d08c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x54398(%rip), %rsi     # 0xf13f0
leaq 0x80037(%rip), %rdx     # 0x11d096
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x53fb9(%rip), %rsi     # 0xf1034
leaq 0x7ffed(%rip), %rdx     # 0x11d06f
movq %r14, %rdi
movl $0x852, %ecx            # imm = 0x852
jmp 0x9d0eb
movl %r13d, 0x24(%rsp)
movl %ebp, %r13d
leaq 0x32a(%r14), %rbp
leaq 0x88(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x9ede1
testl %eax, %eax
je 0x9d10c
leaq 0x54337(%rip), %rsi     # 0xf13f0
leaq 0x7fbec(%rip), %rdx     # 0x11ccac
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x53f58(%rip), %rsi     # 0xf1034
leaq 0x7ff8c(%rip), %rdx     # 0x11d06f
movq %rbp, %rdi
movl $0x85f, %ecx            # imm = 0x85F
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x1978, %rsp           # imm = 0x1978
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, 0x8(%rsp)
cmpl $0x1, %r13d
jne 0x9d16f
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9d125
cmpl $0x2, %eax
jne 0x9d16f
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm4
divsd (%r12,%rax,8), %xmm4
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm0
divsd (%r12,%rax,8), %xmm0
andpd 0x540ed(%rip), %xmm0    # 0xf1240
minsd %xmm0, %xmm4
mulsd 0x6a8(%rbx), %xmm4
movl 0x19b8(%rsp), %r13d
movsd 0x30(%rsp), %xmm3
jmp 0x9d19c
movsd 0x6a8(%rbx), %xmm4
movsd 0x30(%rsp), %xmm3
mulsd %xmm3, %xmm4
movslq 0x2d0(%r14), %rax
mulsd (%r15,%rax,8), %xmm4
divsd (%r12,%rax,8), %xmm4
movl 0x19b8(%rsp), %r13d
xorpd %xmm0, %xmm0
movl 0x24(%rsp), %eax
movl %eax, %ebp
cmpl $0x3, %eax
ja 0x9d2da
leaq 0x7e31a(%rip), %rax     # 0x11b4d0
movslq (%rax,%rbp,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm2
movsd (%r15,%rax,8), %xmm1
movapd %xmm2, %xmm5
divsd %xmm1, %xmm5
mulsd %xmm4, %xmm5
addsd 0x5407a(%rip), %xmm5    # 0xf1260
mulsd %xmm2, %xmm5
testl %r13d, %r13d
jne 0x9d2de
divsd %xmm1, %xmm5
jmp 0x9d2de
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm1
divsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm2
movsd 0x58a50(%rip), %xmm5    # 0xf5c78
mulsd %xmm2, %xmm5
mulsd %xmm2, %xmm5
subsd %xmm1, %xmm5
testl %r13d, %r13d
jne 0x9d24e
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm5
xorpd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
cmpl $0x4, 0x18(%r14)
je 0x9d2de
leaq 0x7fe76(%rip), %rsi     # 0x11d0dc
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x53e03(%rip), %rsi     # 0xf1082
leaq 0x7fec1(%rip), %rdx     # 0x11d147
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x53d92(%rip), %rsi     # 0xf1034
leaq 0x7fdc6(%rip), %rdx     # 0x11d06f
movq 0x8(%rsp), %rdi
movl $0x883, %ecx            # imm = 0x883
jmp 0x9d6d6
movslq 0x2d0(%r14), %rax
jmp 0x9d2c8
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm5
mulsd %xmm4, %xmm5
addsd (%r15,%rax,8), %xmm5
jmp 0x9d2de
xorpd %xmm5, %xmm5
movapd %xmm5, %xmm1
subsd 0x18(%rsp), %xmm1
mulsd %xmm3, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9d5cf
xorpd %xmm3, %xmm3
movsd %xmm5, 0x28(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm3, 0x40(%rsp)
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9d31a
cmpl $0x2, %eax
jne 0x9d347
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x9e23a
testl %eax, %eax
je 0x9d37b
jmp 0x9d766
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movq %r14, %rdi
leaq 0x80(%rsp), %rsi
leaq 0x78(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x68(%rsp), %r8
callq 0x9ce10
testl %eax, %eax
jne 0x9d8fe
movsd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm0
movsd 0x40(%rsp), %xmm4
divsd %xmm4, %xmm0
movapd %xmm0, %xmm1
andpd 0x53ea5(%rip), %xmm1    # 0xf1240
movsd 0xa28(%rbx), %xmm3
ucomisd %xmm1, %xmm3
ja 0x9d682
movapd %xmm2, %xmm1
addsd %xmm4, %xmm1
movsd 0x6b0(%rbx), %xmm2
leaq 0x1a1d(%rip), %rdi      # 0x9ede1
movapd %xmm4, %xmm0
movsd %xmm1, 0x10(%rsp)
movq %r15, %rsi
leaq 0x88(%rsp), %rdx
leaq 0x908(%rsp), %rcx
callq 0xa57b
cmpl $0x1, %eax
je 0x9d6de
cmpw $0x1, 0x3c(%rsp)
jne 0x9d449
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movq %r14, %rdi
leaq 0x48(%rsp), %rsi
callq 0x9f5a9
testl %eax, %eax
jne 0x9d83e
movsd 0x48(%rsp), %xmm0
ucomisd 0x53e2d(%rip), %xmm0    # 0xf1260
jbe 0x9d449
movsd 0x53e23(%rip), %xmm0    # 0xf1260
ucomisd 0x40(%rsp), %xmm0
jae 0x9d881
movq %r15, %rdi
movq %r12, %rsi
leaq 0x88(%rsp), %rdx
callq 0x9ede1
testl %eax, %eax
jne 0x9d723
cmpl $0x1, 0x19b0(%rsp)
jne 0x9d4be
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9d47c
cmpl $0x2, %eax
jne 0x9d4be
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm4
divsd (%r12,%rax,8), %xmm4
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm0
divsd (%r12,%rax,8), %xmm0
andpd 0x53d96(%rip), %xmm0    # 0xf1240
minsd %xmm0, %xmm4
mulsd 0x6a8(%rbx), %xmm4
movsd 0x30(%rsp), %xmm2
jmp 0x9d4e3
movsd 0x6a8(%rbx), %xmm4
movsd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm4
movslq 0x2d0(%r14), %rax
mulsd (%r15,%rax,8), %xmm4
divsd (%r12,%rax,8), %xmm4
movsd 0x28(%rsp), %xmm5
movq %rbp, %rax
movsd 0x10(%rsp), %xmm3
cmpl $0x3, 0x24(%rsp)
ja 0x9d5b3
leaq 0x7dfdc(%rip), %rcx     # 0x11b4e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm1
movsd (%r15,%rax,8), %xmm0
movapd %xmm1, %xmm5
divsd %xmm0, %xmm5
mulsd %xmm4, %xmm5
addsd 0x53d2c(%rip), %xmm5    # 0xf1260
mulsd %xmm1, %xmm5
testl %r13d, %r13d
jne 0x9d5b3
jmp 0x9d58d
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
divsd (%r15,%rax,8), %xmm0
mulsd %xmm0, %xmm0
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm1
movapd %xmm1, %xmm5
mulsd 0x58709(%rip), %xmm5    # 0xf5c78
mulsd %xmm1, %xmm5
subsd %xmm0, %xmm5
testl %r13d, %r13d
jne 0x9d5b3
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm5
jmp 0x9d5b3
movslq 0x2d0(%r14), %rax
jmp 0x9d5a3
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm5
mulsd %xmm4, %xmm5
addsd (%r15,%rax,8), %xmm5
movapd %xmm5, %xmm0
subsd 0x18(%rsp), %xmm0
mulsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x9d2fa
movsd %xmm5, 0x28(%rsp)
movsd %xmm4, 0x10(%rsp)
leaq 0x908(%rsp), %rdi
callq 0xa510
cmpl $0x1, %eax
jne 0x9d632
leaq 0x970(%rsp), %rcx
leaq 0x53df4(%rip), %rsi     # 0xf13f0
leaq 0x545f6(%rip), %rdx     # 0xf1bf9
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x53a18(%rip), %rsi     # 0xf1034
leaq 0x7fa4c(%rip), %rdx     # 0x11d06f
movq 0x8(%rsp), %rdi
movl $0x904, %ecx            # imm = 0x904
jmp 0x9d0eb
cmpl $0x3, 0x24(%rsp)
movq 0x8(%rsp), %r13
movsd 0x10(%rsp), %xmm1
ja 0x9d9d5
leaq 0x7dea1(%rip), %rax     # 0x11b4f0
movslq (%rax,%rbp,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x19b8(%rsp), %eax
testl %eax, %eax
je 0x9d9ac
cmpl $0x1, %eax
jne 0x9d9d5
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
jmp 0x9d9bf
leaq 0x7f66b(%rip), %rsi     # 0x11ccf4
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0x539e0(%rip), %rsi     # 0xf1082
leaq 0x7fb6d(%rip), %rdx     # 0x11d216
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x5396f(%rip), %rsi     # 0xf1034
leaq 0x7f9a3(%rip), %rdx     # 0x11d06f
movq 0x8(%rsp), %rdi
movl $0x8af, %ecx            # imm = 0x8AF
movq %r14, %r8
jmp 0x9d0ee
leaq 0x970(%rsp), %rcx
leaq 0x53d03(%rip), %rsi     # 0xf13f0
leaq 0x7f6a6(%rip), %rdx     # 0x11cd9a
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x53927(%rip), %rsi     # 0xf1034
leaq 0x7f95b(%rip), %rdx     # 0x11d06f
movq 0x8(%rsp), %rdi
movl $0x8ba, %ecx            # imm = 0x8BA
jmp 0x9d0eb
leaq 0x53cc6(%rip), %rsi     # 0xf13f0
leaq 0x7f57b(%rip), %rdx     # 0x11ccac
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x538e2(%rip), %rsi     # 0xf1034
leaq 0x7f916(%rip), %rdx     # 0x11d06f
movq %r14, %rdi
movl $0x8d8, %ecx            # imm = 0x8D8
jmp 0x9d0eb
leaq 0x53c83(%rip), %rsi     # 0xf13f0
leaq 0x7fa00(%rip), %rdx     # 0x11d174
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x5389f(%rip), %rsi     # 0xf1034
leaq 0x7f8d3(%rip), %rdx     # 0x11d06f
movq %r14, %rdi
movl $0x899, %ecx            # imm = 0x899
jmp 0x9d0eb
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
leaq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %r14, %rdi
callq 0x9e23a
testl %eax, %eax
je 0x9d941
leaq 0x53c14(%rip), %rsi     # 0xf13f0
leaq 0x7fb0d(%rip), %rdx     # 0x11d2f0
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x53835(%rip), %rsi     # 0xf1034
leaq 0x7f869(%rip), %rdx     # 0x11d06f
movq %r13, %rdi
movl $0x91c, %ecx            # imm = 0x91C
jmp 0x9d0eb
movslq 0x2d0(%r14), %rax
jmp 0x9d823
movslq 0x2d4(%r14), %rax
movsd 0x18(%rsp), %xmm0
subsd (%r15,%rax,8), %xmm0
divsd (%r12,%rax,8), %xmm0
movapd %xmm0, %xmm1
jmp 0x9d9d5
leaq 0x53bab(%rip), %rsi     # 0xf13f0
leaq 0x7f84a(%rip), %rdx     # 0x11d096
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x537c7(%rip), %rsi     # 0xf1034
leaq 0x7f7fb(%rip), %rdx     # 0x11d06f
movq %r14, %rdi
movl $0x8c7, %ecx            # imm = 0x8C7
movq %rbx, %r8
jmp 0x9d8e5
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
leaq 0x7f9b8(%rip), %rsi     # 0x11d24d
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0x537d4(%rip), %rsi     # 0xf1082
leaq 0x7fa17(%rip), %rdx     # 0x11d2cc
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x53763(%rip), %rsi     # 0xf1034
leaq 0x7f797(%rip), %rdx     # 0x11d06f
movq 0x8(%rsp), %rdi
movl $0x8cd, %ecx            # imm = 0x8CD
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
leaq 0x908(%rsp), %rdi
callq 0xa510
jmp 0x9d0f5
leaq 0x53aeb(%rip), %rsi     # 0xf13f0
leaq 0x7f8b7(%rip), %rdx     # 0x11d1c3
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x53707(%rip), %rsi     # 0xf1034
leaq 0x7f73b(%rip), %rdx     # 0x11d06f
movq %r14, %rdi
movl $0x8a3, %ecx            # imm = 0x8A3
jmp 0x9d0eb
movl 0x19b8(%rsp), %eax
testl %eax, %eax
je 0x9da9c
cmpl $0x1, %eax
movsd 0x10(%rsp), %xmm1
movsd 0x28(%rsp), %xmm3
jne 0x9d9d5
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd 0x7dafa(%rip), %xmm1    # 0x11b470
mulsd %xmm0, %xmm1
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm2
movslq 0x2d8(%r14), %rcx
mulsd (%r12,%rcx,8), %xmm2
mulsd (%r12,%rax,8), %xmm0
addsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm3
movapd %xmm3, %xmm1
jmp 0x9d9d5
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
divsd (%r15,%rax,8), %xmm0
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0x53e17(%rip), %xmm1    # 0xf17e8
divsd %xmm0, %xmm1
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
mulsd %xmm1, %xmm0
addsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
mulsd %xmm1, %xmm0
addsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
cmpl $0x1, 0x19b0(%rsp)
jne 0x9da40
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9da27
cmpl $0x2, %eax
jne 0x9da40
movslq 0x2d8(%r14), %rax
mulsd (%r12,%rax,8), %xmm1
addsd (%r15,%rax,8), %xmm1
movsd %xmm1, (%r15,%rax,8)
leaq 0x88(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x9ede1
testl %eax, %eax
je 0x9da95
leaq 0x53992(%rip), %rsi     # 0xf13f0
leaq 0x7f247(%rip), %rdx     # 0x11ccac
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x535b3(%rip), %rsi     # 0xf1034
leaq 0x7f5e7(%rip), %rdx     # 0x11d06f
movq %r13, %rdi
movl $0x93d, %ecx            # imm = 0x93D
jmp 0x9d0eb
xorl %eax, %eax
jmp 0x9d0fa
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd 0x7d9bf(%rip), %xmm1    # 0x11b470
divsd %xmm0, %xmm1
divsd %xmm0, %xmm1
movslq 0x2d4(%r14), %rax
mulsd (%r12,%rax,8), %xmm1
movslq 0x2d8(%r14), %rax
mulsd (%r12,%rax,8), %xmm1
movsd 0x28(%rsp), %xmm0
divsd %xmm1, %xmm0
jmp 0x9d835