// File: /workspace/github_c_makefile_star2_O2/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, %r13d
movsd %xmm0, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x19b8(%rsp), %ecx
movq %rdi, 0x88(%rsp)
cvtsi2sdl 0x2fc(%rdi), %xmm0
movl 0x19b0(%rsp), %ebp
movsd %xmm0, 0x90(%rsp)
xorpd %xmm1, %xmm1
testl %ebp, %ebp
jne 0x9543b
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9541c
cmpl $0x2, %eax
jne 0x95433
movsd 0x503c4(%rip), %xmm1    # 0xe57e8
addsd %xmm1, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x9543b
movsd 0x503ad(%rip), %xmm1    # 0xe57e8
movl %ebp, 0xf8(%rsp)
movl %ecx, 0xfc(%rsp)
cmpl $0x1, %ebp
jne 0x95456
movsd 0x4fe0a(%rip), %xmm1    # 0xe5260
movsd %xmm1, 0x20(%rsp)
cvttsd2si %xmm0, %edi
leaq 0x908(%rsp), %rsi
callq 0x8cb0
cmpl $0x1, %eax
jne 0x954bc
leaq 0x970(%rsp), %rcx
leaq 0x4ff6f(%rip), %rsi     # 0xe53f0
leaq 0x7b6be(%rip), %rdx     # 0x110b46
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x4fb8c(%rip), %rsi     # 0xe5034
leaq 0x7baa0(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x848, %ecx            # imm = 0x848
jmp 0x95582
cmpw $0x1, %r13w
jne 0x95523
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x978ce
testl %eax, %eax
je 0x95523
addq $0x32a, %r14            # imm = 0x32A
leaq 0x4ff01(%rip), %rsi     # 0xe53f0
leaq 0x7ba80(%rip), %rdx     # 0x110f76
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4fb22(%rip), %rsi     # 0xe5034
leaq 0x7ba36(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x852, %ecx            # imm = 0x852
jmp 0x95582
movl %r13d, 0x3c(%rsp)
movl %ebp, %r13d
leaq 0x32a(%r14), %rbp
leaq 0x88(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x97105
testl %eax, %eax
je 0x955a1
leaq 0x4fea0(%rip), %rsi     # 0xe53f0
leaq 0x7b635(%rip), %rdx     # 0x110b8c
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4fac1(%rip), %rsi     # 0xe5034
leaq 0x7b9d5(%rip), %rdx     # 0x110f4f
movq %rbp, %rdi
movl $0x85f, %ecx            # imm = 0x85F
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x1978, %rsp           # imm = 0x1978
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, (%rsp)
movl %r13d, %ebp
cmpl $0x1, %r13d
jne 0x95606
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x955bc
cmpl $0x2, %eax
jne 0x95606
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd (%r12,%rax,8), %xmm2
movapd %xmm0, %xmm4
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm1
divsd (%r12,%rax,8), %xmm1
andpd 0x4fc52(%rip), %xmm1    # 0xe5240
divsd %xmm2, %xmm4
minsd %xmm1, %xmm4
mulsd 0x6a8(%rbx), %xmm4
movsd 0x20(%rsp), %xmm3
jmp 0x95633
movsd 0x6a8(%rbx), %xmm4
movsd 0x20(%rsp), %xmm3
mulsd %xmm3, %xmm4
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
mulsd %xmm0, %xmm4
movsd (%r12,%rax,8), %xmm2
divsd %xmm2, %xmm4
movl 0x14(%rsp), %eax
movl %eax, %r13d
cmpl $0x3, %eax
ja 0x95749
leaq 0x79d66(%rip), %rax     # 0x10f3b0
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
jmpq *%rcx
mulsd %xmm4, %xmm1
addsd 0x4fbf9(%rip), %xmm1    # 0xe5260
mulsd %xmm1, %xmm2
cmpl $0x0, 0x19b8(%rsp)
jne 0x9574d
divsd %xmm0, %xmm2
jmp 0x9574d
mulsd %xmm1, %xmm1
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm2
movsd 0x544cd(%rip), %xmm5    # 0xe9b68
mulsd %xmm2, %xmm5
mulsd %xmm2, %xmm5
subsd %xmm1, %xmm5
movapd %xmm5, %xmm2
cmpl $0x0, 0x19b8(%rsp)
jne 0x956bd
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
cmpl $0x4, 0x18(%r14)
je 0x9574d
leaq 0x7b8e7(%rip), %rsi     # 0x110fbc
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x4f994(%rip), %rsi     # 0xe5082
leaq 0x7b932(%rip), %rdx     # 0x111027
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f923(%rip), %rsi     # 0xe5034
leaq 0x7b837(%rip), %rdx     # 0x110f4f
movq (%rsp), %rdi
movl $0x883, %ecx            # imm = 0x883
jmp 0x95ae6
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
jmp 0x9574d
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm2
mulsd %xmm4, %xmm2
addsd (%r15,%rax,8), %xmm2
jmp 0x9574d
xorpd %xmm2, %xmm2
xorpd %xmm6, %xmm6
movapd %xmm2, %xmm5
movsd %xmm5, 0x40(%rsp)
subsd 0x18(%rsp), %xmm5
mulsd %xmm3, %xmm5
movsd %xmm5, 0x48(%rsp)
movapd %xmm6, %xmm2
xorpd %xmm0, %xmm0
ucomisd 0x48(%rsp), %xmm0
movsd %xmm4, 0x8(%rsp)
jbe 0x95a39
movsd %xmm2, 0x28(%rsp)
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x95799
cmpl $0x2, %eax
jne 0x957c6
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 0x96639
testl %eax, %eax
je 0x957fa
jmp 0x95b74
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 0x952ba
testl %eax, %eax
jne 0x95cc3
movsd 0x8(%rsp), %xmm2
movapd %xmm2, %xmm0
movsd 0x28(%rsp), %xmm4
divsd %xmm4, %xmm0
movapd %xmm0, %xmm1
andpd 0x4fa26(%rip), %xmm1    # 0xe5240
movsd 0xa28(%rbx), %xmm3
ucomisd %xmm1, %xmm3
ja 0x95a93
movapd %xmm2, %xmm1
addsd %xmm4, %xmm1
movsd 0x6b0(%rbx), %xmm2
leaq 0x18c2(%rip), %rdi      # 0x97105
movapd %xmm4, %xmm0
movsd %xmm1, 0x8(%rsp)
movq %r15, %rsi
leaq 0x88(%rsp), %rdx
leaq 0x908(%rsp), %rcx
callq 0x908f
cmpl $0x1, %eax
je 0x95aee
cmpw $0x1, 0x3c(%rsp)
jne 0x958c8
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
callq 0x978ce
testl %eax, %eax
jne 0x95c05
movsd 0x30(%rsp), %xmm0
ucomisd 0x4f9ae(%rip), %xmm0    # 0xe5260
jbe 0x958c8
movsd 0x4f9a4(%rip), %xmm0    # 0xe5260
ucomisd 0x28(%rsp), %xmm0
jae 0x95c47
movq %r15, %rdi
movq %r12, %rsi
leaq 0x88(%rsp), %rdx
callq 0x97105
testl %eax, %eax
jne 0x95b32
cmpl $0x1, %ebp
jne 0x95940
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x958f6
cmpl $0x2, %eax
jne 0x95940
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd (%r12,%rax,8), %xmm1
movapd %xmm0, %xmm4
divsd %xmm1, %xmm4
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm2
divsd (%r12,%rax,8), %xmm2
andpd 0x4f914(%rip), %xmm2    # 0xe5240
minsd %xmm2, %xmm4
mulsd 0x6a8(%rbx), %xmm4
movsd 0x20(%rsp), %xmm3
jmp 0x9596d
movsd 0x6a8(%rbx), %xmm4
movsd 0x20(%rsp), %xmm3
mulsd %xmm3, %xmm4
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
mulsd %xmm0, %xmm4
movsd (%r12,%rax,8), %xmm1
divsd %xmm1, %xmm4
movq %r13, %rax
movsd 0x8(%rsp), %xmm6
movapd %xmm6, %xmm2
cmpl $0x3, 0x14(%rsp)
ja 0x9576f
leaq 0x79a44(%rip), %rcx     # 0x10f3d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movapd %xmm1, %xmm2
divsd %xmm0, %xmm2
jmpq *%rax
mulsd %xmm4, %xmm2
addsd 0x4f8b7(%rip), %xmm2    # 0xe5260
mulsd %xmm2, %xmm1
movapd %xmm1, %xmm5
cmpl $0x0, 0x19b8(%rsp)
jne 0x95755
divsd %xmm0, %xmm1
movapd %xmm1, %xmm5
jmp 0x95755
mulsd %xmm2, %xmm2
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm1
movapd %xmm1, %xmm5
mulsd 0x5417f(%rip), %xmm5    # 0xe9b68
mulsd %xmm1, %xmm5
subsd %xmm2, %xmm5
cmpl $0x0, 0x19b8(%rsp)
jne 0x95755
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm5
jmp 0x95755
mulsd %xmm4, %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm5
jmp 0x95755
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm5
mulsd %xmm4, %xmm5
addsd (%r15,%rax,8), %xmm5
jmp 0x95755
leaq 0x908(%rsp), %rdi
callq 0x9024
cmpl $0x1, %eax
jne 0x95bb6
leaq 0x970(%rsp), %rcx
leaq 0x4f992(%rip), %rsi     # 0xe53f0
leaq 0x50194(%rip), %rdx     # 0xe5bf9
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x4f5b6(%rip), %rsi     # 0xe5034
leaq 0x7b4ca(%rip), %rdx     # 0x110f4f
movq (%rsp), %rdi
movl $0x904, %ecx            # imm = 0x904
jmp 0x95582
leaq 0x7b13a(%rip), %rsi     # 0x110bd4
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x4f5cf(%rip), %rsi     # 0xe5082
leaq 0x7b63c(%rip), %rdx     # 0x1110f6
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f55e(%rip), %rsi     # 0xe5034
leaq 0x7b472(%rip), %rdx     # 0x110f4f
movq (%rsp), %rdi
movl $0x8af, %ecx            # imm = 0x8AF
movq %r14, %r8
jmp 0x95585
leaq 0x970(%rsp), %rcx
leaq 0x4f8f3(%rip), %rsi     # 0xe53f0
leaq 0x7b176(%rip), %rdx     # 0x110c7a
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x4f517(%rip), %rsi     # 0xe5034
leaq 0x7b42b(%rip), %rdx     # 0x110f4f
movq (%rsp), %rdi
movl $0x8ba, %ecx            # imm = 0x8BA
jmp 0x95582
leaq 0x4f8b7(%rip), %rsi     # 0xe53f0
leaq 0x7b04c(%rip), %rdx     # 0x110b8c
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f4d4(%rip), %rsi     # 0xe5034
leaq 0x7b3e8(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x8d8, %ecx            # imm = 0x8D8
jmp 0x95582
leaq 0x4f875(%rip), %rsi     # 0xe53f0
leaq 0x7b4d2(%rip), %rdx     # 0x111054
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f492(%rip), %rsi     # 0xe5034
leaq 0x7b3a6(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x899, %ecx            # imm = 0x899
jmp 0x95582
cmpl $0x3, 0x14(%rsp)
movq (%rsp), %rbx
ja 0x95d99
leaq 0x797f4(%rip), %rax     # 0x10f3c0
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x19b8(%rsp), %eax
testl %eax, %eax
movsd 0x8(%rsp), %xmm1
je 0x95e07
cmpl $0x1, %eax
jne 0x95e30
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
jmp 0x95e1a
leaq 0x4f7e4(%rip), %rsi     # 0xe53f0
leaq 0x7b363(%rip), %rdx     # 0x110f76
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f401(%rip), %rsi     # 0xe5034
leaq 0x7b315(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x8c7, %ecx            # imm = 0x8C7
movq %rbx, %r8
jmp 0x95caa
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
leaq 0x7b4d2(%rip), %rsi     # 0x11112d
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x4f40e(%rip), %rsi     # 0xe5082
leaq 0x7b531(%rip), %rdx     # 0x1111ac
leaq 0x1170(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f39d(%rip), %rsi     # 0xe5034
leaq 0x7b2b1(%rip), %rdx     # 0x110f4f
movq (%rsp), %rdi
movl $0x8cd, %ecx            # imm = 0x8CD
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
leaq 0x908(%rsp), %rdi
callq 0x9024
jmp 0x9558c
leaq 0x4f726(%rip), %rsi     # 0xe53f0
leaq 0x7b3d2(%rip), %rdx     # 0x1110a3
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f343(%rip), %rsi     # 0xe5034
leaq 0x7b257(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x8a3, %ecx            # imm = 0x8A3
jmp 0x95582
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 0x96639
testl %eax, %eax
je 0x95da4
leaq 0x4f6bc(%rip), %rsi     # 0xe53f0
leaq 0x7b495(%rip), %rdx     # 0x1111d0
movq %rbx, %r14
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f2da(%rip), %rsi     # 0xe5034
leaq 0x7b1ee(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x91c, %ecx            # imm = 0x91C
jmp 0x95582
movslq 0x2d0(%r14), %rax
jmp 0x95d7e
movslq 0x2d4(%r14), %rax
movsd 0x18(%rsp), %xmm0
subsd (%r15,%rax,8), %xmm0
divsd (%r12,%rax,8), %xmm0
movapd %xmm0, %xmm1
jmp 0x95e30
movsd 0x8(%rsp), %xmm1
jmp 0x95e30
movl 0x19b8(%rsp), %eax
testl %eax, %eax
je 0x95ef5
cmpl $0x1, %eax
movsd 0x8(%rsp), %xmm1
jne 0x95e30
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd 0x7957d(%rip), %xmm1    # 0x10f350
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
movsd 0x40(%rsp), %xmm1
jmp 0x95e2c
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
divsd (%r15,%rax,8), %xmm0
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0x4f9bc(%rip), %xmm1    # 0xe57e8
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, %ebp
jne 0x95e96
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x95e7d
cmpl $0x2, %eax
jne 0x95e96
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 0x97105
testl %eax, %eax
je 0x95eee
leaq 0x4f53c(%rip), %rsi     # 0xe53f0
leaq 0x7acd1(%rip), %rdx     # 0x110b8c
movq %rbx, %r14
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4f15a(%rip), %rsi     # 0xe5034
leaq 0x7b06e(%rip), %rdx     # 0x110f4f
movq %r14, %rdi
movl $0x93d, %ecx            # imm = 0x93D
jmp 0x95582
xorl %eax, %eax
jmp 0x9558f
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd 0x79446(%rip), %xmm1    # 0x10f350
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 0x40(%rsp), %xmm0
divsd %xmm1, %xmm0
jmp 0x95d90