// File: /workspace/github_c_makefile_star2_O3/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 0x9a1b0
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9a191
cmpl $0x2, %eax
jne 0x9a1a8
movsd 0x5464f(%rip), %xmm1    # 0xee7e8
addsd %xmm1, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x9a1b0
movsd 0x54638(%rip), %xmm1    # 0xee7e8
movl %ebp, 0xf8(%rsp)
movl %ecx, 0xfc(%rsp)
cmpl $0x1, %ebp
jne 0x9a1cb
movsd 0x54095(%rip), %xmm1    # 0xee260
movsd %xmm1, 0x30(%rsp)
cvttsd2si %xmm0, %edi
leaq 0x908(%rsp), %rsi
callq 0xa140
cmpl $0x1, %eax
jne 0x9a231
leaq 0x970(%rsp), %rcx
leaq 0x541fa(%rip), %rsi     # 0xee3f0
leaq 0x7faa9(%rip), %rdx     # 0x119ca6
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x53e17(%rip), %rsi     # 0xee034
leaq 0x7fe8b(%rip), %rdx     # 0x11a0af
movq %r14, %rdi
movl $0x848, %ecx            # imm = 0x848
jmp 0x9a2f8
cmpw $0x1, 0x3c(%rsp)
jne 0x9a299
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x9c685
testl %eax, %eax
je 0x9a299
addq $0x32a, %r14            # imm = 0x32A
leaq 0x5418b(%rip), %rsi     # 0xee3f0
leaq 0x7fe6a(%rip), %rdx     # 0x11a0d6
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x53dac(%rip), %rsi     # 0xee034
leaq 0x7fe20(%rip), %rdx     # 0x11a0af
movq %r14, %rdi
movl $0x852, %ecx            # imm = 0x852
jmp 0x9a2f8
movl %r13d, 0x24(%rsp)
movl %ebp, %r13d
leaq 0x32a(%r14), %rbp
leaq 0x88(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x9beb7
testl %eax, %eax
je 0x9a319
leaq 0x5412a(%rip), %rsi     # 0xee3f0
leaq 0x7fa1f(%rip), %rdx     # 0x119cec
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x53d4b(%rip), %rsi     # 0xee034
leaq 0x7fdbf(%rip), %rdx     # 0x11a0af
movq %rbp, %rdi
movl $0x85f, %ecx            # imm = 0x85F
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
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 0x9a384
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9a332
cmpl $0x2, %eax
jne 0x9a384
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm1
movsd (%r12,%rax,8), %xmm2
movapd %xmm1, %xmm5
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm0
divsd (%r12,%rax,8), %xmm0
andpd 0x53edc(%rip), %xmm0    # 0xee240
divsd %xmm2, %xmm5
minsd %xmm0, %xmm5
mulsd 0x6a8(%rbx), %xmm5
movl 0x19b8(%rsp), %r13d
movsd 0x30(%rsp), %xmm4
jmp 0x9a3b9
movsd 0x6a8(%rbx), %xmm5
movsd 0x30(%rsp), %xmm4
mulsd %xmm4, %xmm5
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm5
movsd (%r12,%rax,8), %xmm2
divsd %xmm2, %xmm5
movl 0x19b8(%rsp), %r13d
xorpd %xmm0, %xmm0
movl 0x24(%rsp), %eax
movl %eax, %ebp
cmpl $0x3, %eax
ja 0x9a4d1
leaq 0x7e13d(%rip), %rax     # 0x118510
movslq (%rax,%rbp,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movapd %xmm2, %xmm6
divsd %xmm1, %xmm6
mulsd %xmm5, %xmm6
addsd 0x53e70(%rip), %xmm6    # 0xee260
mulsd %xmm2, %xmm6
testl %r13d, %r13d
jne 0x9a4d5
divsd %xmm1, %xmm6
jmp 0x9a4d5
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm3
movsd 0x5887d(%rip), %xmm6    # 0xf2ca0
mulsd %xmm3, %xmm6
mulsd %xmm3, %xmm6
subsd %xmm2, %xmm6
testl %r13d, %r13d
jne 0x9a43c
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm6
xorpd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
cmpl $0x4, 0x18(%r14)
je 0x9a4d5
leaq 0x7fcc4(%rip), %rsi     # 0x11a11c
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x53c11(%rip), %rsi     # 0xee082
leaq 0x7fd0f(%rip), %rdx     # 0x11a187
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x53ba0(%rip), %rsi     # 0xee034
leaq 0x7fc14(%rip), %rdx     # 0x11a0af
movq 0x8(%rsp), %rdi
movl $0x883, %ecx            # imm = 0x883
jmp 0x9a8b3
mulsd %xmm5, %xmm2
addsd %xmm1, %xmm2
movapd %xmm2, %xmm6
jmp 0x9a4d5
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm6
mulsd %xmm5, %xmm6
addsd (%r15,%rax,8), %xmm6
jmp 0x9a4d5
xorpd %xmm6, %xmm6
movapd %xmm6, %xmm1
subsd 0x18(%rsp), %xmm1
mulsd %xmm4, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9a7ac
xorpd %xmm4, %xmm4
movsd %xmm6, 0x28(%rsp)
movsd %xmm5, 0x10(%rsp)
movsd %xmm4, 0x40(%rsp)
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9a511
cmpl $0x2, %eax
jne 0x9a53e
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 0x9b3e7
testl %eax, %eax
je 0x9a572
jmp 0x9a943
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 0x9a02a
testl %eax, %eax
jne 0x9aadb
movsd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm0
movsd 0x40(%rsp), %xmm4
divsd %xmm4, %xmm0
movapd %xmm0, %xmm1
andpd 0x53cae(%rip), %xmm1    # 0xee240
movsd 0xa28(%rbx), %xmm3
ucomisd %xmm1, %xmm3
ja 0x9a85f
movapd %xmm2, %xmm1
addsd %xmm4, %xmm1
movsd 0x6b0(%rbx), %xmm2
leaq 0x18fc(%rip), %rdi      # 0x9beb7
movapd %xmm4, %xmm0
movsd %xmm1, 0x10(%rsp)
movq %r15, %rsi
leaq 0x88(%rsp), %rdx
leaq 0x908(%rsp), %rcx
callq 0xa55f
cmpl $0x1, %eax
je 0x9a8bb
cmpw $0x1, 0x3c(%rsp)
jne 0x9a640
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 0x9c685
testl %eax, %eax
jne 0x9aa1b
movsd 0x48(%rsp), %xmm0
ucomisd 0x53c36(%rip), %xmm0    # 0xee260
jbe 0x9a640
movsd 0x53c2c(%rip), %xmm0    # 0xee260
ucomisd 0x40(%rsp), %xmm0
jae 0x9aa5e
movq %r15, %rdi
movq %r12, %rsi
leaq 0x88(%rsp), %rdx
callq 0x9beb7
testl %eax, %eax
jne 0x9a900
cmpl $0x1, 0x19b0(%rsp)
jne 0x9a6bd
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9a673
cmpl $0x2, %eax
jne 0x9a6bd
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd (%r12,%rax,8), %xmm1
movapd %xmm0, %xmm5
divsd %xmm1, %xmm5
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm2
divsd (%r12,%rax,8), %xmm2
andpd 0x53b97(%rip), %xmm2    # 0xee240
minsd %xmm2, %xmm5
mulsd 0x6a8(%rbx), %xmm5
movsd 0x30(%rsp), %xmm3
jmp 0x9a6ea
movsd 0x6a8(%rbx), %xmm5
movsd 0x30(%rsp), %xmm3
mulsd %xmm3, %xmm5
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
mulsd %xmm0, %xmm5
movsd (%r12,%rax,8), %xmm1
divsd %xmm1, %xmm5
movsd 0x28(%rsp), %xmm6
movq %rbp, %rax
movsd 0x10(%rsp), %xmm4
cmpl $0x3, 0x24(%rsp)
ja 0x9a790
leaq 0x7de15(%rip), %rcx     # 0x118520
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movapd %xmm1, %xmm6
divsd %xmm0, %xmm6
mulsd %xmm5, %xmm6
addsd 0x53b38(%rip), %xmm6    # 0xee260
mulsd %xmm1, %xmm6
testl %r13d, %r13d
jne 0x9a790
jmp 0x9a765
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm2
movapd %xmm2, %xmm6
mulsd 0x5854c(%rip), %xmm6    # 0xf2ca0
mulsd %xmm2, %xmm6
subsd %xmm1, %xmm6
testl %r13d, %r13d
jne 0x9a790
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm6
jmp 0x9a790
mulsd %xmm5, %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm6
jmp 0x9a790
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm6
mulsd %xmm5, %xmm6
addsd (%r15,%rax,8), %xmm6
movapd %xmm6, %xmm0
subsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x9a4f1
movsd %xmm6, 0x28(%rsp)
movsd %xmm5, 0x10(%rsp)
leaq 0x908(%rsp), %rdi
callq 0xa4f4
cmpl $0x1, %eax
jne 0x9a80f
leaq 0x970(%rsp), %rcx
leaq 0x53c17(%rip), %rsi     # 0xee3f0
leaq 0x54419(%rip), %rdx     # 0xeebf9
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x5383b(%rip), %rsi     # 0xee034
leaq 0x7f8af(%rip), %rdx     # 0x11a0af
movq 0x8(%rsp), %rdi
movl $0x904, %ecx            # imm = 0x904
jmp 0x9a2f8
cmpl $0x3, 0x24(%rsp)
movq 0x8(%rsp), %r13
movsd 0x10(%rsp), %xmm1
ja 0x9abb2
leaq 0x7dd04(%rip), %rax     # 0x118530
movslq (%rax,%rbp,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x19b8(%rsp), %eax
testl %eax, %eax
je 0x9ab89
cmpl $0x1, %eax
jne 0x9abb2
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
jmp 0x9ab9c
leaq 0x7f4ce(%rip), %rsi     # 0x119d34
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x53803(%rip), %rsi     # 0xee082
leaq 0x7f9d0(%rip), %rdx     # 0x11a256
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x53792(%rip), %rsi     # 0xee034
leaq 0x7f806(%rip), %rdx     # 0x11a0af
movq 0x8(%rsp), %rdi
movl $0x8af, %ecx            # imm = 0x8AF
movq %r14, %r8
jmp 0x9a2fb
leaq 0x970(%rsp), %rcx
leaq 0x53b26(%rip), %rsi     # 0xee3f0
leaq 0x7f509(%rip), %rdx     # 0x119dda
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x5374a(%rip), %rsi     # 0xee034
leaq 0x7f7be(%rip), %rdx     # 0x11a0af
movq 0x8(%rsp), %rdi
movl $0x8ba, %ecx            # imm = 0x8BA
jmp 0x9a2f8
leaq 0x53ae9(%rip), %rsi     # 0xee3f0
leaq 0x7f3de(%rip), %rdx     # 0x119cec
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x53705(%rip), %rsi     # 0xee034
leaq 0x7f779(%rip), %rdx     # 0x11a0af
movq %r14, %rdi
movl $0x8d8, %ecx            # imm = 0x8D8
jmp 0x9a2f8
leaq 0x53aa6(%rip), %rsi     # 0xee3f0
leaq 0x7f863(%rip), %rdx     # 0x11a1b4
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x536c2(%rip), %rsi     # 0xee034
leaq 0x7f736(%rip), %rdx     # 0x11a0af
movq %r14, %rdi
movl $0x899, %ecx            # imm = 0x899
jmp 0x9a2f8
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 0x9b3e7
testl %eax, %eax
je 0x9ab1e
leaq 0x53a37(%rip), %rsi     # 0xee3f0
leaq 0x7f970(%rip), %rdx     # 0x11a330
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x53658(%rip), %rsi     # 0xee034
leaq 0x7f6cc(%rip), %rdx     # 0x11a0af
movq %r13, %rdi
movl $0x91c, %ecx            # imm = 0x91C
jmp 0x9a2f8
movslq 0x2d0(%r14), %rax
jmp 0x9aa00
movslq 0x2d4(%r14), %rax
movsd 0x18(%rsp), %xmm0
subsd (%r15,%rax,8), %xmm0
divsd (%r12,%rax,8), %xmm0
movapd %xmm0, %xmm1
jmp 0x9abb2
leaq 0x539ce(%rip), %rsi     # 0xee3f0
leaq 0x7f6ad(%rip), %rdx     # 0x11a0d6
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x535ea(%rip), %rsi     # 0xee034
leaq 0x7f65e(%rip), %rdx     # 0x11a0af
movq %r14, %rdi
movl $0x8c7, %ecx            # imm = 0x8C7
movq %rbx, %r8
jmp 0x9aac2
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
leaq 0x7f81b(%rip), %rsi     # 0x11a28d
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x535f7(%rip), %rsi     # 0xee082
leaq 0x7f87a(%rip), %rdx     # 0x11a30c
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x53586(%rip), %rsi     # 0xee034
leaq 0x7f5fa(%rip), %rdx     # 0x11a0af
movq 0x8(%rsp), %rdi
movl $0x8cd, %ecx            # imm = 0x8CD
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
leaq 0x908(%rsp), %rdi
callq 0xa4f4
jmp 0x9a302
leaq 0x5390e(%rip), %rsi     # 0xee3f0
leaq 0x7f71a(%rip), %rdx     # 0x11a203
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x5352a(%rip), %rsi     # 0xee034
leaq 0x7f59e(%rip), %rdx     # 0x11a0af
movq %r14, %rdi
movl $0x8a3, %ecx            # imm = 0x8A3
jmp 0x9a2f8
movl 0x19b8(%rsp), %eax
testl %eax, %eax
je 0x9ac79
cmpl $0x1, %eax
movsd 0x10(%rsp), %xmm1
movsd 0x28(%rsp), %xmm3
jne 0x9abb2
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd 0x7d95d(%rip), %xmm1    # 0x1184b0
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 0x9abb2
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
divsd (%r15,%rax,8), %xmm0
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0x53c3a(%rip), %xmm1    # 0xee7e8
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 0x9ac1d
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9ac04
cmpl $0x2, %eax
jne 0x9ac1d
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 0x9beb7
testl %eax, %eax
je 0x9ac72
leaq 0x537b5(%rip), %rsi     # 0xee3f0
leaq 0x7f0aa(%rip), %rdx     # 0x119cec
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x533d6(%rip), %rsi     # 0xee034
leaq 0x7f44a(%rip), %rdx     # 0x11a0af
movq %r13, %rdi
movl $0x93d, %ecx            # imm = 0x93D
jmp 0x9a2f8
xorl %eax, %eax
jmp 0x9a307
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd 0x7d822(%rip), %xmm1    # 0x1184b0
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 0x9aa12