// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_solve_inflation
int primordial_inflation_solve_inflation(
                                         struct perturbations * ppt,
                                         struct primordial * ppm,
                                         struct precision *ppr
                                         ) {
  /** Summary: */
  /** - define local variables */
  double * y;
  double * y_ini;
  double * dy;
  double a_pivot;
  double a_try;
  double H_pivot;
  double H_try;
  double phi_try;
  double dphidt_pivot;
  double dphidt_try;
  double aH_ini,aH_end;
  double k_max,k_min;
  int counter;
  double dH,ddH,dddH;

  /** - allocate vectors for background/perturbed quantities */
  class_alloc(y,ppm->in_size*sizeof(double),ppm->error_message);
  class_alloc(y_ini,ppm->in_size*sizeof(double),ppm->error_message);
  class_alloc(dy,ppm->in_size*sizeof(double),ppm->error_message);

  /** - eventually, needs first to find phi_pivot */
  if (ppm->primordial_spec_type == inflation_V_end) {

    class_call(primordial_inflation_find_phi_pivot(ppm,ppr,y,dy),
               ppm->error_message,
               ppm->error_message);

  }
  else {
    ppm->phi_pivot = 0.;
  }

  // uncomment these lines if for checking, you want first-order slow-roll predictions
  /*
    if (ppm->primordial_verbose>0) {
    if ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end)) {
    double V,dV,ddV;
    class_call(primordial_inflation_check_potential(ppm,ppm->phi_pivot,&V,&dV,&ddV),
    ppm->error_message,
    ppm->error_message);
    fprintf(stdout," -> 1st-order slow-roll prediction for A_s: %g\n",128.*_PI_/3.*pow(V,3)/pow(dV,2));
    fprintf(stdout," -> 1st-order slow-roll prediction for T/S: %g\n",pow(dV/V,2)/_PI_);
    fprintf(stdout," -> 1st-order slow-roll prediction for A_T: %g\n",pow(dV/V,2)/_PI_*128.*_PI_/3.*pow(V,3)/pow(dV,2));
    fprintf(stdout," -> 1st-order slow-roll prediction for n_s: %g\n",1.-6./16./_PI_*pow(dV/V,2)+2./8./_PI_*(ddV/V));
    fprintf(stdout," -> 1st-order slow-roll prediction for n_t: %g\n",-2./16./_PI_*pow(dV/V,2));
    }
    }
  */

  /** - compute H_pivot at phi_pivot */
  switch (ppm->primordial_spec_type) {

  case inflation_V:
  case inflation_V_end:

    /** - check positivity and negative slope of potential in field pivot
        value, and find value of phi_dot and H for field's pivot value,
        assuming slow-roll attractor solution has been reached. If no
        solution, code will stop there. */

    if (ppm->primordial_verbose > 1)
      printf(" (search attractor at pivot)\n");

    class_call_except(primordial_inflation_find_attractor(ppm,
                                                          ppr,
                                                          ppm->phi_pivot,
                                                          ppr->primordial_inflation_attractor_precision_pivot,
                                                          y,
                                                          dy,
                                                          &H_pivot,
                                                          &dphidt_pivot),
                      ppm->error_message,
                      ppm->error_message,
                      free(y);free(y_ini);free(dy));
    break;

  case inflation_H:

    /** - check positivity and negative slope of \f$ H(\phi)\f$ in field pivot
        value, and get H_pivot */

    class_call_except(primordial_inflation_check_hubble(ppm,
                                                        ppm->phi_pivot,
                                                        &H_pivot,
                                                        &dH,
                                                        &ddH,
                                                        &dddH),
                      ppm->error_message,
                      ppm->error_message,
                      free(y);free(y_ini);free(dy));
    break;

  default:
    free(y);free(y_ini);free(dy);
    class_stop(ppm->error_message,"ppm->primordial_spec_type=%d different from possible relevant cases",ppm->primordial_spec_type);
    break;
  }

  /** - find a_pivot, value of scale factor when k_pivot crosses horizon while phi=phi_pivot */

  a_pivot = ppm->k_pivot/H_pivot;

  /** - integrate background solution starting from phi_pivot and until
      k_max>>aH. This ensures that the inflationary model considered
      here is valid and that the primordial spectrum can be
      computed. Otherwise, if slow-roll brakes too early, model is not
      suitable and run stops. */

  if (ppm->primordial_verbose > 1)
    printf(" (check inflation duration after phi_pivot=%e)\n",ppm->phi_pivot);

  k_max = exp(ppm->lnk[ppm->lnk_size-1]);
  aH_end = k_max/ppr->primordial_inflation_ratio_max;

  y[ppm->index_in_a] = a_pivot;
  y[ppm->index_in_phi] = ppm->phi_pivot;
  if ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end))
    y[ppm->index_in_dphi] = a_pivot*dphidt_pivot;

  class_call_except(primordial_inflation_evolve_background(ppm,
                                                           ppr,
                                                           y,
                                                           dy,
                                                           _aH_,
                                                           aH_end,
                                                           _TRUE_,
                                                           forward,
                                                           conformal),
                    ppm->error_message,
                    ppm->error_message,
                    free(y);free(y_ini);free(dy));

  /* we need to do the opposite: to check that there is an initial
     time such that k_min << (aH)_ini. A guess is made by integrating
     backward in time. This can be done exactly for inflation_H, or
     only approximately for inflation_V (using the first-order
     approximation to the attractor inflationary solution). However
     this approximation is irrelevant because nevertheless, later on,
     we compute the attractor solution at the initial time with high
     accuracy, and then we integrate the background equations forward
     in time. Hence the approximation made here introduces zero
     mistake on the final result. It is just a way to find quickly a
     reasonable initial phi value. In the inflation_V case, if the
     exact forward integration reveals that the guess was not good
     (i.e. does not correspond to "early enough"), we iterate over
     sequences of backward/forward integration, until a correct time is
     found. For potential such that no solution exists (no long-enough
     slow-roll period before the pivot scale), the run stops. */

  if (ppm->primordial_verbose > 1)
    printf(" (check inflation duration before pivot)\n");

  k_min = exp(ppm->lnk[0]);
  aH_ini = k_min/ppr->primordial_inflation_ratio_min;

  switch (ppm->primordial_spec_type) {

  case inflation_V:
  case inflation_V_end:

    counter = 0;

    y[ppm->index_in_a] = a_pivot;
    y[ppm->index_in_phi] = ppm->phi_pivot;

    do {

      /* counter to avoid infinite loop */
      counter ++;

      class_test_except(counter >= ppr->primordial_inflation_phi_ini_maxit,
                        ppm->error_message,
                        free(y);free(y_ini);free(dy),
                        "when searching for an initial value of phi just before observable inflation takes place, could not converge after %d iterations. The potential does not allow eough inflationary e-folds before reaching the pivot scale",
                        counter);

      /* try to find a value phi_try such that
         aH=aH_ini*(ppr->primordial_inflation_aH_ini_target) (default:
         aH_ini*0.9). But this is using the approximate backward
         solution. So, anyway, we will check using the exact forward
         solution that at this phi_try, we really have aH < aH_ini; if
         this is not the case, we will iterate until a correct phi_try
         is found. */

      class_call_except(primordial_inflation_evolve_background(ppm,
                                                               ppr,
                                                               y,
                                                               dy,
                                                               _aH_,
                                                               aH_ini*ppr->primordial_inflation_aH_ini_target,
                                                               _TRUE_,
                                                               backward,
                                                               conformal),
                        ppm->error_message,
                        ppm->error_message,
                        free(y);free(y_ini);free(dy));

      phi_try = y[ppm->index_in_phi];

      /* in inflation_V case, find the accurate attractor solution for
         phi_ini', and then the correct value of a_ini, and finally of
         dphi/dtau_ini */

      /* find dphi/dt_ini (unlike dphi/dtau_ini, this does not depend on normalization of a) */
      class_call_except(primordial_inflation_find_attractor(ppm,
                                                            ppr,
                                                            phi_try,
                                                            ppr->primordial_inflation_attractor_precision_initial,
                                                            y,
                                                            dy,
                                                            &H_try,
                                                            &dphidt_try),
                        ppm->error_message,
                        ppm->error_message,
                        free(y);free(y_ini);free(dy));

      /* we need to normalize a properly so that a=a_pivot when
         phi=phi_pivot. To do so, we evolve starting arbitrarily from
         a_ini=1, and then we rescale a_ini appropriately. */

      y[ppm->index_in_a] = 1.;
      y[ppm->index_in_phi] = phi_try;
      y[ppm->index_in_dphi] = y[ppm->index_in_a]*dphidt_try; // dphi/dtau = a dphi/dt

      class_call_except(primordial_inflation_evolve_background(ppm,
                                                               ppr,
                                                               y,
                                                               dy,
                                                               _phi_,
                                                               ppm->phi_pivot,
                                                               _TRUE_,
                                                               forward,
                                                               conformal),
                        ppm->error_message,
                        ppm->error_message,
                        free(y);free(y_ini);free(dy));

      /* now impose the correct a_ini */
      a_try = a_pivot/y[ppm->index_in_a];

      /* in case another iteration will be needed, set a new starting point for the routine primordial_inflation_evolve_background(...,backward) */
      y[ppm->index_in_a] = a_try;
      y[ppm->index_in_phi] = phi_try;

    } while (a_try*H_try > aH_ini);

    y_ini[ppm->index_in_a] = a_try;
    y_ini[ppm->index_in_phi] = phi_try;
    y_ini[ppm->index_in_dphi] = y_ini[ppm->index_in_a]*dphidt_try; // dphi/dtau = a dphi/dt

    break;

  case inflation_H:

    y[ppm->index_in_a] = a_pivot;
    y[ppm->index_in_phi] = ppm->phi_pivot;

    class_call_except(primordial_inflation_evolve_background(ppm,
                                                             ppr,
                                                             y,
                                                             dy,
                                                             _aH_,
                                                             aH_ini,
                                                             _TRUE_,
                                                             backward,
                                                             conformal),
                      ppm->error_message,
                      ppm->error_message,
                      free(y);free(y_ini);free(dy));

    y_ini[ppm->index_in_a] = y[ppm->index_in_a];
    y_ini[ppm->index_in_phi] = y[ppm->index_in_phi];

    break;

  default:
    free(y);free(y_ini);free(dy);
    class_stop(ppm->error_message,"ppm->primordial_spec_type=%d different from possible relevant cases",ppm->primordial_spec_type);
    break;
  }

  /** - starting from this time, i.e. from y_ini[ ], we run the routine
      which takes care of computing the primordial spectrum. */

  if (ppm->primordial_verbose > 1)
    printf(" (compute spectrum)\n");

  if (ppm->behavior == numerical) {

    class_call_except(primordial_inflation_spectra(ppt,
                                                   ppm,
                                                   ppr,
                                                   y_ini),
                      ppm->error_message,
                      ppm->error_message,
                      free(y);free(y_ini);free(dy));
  }
  else if (ppm->behavior == analytical) {

    class_call_except(primordial_inflation_analytic_spectra(ppt,
                                                            ppm,
                                                            ppr,
                                                            y_ini),
                      ppm->error_message,
                      ppm->error_message,
                      free(y);free(y_ini);free(dy));
  }
  else {
    class_stop(ppm->error_message,"Uncomprehensible value of the flag ppm->behavior=%d",ppm->behavior);
  }

  /** - before ending, we want to compute and store the values of \f$ \phi \f$
      corresponding to k=aH for k_min and k_max */

  y[ppm->index_in_a] = y_ini[ppm->index_in_a];
  y[ppm->index_in_phi] = y_ini[ppm->index_in_phi];
  if ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end))
    y[ppm->index_in_dphi] = y_ini[ppm->index_in_dphi];

  class_call_except(primordial_inflation_evolve_background(ppm,
                                                           ppr,
                                                           y,
                                                           dy,
                                                           _aH_,
                                                           k_min,
                                                           _FALSE_,
                                                           forward,
                                                           conformal),
                    ppm->error_message,
                    ppm->error_message,
                    free(y);free(y_ini);free(dy));

  ppm->phi_min=y[ppm->index_in_phi];

  class_call_except(primordial_inflation_evolve_background(ppm,
                                                           ppr,
                                                           y,
                                                           dy,
                                                           _aH_,
                                                           k_max,
                                                           _FALSE_,
                                                           forward,
                                                           conformal),
                    ppm->error_message,
                    ppm->error_message,
                    free(y);free(y_ini);free(dy));

  ppm->phi_max=y[ppm->index_in_phi];

  if (ppm->primordial_verbose > 1)
    printf(" (observable power spectrum goes from %e to %e)\n",
           ppm->phi_min,
           ppm->phi_max);

  /** - finally, we can de-allocate */

  free(y);
  free(y_ini);
  free(dy);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1098, %rsp           # imm = 0x1098
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x300(%rsi), %rbp
movq %rbp, %r15
shlq $0x3, %r15
movq %r15, %rdi
callq 0x8490
testq %rax, %rax
je 0x92150
movq %rax, %r12
movq %r15, %rdi
callq 0x8490
testq %rax, %rax
je 0x92199
movq %rax, 0x18(%rsp)
movq %r15, %rdi
callq 0x8490
testq %rax, %rax
je 0x921df
movq %rax, %r15
movl 0x18(%r14), %ebp
cmpl $0x4, %ebp
jne 0x92244
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x93ea6
testl %eax, %eax
je 0x9224e
addq $0x32a, %r14            # imm = 0x32A
leaq 0x532d7(%rip), %rsi     # 0xe53f0
leaq 0x7e1c3(%rip), %rdx     # 0x1102e3
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x52ef8(%rip), %rsi     # 0xe5034
leaq 0x7e17b(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x4c0, %ecx            # imm = 0x4C0
jmp 0x92223
leal (,%rbp,8), %ecx
leaq 0x52ea6(%rip), %rsi     # 0xe5004
leaq 0x56279(%rip), %rdx     # 0xe83de
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52eaf(%rip), %rsi     # 0xe5034
leaq 0x7e132(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x4b7, %ecx            # imm = 0x4B7
jmp 0x92223
leal (,%rbp,8), %ecx
leaq 0x52e5d(%rip), %rsi     # 0xe5004
leaq 0x5bdc1(%rip), %rdx     # 0xedf6f
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52e66(%rip), %rsi     # 0xe5034
leaq 0x7e0e9(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x4b8, %ecx            # imm = 0x4B8
jmp 0x92223
leal (,%rbp,8), %ecx
leaq 0x52e17(%rip), %rsi     # 0xe5004
leaq 0x7b729(%rip), %rdx     # 0x10d91d
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52e20(%rip), %rsi     # 0xe5034
leaq 0x7e0a3(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x4b9, %ecx            # imm = 0x4B9
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x1098, %rsp           # imm = 0x1098
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andq $0x0, 0x308(%r14)
jmp 0x92252
movl 0x18(%r14), %ebp
cmpl $0x4, %ebp
je 0x92269
cmpl $0x3, %ebp
je 0x922f7
cmpl $0x2, %ebp
jne 0x924d1
cmpw $0x2, 0x328(%r14)
jl 0x92280
leaq 0x7fed4(%rip), %rdi     # 0x11214f
callq 0x8540
movsd 0x308(%r14), %xmm0
movsd 0x6b8(%r13), %xmm1
leaq 0x40(%rsp), %r8
leaq 0x68(%rsp), %r9
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x94ea3
testl %eax, %eax
je 0x9238f
addq $0x32a, %r14            # imm = 0x32A
leaq 0x5312d(%rip), %rsi     # 0xe53f0
leaq 0x7e04b(%rip), %rdx     # 0x110315
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x52d4e(%rip), %rsi     # 0xe5034
leaq 0x7dfd1(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x4f0, %ecx            # imm = 0x4F0
jmp 0x92366
movsd 0x308(%r14), %xmm0
leaq 0x40(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x80(%rsp), %rcx
leaq 0x78(%rsp), %r8
movq %r14, %rdi
callq 0x952ba
testl %eax, %eax
je 0x9238f
addq $0x32a, %r14            # imm = 0x32A
leaq 0x530bc(%rip), %rsi     # 0xe53f0
leaq 0x7e06d(%rip), %rdx     # 0x1103a8
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x52cdd(%rip), %rsi     # 0xe5034
leaq 0x7df60(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x500, %ecx            # imm = 0x500
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
movq %r12, %rdi
callq 0x8430
movq 0x18(%rsp), %rdi
callq 0x8430
movq %r15, %rdi
callq 0x8430
jmp 0x9222d
movsd (%r14), %xmm0
divsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
cmpw $0x2, 0x328(%r14)
jl 0x923c2
movsd 0x308(%r14), %xmm0
leaq 0x7e084(%rip), %rdi     # 0x11043f
movb $0x1, %al
callq 0x8030
movq 0x298(%r14), %rax
movslq 0x290(%r14), %rcx
movsd -0x8(%rax,%rcx,8), %xmm0
callq 0x86a0
movsd %xmm0, 0x48(%rsp)
divsd 0x690(%r13), %xmm0
movslq 0x2d0(%r14), %rax
movsd 0x28(%rsp), %xmm1
movsd %xmm1, (%r12,%rax,8)
movsd 0x308(%r14), %xmm1
movslq 0x2d4(%r14), %rax
movsd %xmm1, (%r12,%rax,8)
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x92421
cmpl $0x2, %eax
jne 0x9243a
movsd 0x68(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
movslq 0x2d8(%r14), %rax
movsd %xmm1, (%r12,%rax,8)
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x953b4
testl %eax, %eax
je 0x92547
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52f7a(%rip), %rsi     # 0xe53f0
leaq 0x7dff2(%rip), %rdx     # 0x11046f
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x52b9b(%rip), %rsi     # 0xe5034
leaq 0x7de1e(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x529, %ecx            # imm = 0x529
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
movq %r12, %rdi
callq 0x8430
movq 0x18(%rsp), %rdi
callq 0x8430
movq %r15, %rdi
callq 0x8430
jmp 0x92230
movq %r12, %rdi
callq 0x8430
movq 0x18(%rsp), %rdi
callq 0x8430
movq %r15, %rdi
callq 0x8430
leaq 0x7df09(%rip), %rsi     # 0x1103fb
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2e014
leaq 0x53078(%rip), %rsi     # 0xe5585
leaq 0x890(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52b04(%rip), %rsi     # 0xe5034
leaq 0x7dd87(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x505, %ecx            # imm = 0x505
movq %r15, %r8
jmp 0x92226
movq %r15, 0x20(%rsp)
cmpw $0x2, 0x328(%r14)
jl 0x92563
leaq 0x7fc0e(%rip), %rdi     # 0x11216c
callq 0x8540
movq 0x298(%r14), %rax
movsd (%rax), %xmm0
callq 0x86a0
movapd %xmm0, %xmm1
divsd 0x688(%r13), %xmm1
movl 0x18(%r14), %r15d
cmpl $0x4, %r15d
je 0x9259e
cmpl $0x3, %r15d
je 0x9275b
cmpl $0x2, %r15d
jne 0x92801
movsd %xmm0, 0x38(%rsp)
movslq 0x2d0(%r14), %rax
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%r12,%rax,8)
movsd 0x308(%r14), %xmm0
movslq 0x2d4(%r14), %rax
movsd %xmm0, (%r12,%rax,8)
pushq $0x1
popq %r15
movsd %xmm1, 0x58(%rsp)
cmpl 0x698(%r13), %r15d
jge 0x92877
movsd 0x6d8(%r13), %xmm0
mulsd %xmm1, %xmm0
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %rcx
xorl %r8d, %r8d
pushq $0x1
popq %r9
callq 0x953b4
testl %eax, %eax
jne 0x928db
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd 0x6c0(%r13), %xmm1
movq %r14, %rdi
movq %r13, %rsi
movsd %xmm0, 0x30(%rsp)
movq %r12, %rdx
movq 0x20(%rsp), %rcx
leaq 0x70(%rsp), %r8
leaq 0x60(%rsp), %r9
callq 0x94ea3
testl %eax, %eax
jne 0x92920
movslq 0x2d0(%r14), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%r12,%rax,8)
movslq 0x2d4(%r14), %rcx
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%r12,%rcx,8)
movsd 0x60(%rsp), %xmm1
movsd (%r12,%rax,8), %xmm0
movsd %xmm1, 0x50(%rsp)
mulsd %xmm1, %xmm0
movslq 0x2d8(%r14), %rax
movsd %xmm0, (%r12,%rax,8)
movsd 0x308(%r14), %xmm0
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %rcx
pushq $0x1
popq %r8
movl %r8d, %r9d
callq 0x953b4
testl %eax, %eax
jne 0x92962
movslq 0x2d0(%r14), %rax
movsd 0x28(%rsp), %xmm0
divsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
movslq 0x2d4(%r14), %rcx
movsd 0x30(%rsp), %xmm1
movsd %xmm1, (%r12,%rcx,8)
movsd 0x70(%rsp), %xmm1
mulsd %xmm0, %xmm1
incl %r15d
movsd 0x58(%rsp), %xmm2
ucomisd %xmm2, %xmm1
movapd %xmm2, %xmm1
ja 0x925d7
movq 0x18(%rsp), %r15
movsd %xmm0, (%r15,%rax,8)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%r15,%rcx,8)
movsd 0x50(%rsp), %xmm0
mulsd (%r15,%rax,8), %xmm0
movslq 0x2d8(%r14), %rax
jmp 0x929ed
movsd %xmm0, 0x38(%rsp)
movslq 0x2d0(%r14), %rax
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%r12,%rax,8)
movsd 0x308(%r14), %xmm0
movslq 0x2d4(%r14), %rax
movsd %xmm0, (%r12,%rax,8)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x1
popq %r9
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %r15
movq %r15, %rcx
xorl %r8d, %r8d
movapd %xmm1, %xmm0
callq 0x953b4
testl %eax, %eax
je 0x929c8
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52c26(%rip), %rsi     # 0xe53f0
leaq 0x7df8c(%rip), %rdx     # 0x11075d
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x52847(%rip), %rsi     # 0xe5034
leaq 0x7daca(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x5b3, %ecx            # imm = 0x5B3
jmp 0x92366
movq %r12, %rdi
callq 0x8430
movq 0x18(%rsp), %rdi
callq 0x8430
movq 0x20(%rsp), %rdi
callq 0x8430
leaq 0x7dbd7(%rip), %rsi     # 0x1103fb
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x2e014
leaq 0x52d45(%rip), %rsi     # 0xe5585
leaq 0x890(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x527d1(%rip), %rsi     # 0xe5034
leaq 0x7da54(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x5bc, %ecx            # imm = 0x5BC
jmp 0x92b4e
leaq 0x7dc53(%rip), %rsi     # 0x1104d1
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x2e014
leaq 0x527e8(%rip), %rsi     # 0xe5082
leaq 0x7dd09(%rip), %rdx     # 0x1105aa
leaq 0x890(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52770(%rip), %rsi     # 0xe5034
leaq 0x7d9f3(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x555, %ecx            # imm = 0x555
movq %r15, %r8
jmp 0x929a5
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52b07(%rip), %rsi     # 0xe53f0
leaq 0x7dced(%rip), %rdx     # 0x1105dd
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x52728(%rip), %rsi     # 0xe5034
leaq 0x7d9ab(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x56a, %ecx            # imm = 0x56A
jmp 0x929a2
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52ac2(%rip), %rsi     # 0xe53f0
leaq 0x7dd33(%rip), %rdx     # 0x110668
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x526e3(%rip), %rsi     # 0xe5034
leaq 0x7d966(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x57d, %ecx            # imm = 0x57D
jmp 0x929a2
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52a80(%rip), %rsi     # 0xe53f0
leaq 0x7dd7b(%rip), %rdx     # 0x1106f2
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x526a1(%rip), %rsi     # 0xe5034
leaq 0x7d924(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x592, %ecx            # imm = 0x592
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
movq %r12, %rdi
callq 0x8430
movq 0x18(%rsp), %rdi
callq 0x8430
movq 0x20(%rsp), %rdi
jmp 0x92385
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movq 0x18(%rsp), %r15
movsd %xmm0, (%r15,%rax,8)
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
cmpw $0x2, 0x328(%r14)
jl 0x92a0f
leaq 0x7f790(%rip), %rdi     # 0x112195
callq 0x8540
movq 0x18(%rsp), %r15
movl 0x218(%r14), %edx
cmpl $0x1, %edx
je 0x92a7f
testl %edx, %edx
jne 0x92afc
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x95f3b
cmpl $0x1, %eax
jne 0x92b5d
addq $0x32a, %r14            # imm = 0x32A
leaq 0x529a5(%rip), %rsi     # 0xe53f0
leaq 0x7dd6e(%rip), %rdx     # 0x1107c0
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x525c6(%rip), %rsi     # 0xe5034
leaq 0x7d849(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x5ce, %ecx            # imm = 0x5CE
jmp 0x92ad8
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x962e4
testl %eax, %eax
je 0x92b5d
addq $0x32a, %r14            # imm = 0x32A
leaq 0x5294a(%rip), %rsi     # 0xe53f0
leaq 0x7dd46(%rip), %rdx     # 0x1107f3
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x5256b(%rip), %rsi     # 0xe5034
leaq 0x7d7ee(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x5d8, %ecx            # imm = 0x5D8
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
movq %r12, %rdi
callq 0x8430
movq %r15, %rdi
callq 0x8430
movq 0x20(%rsp), %rdi
jmp 0x924c7
leaq 0x7dd2c(%rip), %rsi     # 0x11082f
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x52a69(%rip), %rsi     # 0xe5585
leaq 0x890(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %r14            # imm = 0x32A
leaq 0x524f5(%rip), %rsi     # 0xe5034
leaq 0x7d778(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x5db, %ecx            # imm = 0x5DB
movq %r15, %r8
xorl %eax, %eax
callq 0x2e014
jmp 0x92230
movslq 0x2d0(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
movslq 0x2d4(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x92b91
cmpl $0x2, %eax
jne 0x92ba4
movslq 0x2d8(%r14), %rax
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %r15
movq %r15, %rcx
xorl %r8d, %r8d
movsd 0x38(%rsp), %xmm0
xorl %r9d, %r9d
callq 0x953b4
testl %eax, %eax
je 0x92c1b
addq $0x32a, %r14            # imm = 0x32A
leaq 0x5280c(%rip), %rsi     # 0xe53f0
leaq 0x7dc78(%rip), %rdx     # 0x110863
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x5242d(%rip), %rsi     # 0xe5034
leaq 0x7d6b0(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x5f1, %ecx            # imm = 0x5F1
jmp 0x924a8
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, 0x310(%r14)
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movsd 0x48(%rsp), %xmm0
xorl %r9d, %r9d
callq 0x953b4
testl %eax, %eax
je 0x92ca3
addq $0x32a, %r14            # imm = 0x32A
leaq 0x52784(%rip), %rsi     # 0xe53f0
leaq 0x7dc52(%rip), %rdx     # 0x1108c5
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x523a5(%rip), %rsi     # 0xe5034
leaq 0x7d628(%rip), %rdx     # 0x1102be
movq %r14, %rdi
movl $0x600, %ecx            # imm = 0x600
jmp 0x924a8
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm1
movsd %xmm1, 0x318(%r14)
cmpw $0x2, 0x328(%r14)
jl 0x92cdb
movsd 0x310(%r14), %xmm0
leaq 0x7dc53(%rip), %rdi     # 0x110927
movb $0x2, %al
callq 0x8030
movq %r12, %rdi
callq 0x8430
movq 0x18(%rsp), %rdi
callq 0x8430
movq %r15, %rdi
callq 0x8430
xorl %ebp, %ebp
jmp 0x92230