// File: /workspace/github_c_makefile_star2_O1/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 $0x1088, %rsp           # imm = 0x1088
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x300(%rsi), %rbp
movq %rbp, %r15
shlq $0x3, %r15
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x99ca5
movq %rax, %r12
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x99cee
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x99d34
movq %rax, %r15
cmpl $0x4, 0x18(%r14)
jne 0x99d9b
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x9b99a
testl %eax, %eax
je 0x99da6
addq $0x32a, %r14            # imm = 0x32A
leaq 0x57782(%rip), %rsi     # 0xf13f0
leaq 0x8278e(%rip), %rdx     # 0x11c403
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x573a3(%rip), %rsi     # 0xf1034
leaq 0x82746(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x4c0, %ecx            # imm = 0x4C0
jmp 0x99d78
leal (,%rbp,8), %ecx
leaq 0x57351(%rip), %rsi     # 0xf1004
leaq 0x5a754(%rip), %rdx     # 0xf440e
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x5735a(%rip), %rsi     # 0xf1034
leaq 0x826fd(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x4b7, %ecx            # imm = 0x4B7
jmp 0x99d78
leal (,%rbp,8), %ecx
leaq 0x57308(%rip), %rsi     # 0xf1004
leaq 0x6037c(%rip), %rdx     # 0xfa07f
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x57311(%rip), %rsi     # 0xf1034
leaq 0x826b4(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x4b8, %ecx            # imm = 0x4B8
jmp 0x99d78
leal (,%rbp,8), %ecx
leaq 0x572c2(%rip), %rsi     # 0xf1004
leaq 0x7fcf4(%rip), %rdx     # 0x119a3d
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x572cb(%rip), %rsi     # 0xf1034
leaq 0x8266e(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x4b9, %ecx            # imm = 0x4B9
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebp
movl %ebp, %eax
addq $0x1088, %rsp           # imm = 0x1088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x308(%r14)
movl 0x18(%r14), %ebp
cmpl $0x4, %ebp
je 0x99dc1
cmpl $0x3, %ebp
je 0x99e4f
cmpl $0x2, %ebp
jne 0x9a024
cmpw $0x2, 0x328(%r14)
jl 0x99dd8
leaq 0x8449c(%rip), %rdi     # 0x11e26f
callq 0x8510
movsd 0x308(%r14), %xmm0
movsd 0x6b8(%r13), %xmm1
leaq 0x30(%rsp), %r8
leaq 0x58(%rsp), %r9
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x9c9c7
testl %eax, %eax
je 0x99ee1
addq $0x32a, %r14            # imm = 0x32A
leaq 0x575d5(%rip), %rsi     # 0xf13f0
leaq 0x82613(%rip), %rdx     # 0x11c435
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x571f6(%rip), %rsi     # 0xf1034
leaq 0x82599(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x4f0, %ecx            # imm = 0x4F0
jmp 0x99eb8
movsd 0x308(%r14), %xmm0
leaq 0x30(%rsp), %rsi
leaq 0x78(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x68(%rsp), %r8
movq %r14, %rdi
callq 0x9ce10
testl %eax, %eax
je 0x99ee1
addq $0x32a, %r14            # imm = 0x32A
leaq 0x5756a(%rip), %rsi     # 0xf13f0
leaq 0x8263b(%rip), %rdx     # 0x11c4c8
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x5718b(%rip), %rsi     # 0xf1034
leaq 0x8252e(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x500, %ecx            # imm = 0x500
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq %r15, %rdi
callq 0x8410
jmp 0x99d82
movsd (%r14), %xmm0
divsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
cmpw $0x2, 0x328(%r14)
jl 0x99f14
movsd 0x308(%r14), %xmm0
leaq 0x82652(%rip), %rdi     # 0x11c55f
movb $0x1, %al
callq 0x8030
movq 0x298(%r14), %rax
movslq 0x290(%r14), %rcx
movsd -0x8(%rax,%rcx,8), %xmm0
callq 0x8670
movsd %xmm0, 0x38(%rsp)
divsd 0x690(%r13), %xmm0
movslq 0x2d0(%r14), %rax
movsd 0x18(%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 0x99f73
cmpl $0x2, %eax
jne 0x99f8c
movsd 0x58(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
movslq 0x2d8(%r14), %rax
movsd %xmm1, (%r12,%rax,8)
movl $0x1, %ebp
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
pushq $0x0
pushq $0x1
callq 0x9cf0c
addq $0x10, %rsp
testl %eax, %eax
je 0x9a09a
addq $0x32a, %r14            # imm = 0x32A
leaq 0x57427(%rip), %rsi     # 0xf13f0
leaq 0x825bf(%rip), %rdx     # 0x11c58f
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x57048(%rip), %rsi     # 0xf1034
leaq 0x823eb(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x529, %ecx            # imm = 0x529
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq %r15, %rdi
callq 0x8410
jmp 0x99d87
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq %r15, %rdi
callq 0x8410
leaq 0x824d6(%rip), %rsi     # 0x11c51b
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x30c2c
leaq 0x57525(%rip), %rsi     # 0xf1585
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56fb1(%rip), %rsi     # 0xf1034
leaq 0x82354(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x505, %ecx            # imm = 0x505
movq %r15, %r8
jmp 0x99d7b
movq %r15, 0x10(%rsp)
cmpw $0x2, 0x328(%r14)
jl 0x9a0b6
leaq 0x841db(%rip), %rdi     # 0x11e28c
callq 0x8510
movq 0x298(%r14), %rax
movsd (%rax), %xmm0
callq 0x8670
movapd %xmm0, %xmm1
divsd 0x688(%r13), %xmm1
movl 0x18(%r14), %r15d
cmpl $0x4, %r15d
je 0x9a0f1
cmpl $0x3, %r15d
je 0x9a2b4
cmpl $0x2, %r15d
jne 0x9a35b
movsd %xmm0, 0x28(%rsp)
movslq 0x2d0(%r14), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%r12,%rax,8)
movsd 0x308(%r14), %xmm0
movslq 0x2d4(%r14), %rax
movsd %xmm0, (%r12,%rax,8)
movl $0x1, %r15d
movsd %xmm1, 0x48(%rsp)
cmpl 0x698(%r13), %r15d
jge 0x9a3d1
movsd 0x6d8(%r13), %xmm0
mulsd %xmm1, %xmm0
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
xorl %eax, %eax
pushq %rax
pushq %rax
callq 0x9cf0c
addq $0x10, %rsp
testl %eax, %eax
jne 0x9a435
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd 0x6c0(%r13), %xmm1
movq %r14, %rdi
movq %r13, %rsi
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdx
movq 0x10(%rsp), %rcx
leaq 0x60(%rsp), %r8
leaq 0x50(%rsp), %r9
callq 0x9c9c7
testl %eax, %eax
jne 0x9a47a
movslq 0x2d0(%r14), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%r12,%rax,8)
movslq 0x2d4(%r14), %rcx
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%r12,%rcx,8)
movsd 0x50(%rsp), %xmm1
movsd (%r12,%rax,8), %xmm0
movsd %xmm1, 0x40(%rsp)
mulsd %xmm1, %xmm0
movslq 0x2d8(%r14), %rax
movsd %xmm0, (%r12,%rax,8)
movsd 0x308(%r14), %xmm0
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq $0x1
callq 0x9cf0c
addq $0x10, %rsp
testl %eax, %eax
jne 0x9a4bc
movslq 0x2d0(%r14), %rax
movsd 0x18(%rsp), %xmm0
divsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
movslq 0x2d4(%r14), %rdx
movsd 0x20(%rsp), %xmm1
movsd %xmm1, (%r12,%rdx,8)
movsd 0x60(%rsp), %xmm1
mulsd %xmm0, %xmm1
incl %r15d
movsd 0x48(%rsp), %xmm2
ucomisd %xmm2, %xmm1
movapd %xmm2, %xmm1
ja 0x9a12c
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movsd 0x40(%rsp), %xmm0
mulsd (%rcx,%rax,8), %xmm0
movslq 0x2d8(%r14), %rax
movq 0x10(%rsp), %r15
jmp 0x9a546
movsd %xmm0, 0x28(%rsp)
movslq 0x2d0(%r14), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%r12,%rax,8)
movsd 0x308(%r14), %xmm0
movslq 0x2d4(%r14), %rax
movsd %xmm0, (%r12,%rax,8)
xorl %eax, %eax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %r15
movq %r15, %rcx
xorl %r8d, %r8d
movapd %xmm1, %xmm0
movl $0x1, %r9d
pushq %rax
pushq %rax
callq 0x9cf0c
addq $0x10, %rsp
testl %eax, %eax
je 0x9a522
addq $0x32a, %r14            # imm = 0x32A
leaq 0x570cc(%rip), %rsi     # 0xf13f0
leaq 0x82552(%rip), %rdx     # 0x11c87d
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56ced(%rip), %rsi     # 0xf1034
leaq 0x82090(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x5b3, %ecx            # imm = 0x5B3
jmp 0x99eb8
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
callq 0x8410
leaq 0x8219d(%rip), %rsi     # 0x11c51b
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x30c2c
leaq 0x571eb(%rip), %rsi     # 0xf1585
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56c77(%rip), %rsi     # 0xf1034
leaq 0x8201a(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x5bc, %ecx            # imm = 0x5BC
jmp 0x9a69c
leaq 0x82219(%rip), %rsi     # 0x11c5f1
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56c8e(%rip), %rsi     # 0xf1082
leaq 0x822cf(%rip), %rdx     # 0x11c6ca
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56c16(%rip), %rsi     # 0xf1034
leaq 0x81fb9(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x555, %ecx            # imm = 0x555
movq %r15, %r8
jmp 0x9a4ff
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56fad(%rip), %rsi     # 0xf13f0
leaq 0x822b3(%rip), %rdx     # 0x11c6fd
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56bce(%rip), %rsi     # 0xf1034
leaq 0x81f71(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x56a, %ecx            # imm = 0x56A
jmp 0x9a4fc
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56f68(%rip), %rsi     # 0xf13f0
leaq 0x822f9(%rip), %rdx     # 0x11c788
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56b89(%rip), %rsi     # 0xf1034
leaq 0x81f2c(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x57d, %ecx            # imm = 0x57D
jmp 0x9a4fc
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56f26(%rip), %rsi     # 0xf13f0
leaq 0x82341(%rip), %rdx     # 0x11c812
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56b47(%rip), %rsi     # 0xf1034
leaq 0x81eea(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x592, %ecx            # imm = 0x592
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
jmp 0x99ed7
movslq 0x2d0(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
cmpw $0x2, 0x328(%r14)
jl 0x9a567
leaq 0x83d58(%rip), %rdi     # 0x11e2b5
callq 0x8510
movq 0x8(%rsp), %rcx
movl 0x218(%r14), %edx
cmpl $0x1, %edx
je 0x9a5d7
testl %edx, %edx
jne 0x9a64a
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rcx, %rbx
callq 0x9dae2
cmpl $0x1, %eax
jne 0x9a6ab
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56e4d(%rip), %rsi     # 0xf13f0
leaq 0x82336(%rip), %rdx     # 0x11c8e0
leaq 0x80(%rsp), %r13
movq %r13, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56a6e(%rip), %rsi     # 0xf1034
leaq 0x81e11(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x5ce, %ecx            # imm = 0x5CE
jmp 0x9a630
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rcx, %rbx
callq 0x9dedc
testl %eax, %eax
je 0x9a6ab
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56df2(%rip), %rsi     # 0xf13f0
leaq 0x8230e(%rip), %rdx     # 0x11c913
leaq 0x80(%rsp), %r13
movq %r13, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56a13(%rip), %rsi     # 0xf1034
leaq 0x81db6(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x5d8, %ecx            # imm = 0x5D8
movq %r13, %r8
xorl %eax, %eax
callq 0x30c2c
movq %r12, %rdi
callq 0x8410
movq %rbx, %rdi
jmp 0x9a012
leaq 0x822fe(%rip), %rsi     # 0x11c94f
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x56f1b(%rip), %rsi     # 0xf1585
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %r14            # imm = 0x32A
leaq 0x569a7(%rip), %rsi     # 0xf1034
leaq 0x81d4a(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x5db, %ecx            # imm = 0x5DB
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
jmp 0x99d87
movslq 0x2d0(%r14), %rax
movsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
movslq 0x2d4(%r14), %rax
movsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
movl 0x18(%r14), %eax
cmpl $0x4, %eax
je 0x9a6dd
cmpl $0x2, %eax
jne 0x9a6ef
movslq 0x2d8(%r14), %rax
movsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movsd 0x28(%rsp), %xmm0
xorl %r9d, %r9d
pushq $0x0
pushq $0x1
callq 0x9cf0c
addq $0x10, %rsp
testl %eax, %eax
je 0x9a75d
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56cca(%rip), %rsi     # 0xf13f0
leaq 0x82256(%rip), %rdx     # 0x11c983
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x568eb(%rip), %rsi     # 0xf1034
leaq 0x81c8e(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x5f1, %ecx            # imm = 0x5F1
jmp 0x99ffb
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, 0x310(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movsd 0x38(%rsp), %xmm0
xorl %r9d, %r9d
pushq $0x0
pushq $0x1
callq 0x9cf0c
addq $0x10, %rsp
testl %eax, %eax
je 0x9a7e1
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56c46(%rip), %rsi     # 0xf13f0
leaq 0x82234(%rip), %rdx     # 0x11c9e5
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x56867(%rip), %rsi     # 0xf1034
leaq 0x81c0a(%rip), %rdx     # 0x11c3de
movq %r14, %rdi
movl $0x600, %ecx            # imm = 0x600
jmp 0x99ffb
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm1
movsd %xmm1, 0x318(%r14)
cmpw $0x2, 0x328(%r14)
jl 0x9a819
movsd 0x310(%r14), %xmm0
leaq 0x82235(%rip), %rdi     # 0x11ca47
movb $0x2, %al
callq 0x8030
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq %r15, %rdi
callq 0x8410
xorl %ebp, %ebp
jmp 0x99d87