// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x91e8, %rsp           # imm = 0x91E8
movw %r9w, %ax
movl 0x91f8(%rsp), %r9d
movl 0x91f0(%rsp), %r9d
movq %rdi, 0x91d8(%rsp)
movq %rsi, 0x91d0(%rsp)
movq %rdx, 0x91c8(%rsp)
movq %rcx, 0x91c0(%rsp)
movl %r8d, 0x91bc(%rsp)
movsd %xmm0, 0x91b0(%rsp)
movw %ax, 0x91ae(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88b0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8878(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8858(%rsp)
movq 0x91d8(%rsp), %rax
movq %rax, 0x9130(%rsp)
movq 0x91d8(%rsp), %rax
cvtsi2sdl 0x2fc(%rax), %xmm0
movsd %xmm0, 0x9138(%rsp)
cmpl $0x0, 0x91f0(%rsp)
jne 0x11c145
movq 0x91d8(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x11c127
movq 0x91d8(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x11c145
movsd 0x9138(%rsp), %xmm0
movsd 0xb6110(%rip), %xmm1    # 0x1d2248
subsd %xmm1, %xmm0
movsd %xmm0, 0x9138(%rsp)
movl 0x91f0(%rsp), %eax
movl %eax, 0x91a0(%rsp)
movl 0x91f8(%rsp), %eax
movl %eax, 0x91a4(%rsp)
movl 0x91f0(%rsp), %eax
movl %eax, 0x4c(%rsp)
testl %eax, %eax
je 0x11c190
jmp 0x11c172
movl 0x4c(%rsp), %eax
subl $0x1, %eax
jne 0x11c1a1
jmp 0x11c17d
movsd 0xb60c3(%rip), %xmm0    # 0x1d2248
movsd %xmm0, 0x8858(%rsp)
jmp 0x11c1a1
movsd 0xb6638(%rip), %xmm0    # 0x1d27d0
movsd %xmm0, 0x8858(%rsp)
cvttsd2si 0x9138(%rsp), %edi
leaq 0x88c8(%rsp), %rsi
callq 0x8ff0
cmpl $0x1, %eax
jne 0x11c226
leaq 0x8050(%rsp), %rdi
leaq 0x88c8(%rsp), %rcx
addq $0x68, %rcx
leaq 0xb6201(%rip), %rsi     # 0x1d23d8
leaq 0xe1da8(%rip), %rdx     # 0x1fdf86
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x8050(%rsp), %r8
leaq 0xb5e31(%rip), %rsi     # 0x1d2034
leaq 0xe2185(%rip), %rdx     # 0x1fe38f
movl $0x848, %ecx            # imm = 0x848
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
movswl 0x91ae(%rsp), %eax
cmpl $0x1, %eax
jne 0x11c2dc
movq 0x91d8(%rsp), %rdi
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x8888(%rsp), %rsi
callq 0x1208e0
cmpl $0x1, %eax
jne 0x11c2da
leaq 0x7850(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb614d(%rip), %rsi     # 0x1d23d8
leaq 0xe2124(%rip), %rdx     # 0x1fe3b6
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x7850(%rsp), %r8
leaq 0xb5d7d(%rip), %rsi     # 0x1d2034
leaq 0xe20d1(%rip), %rdx     # 0x1fe38f
movl $0x852, %ecx            # imm = 0x852
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
jmp 0x11c2dc
xorps %xmm0, %xmm0
movsd %xmm0, 0x88b8(%rsp)
movsd 0x88b8(%rsp), %xmm0
movq 0x91c8(%rsp), %rdi
movq 0x91c0(%rsp), %rsi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0x9130(%rsp), %rdx
callq 0x11f6f0
cmpl $0x1, %eax
jne 0x11c38f
leaq 0x7050(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb6098(%rip), %rsi     # 0x1d23d8
leaq 0xe1c85(%rip), %rdx     # 0x1fdfcc
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x7050(%rsp), %r8
leaq 0xb5cc8(%rip), %rsi     # 0x1d2034
leaq 0xe201c(%rip), %rdx     # 0x1fe38f
movl $0x85f, %ecx            # imm = 0x85F
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
cmpl $0x1, 0x91f0(%rsp)
jne 0x11c4f8
movq 0x91d8(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x11c3bd
movq 0x91d8(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x11c4f8
movq 0x91d0(%rsp), %rax
movsd 0x6a8(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movaps 0xb5de6(%rip), %xmm2    # 0x1d2230
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x11c494
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x11c4dd
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movaps 0xb5d5d(%rip), %xmm1    # 0x1d2230
pand %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x88b0(%rsp)
jmp 0x11c552
movsd 0x8858(%rsp), %xmm0
movq 0x91d0(%rsp), %rax
mulsd 0x6a8(%rax), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x88b0(%rsp)
movl 0x91bc(%rsp), %eax
movq %rax, 0x30(%rsp)
subq $0x3, %rax
ja 0x11c86c
movq 0x30(%rsp), %rax
leaq 0xdfec4(%rip), %rcx     # 0x1fc438
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm1
movsd 0x88b0(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xb5c62(%rip), %xmm2    # 0x1d2248
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
cmpl $0x0, 0x91f8(%rsp)
jne 0x11c633
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x8878(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
jmp 0x11c86c
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x88b0(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
jmp 0x11c86c
xorps %xmm0, %xmm0
movsd %xmm0, 0x91b0(%rsp)
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x5b970
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd 0xba0fd(%rip), %xmm0    # 0x1d6810
mulsd (%rax,%rcx,8), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
cmpl $0x0, 0x91f8(%rsp)
jne 0x11c78e
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x5b970
movaps %xmm0, %xmm1
movsd 0x8878(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
movq 0x91d8(%rsp), %rax
cmpl $0x4, 0x18(%rax)
je 0x11c818
leaq 0x6850(%rsp), %rdi
leaq 0xe1c51(%rip), %rsi     # 0x1fe3fc
movb $0x0, %al
callq 0x5b9c0
leaq 0x6050(%rsp), %rdi
leaq 0x6850(%rsp), %rcx
leaq 0xb58b9(%rip), %rsi     # 0x1d2082
leaq 0xe1c97(%rip), %rdx     # 0x1fe467
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x6050(%rsp), %r8
leaq 0xb583f(%rip), %rsi     # 0x1d2034
leaq 0xe1b93(%rip), %rdx     # 0x1fe38f
movl $0x883, %ecx            # imm = 0x883
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
jmp 0x11c86c
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x88b0(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
jmp 0x11c86e
movsd 0x8858(%rsp), %xmm1
movsd 0x8878(%rsp), %xmm0
subsd 0x91b0(%rsp), %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x11d285
movq 0x91d8(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x11c8ba
movq 0x91d8(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x11c972
movq 0x91d8(%rsp), %rdi
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x8870(%rsp), %rsi
leaq 0x8868(%rsp), %rdx
leaq 0x8860(%rsp), %rcx
callq 0x11e190
cmpl $0x1, %eax
jne 0x11c96d
leaq 0x5850(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb5aba(%rip), %rsi     # 0x1d23d8
leaq 0xe1b6f(%rip), %rdx     # 0x1fe494
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x5850(%rsp), %r8
leaq 0xb56ea(%rip), %rsi     # 0x1d2034
leaq 0xe1a3e(%rip), %rdx     # 0x1fe38f
movl $0x899, %ecx            # imm = 0x899
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
jmp 0x11ca2f
movq 0x91d8(%rsp), %rdi
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x88a8(%rsp), %rsi
leaq 0x88a0(%rsp), %rdx
leaq 0x8898(%rsp), %rcx
leaq 0x8890(%rsp), %r8
callq 0x11be30
cmpl $0x1, %eax
jne 0x11ca2d
leaq 0x5050(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb59fa(%rip), %rsi     # 0x1d23d8
leaq 0xe1afe(%rip), %rdx     # 0x1fe4e3
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x5050(%rsp), %r8
leaq 0xb562a(%rip), %rsi     # 0x1d2034
leaq 0xe197e(%rip), %rdx     # 0x1fe38f
movl $0x8a3, %ecx            # imm = 0x8A3
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
jmp 0x11ca2f
movsd 0x88b8(%rsp), %xmm0
movsd %xmm0, 0x88c0(%rsp)
movsd 0x88c0(%rsp), %xmm0
addsd 0x88b0(%rsp), %xmm0
movsd %xmm0, 0x88b8(%rsp)
movsd 0x88b0(%rsp), %xmm1
divsd 0x88c0(%rsp), %xmm1
movaps 0xb57bb(%rip), %xmm0    # 0x1d2230
pand %xmm0, %xmm1
movq 0x91d0(%rsp), %rax
movsd 0xa28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x11cb21
leaq 0x4850(%rsp), %rdi
movsd 0x88b0(%rsp), %xmm0
divsd 0x88c0(%rsp), %xmm0
leaq 0xe1560(%rip), %rsi     # 0x1fe014
movb $0x1, %al
callq 0x5b9c0
leaq 0x4050(%rsp), %rdi
leaq 0x4850(%rsp), %rcx
leaq 0xb55b0(%rip), %rsi     # 0x1d2082
leaq 0xe1a5d(%rip), %rdx     # 0x1fe536
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x4050(%rsp), %r8
leaq 0xb5536(%rip), %rsi     # 0x1d2034
leaq 0xe188a(%rip), %rdx     # 0x1fe38f
movl $0x8af, %ecx            # imm = 0x8AF
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
movsd 0x88c0(%rsp), %xmm0
movsd 0x88b8(%rsp), %xmm1
movq 0x91c8(%rsp), %rsi
movq 0x91d0(%rsp), %rax
movsd 0x6b0(%rax), %xmm2
movq 0x91d0(%rsp), %rax
movsd 0xa28(%rax), %xmm3
leaq 0x2b8e(%rip), %rdi      # 0x11f6f0
leaq 0x9130(%rsp), %rdx
leaq 0x88c8(%rsp), %rcx
callq 0x97d0
cmpl $0x1, %eax
jne 0x11cbe6
leaq 0x3850(%rsp), %rdi
leaq 0x88c8(%rsp), %rcx
addq $0x68, %rcx
leaq 0xb5841(%rip), %rsi     # 0x1d23d8
leaq 0xe151c(%rip), %rdx     # 0x1fe0ba
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x3850(%rsp), %r8
leaq 0xb5471(%rip), %rsi     # 0x1d2034
leaq 0xe17c5(%rip), %rdx     # 0x1fe38f
movl $0x8ba, %ecx            # imm = 0x8BA
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
movswl 0x91ae(%rsp), %eax
cmpl $0x1, %eax
jne 0x11cd92
movsd 0x8888(%rsp), %xmm0
movsd %xmm0, 0x8880(%rsp)
movq 0x91d8(%rsp), %rdi
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x8888(%rsp), %rsi
callq 0x1208e0
cmpl $0x1, %eax
jne 0x11ccb9
leaq 0x3050(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb577b(%rip), %rsi     # 0x1d23d8
leaq 0xe1752(%rip), %rdx     # 0x1fe3b6
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x3050(%rsp), %r8
leaq 0xb53ab(%rip), %rsi     # 0x1d2034
leaq 0xe16ff(%rip), %rdx     # 0x1fe38f
movl $0x8c7, %ecx            # imm = 0x8C7
movb $0x0, %al
callq 0x5b9c0
leaq 0x88c8(%rsp), %rdi
callq 0x9730
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
movsd 0x8888(%rsp), %xmm0
movsd 0xb557e(%rip), %xmm1    # 0x1d2248
ucomisd %xmm1, %xmm0
jbe 0x11cd90
movsd 0xb556c(%rip), %xmm0    # 0x1d2248
ucomisd 0x8880(%rsp), %xmm0
jb 0x11cd90
leaq 0x2850(%rsp), %rdi
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xe1857(%rip), %rsi     # 0x1fe56d
movb $0x1, %al
callq 0x5b9c0
leaq 0x2050(%rsp), %rdi
leaq 0x2850(%rsp), %rcx
leaq 0xb534e(%rip), %rsi     # 0x1d2082
leaq 0xe18b1(%rip), %rdx     # 0x1fe5ec
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x2050(%rsp), %r8
leaq 0xb52d4(%rip), %rsi     # 0x1d2034
leaq 0xe1628(%rip), %rdx     # 0x1fe38f
movl $0x8cd, %ecx            # imm = 0x8CD
movb $0x0, %al
callq 0x5b9c0
leaq 0x88c8(%rsp), %rdi
callq 0x9730
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
jmp 0x11cd92
movsd 0x88b8(%rsp), %xmm0
movq 0x91c8(%rsp), %rdi
movq 0x91c0(%rsp), %rsi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0x9130(%rsp), %rdx
callq 0x11f6f0
cmpl $0x1, %eax
jne 0x11ce39
leaq 0x1850(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb55ee(%rip), %rsi     # 0x1d23d8
leaq 0xe11db(%rip), %rdx     # 0x1fdfcc
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x1850(%rsp), %r8
leaq 0xb521e(%rip), %rsi     # 0x1d2034
leaq 0xe1572(%rip), %rdx     # 0x1fe38f
movl $0x8d8, %ecx            # imm = 0x8D8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
cmpl $0x1, 0x91f0(%rsp)
jne 0x11cfa2
movq 0x91d8(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x11ce67
movq 0x91d8(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x11cfa2
movq 0x91d0(%rsp), %rax
movsd 0x6a8(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movaps 0xb533c(%rip), %xmm2    # 0x1d2230
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x11cf3e
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x11cf87
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movaps 0xb52b3(%rip), %xmm1    # 0x1d2230
pand %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x88b0(%rsp)
jmp 0x11cffc
movsd 0x8858(%rsp), %xmm0
movq 0x91d0(%rsp), %rax
mulsd 0x6a8(%rax), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x88b0(%rsp)
movl 0x91bc(%rsp), %eax
movq %rax, 0x18(%rsp)
subq $0x3, %rax
ja 0x11d280
movq 0x18(%rsp), %rax
leaq 0xdf43a(%rip), %rcx     # 0x1fc458
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm1
movsd 0x88b0(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xb51b8(%rip), %xmm2    # 0x1d2248
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
cmpl $0x0, 0x91f8(%rsp)
jne 0x11d0dd
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x8878(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
jmp 0x11d280
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x88b0(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
jmp 0x11d280
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x5b970
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd 0xb965f(%rip), %xmm0    # 0x1d6810
mulsd (%rax,%rcx,8), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
cmpl $0x0, 0x91f8(%rsp)
jne 0x11d22c
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x5b970
movaps %xmm0, %xmm1
movsd 0x8878(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
jmp 0x11d280
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x88b0(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8878(%rsp)
jmp 0x11c86e
leaq 0x88c8(%rsp), %rdi
callq 0x9730
cmpl $0x1, %eax
jne 0x11d301
leaq 0x1050(%rsp), %rdi
leaq 0x88c8(%rsp), %rcx
addq $0x68, %rcx
leaq 0xb5126(%rip), %rsi     # 0x1d23d8
leaq 0xb5928(%rip), %rdx     # 0x1d2be1
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x1050(%rsp), %r8
leaq 0xb4d56(%rip), %rsi     # 0x1d2034
leaq 0xe10aa(%rip), %rdx     # 0x1fe38f
movl $0x904, %ecx            # imm = 0x904
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
movl 0x91bc(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x3, %rax
ja 0x11d72b
movq 0x10(%rsp), %rax
leaq 0xdf125(%rip), %rcx     # 0x1fc448
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x91f8(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x11d3a7
jmp 0x11d33d
movl 0xc(%rsp), %eax
subl $0x1, %eax
jne 0x11d43d
jmp 0x11d34c
movsd 0x91b0(%rsp), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd 0xb4ecf(%rip), %xmm1    # 0x1d2248
subsd %xmm1, %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x88b0(%rsp)
jmp 0x11d43d
movsd 0x91b0(%rsp), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
movsd 0xb4e54(%rip), %xmm1    # 0x1d2248
subsd %xmm1, %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x88b0(%rsp)
jmp 0x11d72b
movsd 0x91b0(%rsp), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x88b0(%rsp)
jmp 0x11d72b
movq 0x91d8(%rsp), %rdi
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x8870(%rsp), %rsi
leaq 0x8868(%rsp), %rdx
leaq 0x8860(%rsp), %rcx
callq 0x11e190
cmpl $0x1, %eax
jne 0x11d544
leaq 0x850(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb4ee3(%rip), %rsi     # 0x1d23d8
leaq 0xe1114(%rip), %rdx     # 0x1fe610
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x850(%rsp), %r8
leaq 0xb4b13(%rip), %rsi     # 0x1d2034
leaq 0xe0e67(%rip), %rdx     # 0x1fe38f
movl $0x91c, %ecx            # imm = 0x91C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
movl 0x91f8(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x11d63a
jmp 0x11d559
movl 0x8(%rsp), %eax
subl $0x1, %eax
jne 0x11d6df
jmp 0x11d568
movsd 0x8878(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd 0xb9279(%rip), %xmm1    # 0x1d6820
mulsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm4
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm3
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x88b0(%rsp)
jmp 0x11d6df
movsd 0x8878(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd 0xb91a7(%rip), %xmm1    # 0x1d6820
divsd (%rax,%rcx,8), %xmm1
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm1
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x88b0(%rsp)
jmp 0x11d72b
movsd 0x91b0(%rsp), %xmm0
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x88b0(%rsp)
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x88b0(%rsp), %xmm2
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x88b0(%rsp), %xmm2
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
cmpl $0x1, 0x91f0(%rsp)
jne 0x11d83b
movq 0x91d8(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x11d7ed
movq 0x91d8(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x11d83b
movq 0x91c0(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x88b0(%rsp), %xmm2
movq 0x91c8(%rsp), %rax
movq 0x91d8(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x88b8(%rsp), %xmm0
movq 0x91c8(%rsp), %rdi
movq 0x91c0(%rsp), %rsi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0x9130(%rsp), %rdx
callq 0x11f6f0
cmpl $0x1, %eax
jne 0x11d8d9
leaq 0x50(%rsp), %rdi
movq 0x91d8(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xb4b48(%rip), %rsi     # 0x1d23d8
leaq 0xe0735(%rip), %rdx     # 0x1fdfcc
movb $0x0, %al
callq 0x5b9c0
movq 0x91d8(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x50(%rsp), %r8
leaq 0xb477b(%rip), %rsi     # 0x1d2034
leaq 0xe0acf(%rip), %rdx     # 0x1fe38f
movl $0x93d, %ecx            # imm = 0x93D
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x91e4(%rsp)
jmp 0x11d8e4
movl $0x0, 0x91e4(%rsp)
movl 0x91e4(%rsp), %eax
addq $0x91e8, %rsp           # imm = 0x91E8
retq
nopw %cs:(%rax,%rax)