// File: /workspace/github_c_makefile_star2_O3/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 0x96ea4
movq %rax, %r12
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x96eed
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0x8460
testq %rax, %rax
je 0x96f33
movq %rax, %r15
movl 0x18(%r14), %ebp
cmpl $0x4, %ebp
jne 0x96f9a
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x98ba9
testl %eax, %eax
je 0x96fa7
addq $0x32a, %r14            # imm = 0x32A
leaq 0x57583(%rip), %rsi     # 0xee3f0
leaq 0x825cf(%rip), %rdx     # 0x119443
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x571a4(%rip), %rsi     # 0xee034
leaq 0x82587(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x4c0, %ecx            # imm = 0x4C0
jmp 0x96f77
leal (,%rbp,8), %ecx
leaq 0x57152(%rip), %rsi     # 0xee004
leaq 0x5a565(%rip), %rdx     # 0xf141e
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x5715b(%rip), %rsi     # 0xee034
leaq 0x8253e(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x4b7, %ecx            # imm = 0x4B7
jmp 0x96f77
leal (,%rbp,8), %ecx
leaq 0x57109(%rip), %rsi     # 0xee004
leaq 0x601a5(%rip), %rdx     # 0xf70a7
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x57112(%rip), %rsi     # 0xee034
leaq 0x824f5(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x4b8, %ecx            # imm = 0x4B8
jmp 0x96f77
leal (,%rbp,8), %ecx
leaq 0x570c3(%rip), %rsi     # 0xee004
leaq 0x7fb35(%rip), %rdx     # 0x116a7d
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x570cc(%rip), %rsi     # 0xee034
leaq 0x824af(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x4b9, %ecx            # imm = 0x4B9
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
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)
jmp 0x96fab
movl 0x18(%r14), %ebp
cmpl $0x4, %ebp
je 0x96fc2
cmpl $0x3, %ebp
je 0x97050
cmpl $0x2, %ebp
jne 0x97225
cmpw $0x2, 0x328(%r14)
jl 0x96fd9
leaq 0x842db(%rip), %rdi     # 0x11b2af
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 0x99be6
testl %eax, %eax
je 0x970e2
addq $0x32a, %r14            # imm = 0x32A
leaq 0x573d4(%rip), %rsi     # 0xee3f0
leaq 0x82452(%rip), %rdx     # 0x119475
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56ff5(%rip), %rsi     # 0xee034
leaq 0x823d8(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x4f0, %ecx            # imm = 0x4F0
jmp 0x970b9
movsd 0x308(%r14), %xmm0
leaq 0x30(%rsp), %rsi
leaq 0x78(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x68(%rsp), %r8
movq %r14, %rdi
callq 0x9a02a
testl %eax, %eax
je 0x970e2
addq $0x32a, %r14            # imm = 0x32A
leaq 0x57369(%rip), %rsi     # 0xee3f0
leaq 0x8247a(%rip), %rdx     # 0x119508
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56f8a(%rip), %rsi     # 0xee034
leaq 0x8236d(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x500, %ecx            # imm = 0x500
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq %r15, %rdi
callq 0x8410
jmp 0x96f81
movsd (%r14), %xmm0
divsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
cmpw $0x2, 0x328(%r14)
jl 0x97115
movsd 0x308(%r14), %xmm0
leaq 0x82491(%rip), %rdi     # 0x11959f
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 0x97174
cmpl $0x2, %eax
jne 0x9718d
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 0x9a126
addq $0x10, %rsp
testl %eax, %eax
je 0x9729b
addq $0x32a, %r14            # imm = 0x32A
leaq 0x57226(%rip), %rsi     # 0xee3f0
leaq 0x823fe(%rip), %rdx     # 0x1195cf
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56e47(%rip), %rsi     # 0xee034
leaq 0x8222a(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x529, %ecx            # imm = 0x529
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq %r15, %rdi
callq 0x8410
jmp 0x96f86
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq %r15, %rdi
callq 0x8410
leaq 0x82315(%rip), %rsi     # 0x11955b
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x30af0
leaq 0x57324(%rip), %rsi     # 0xee585
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56db0(%rip), %rsi     # 0xee034
leaq 0x82193(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x505, %ecx            # imm = 0x505
movq %r15, %r8
jmp 0x96f7a
movq %r15, 0x10(%rsp)
cmpw $0x2, 0x328(%r14)
jl 0x972b7
leaq 0x8401a(%rip), %rdi     # 0x11b2cc
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 0x972f2
cmpl $0x3, %r15d
je 0x974b5
cmpl $0x2, %r15d
jne 0x9755c
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 0x975d2
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 0x9a126
addq $0x10, %rsp
testl %eax, %eax
jne 0x97636
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 0x99be6
testl %eax, %eax
jne 0x9767b
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 0x9a126
addq $0x10, %rsp
testl %eax, %eax
jne 0x976bd
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 0x9732d
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 0x97747
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 0x9a126
addq $0x10, %rsp
testl %eax, %eax
je 0x97723
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56ecb(%rip), %rsi     # 0xee3f0
leaq 0x82391(%rip), %rdx     # 0x1198bd
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56aec(%rip), %rsi     # 0xee034
leaq 0x81ecf(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x5b3, %ecx            # imm = 0x5B3
jmp 0x970b9
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
callq 0x8410
leaq 0x81fdc(%rip), %rsi     # 0x11955b
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x30af0
leaq 0x56fea(%rip), %rsi     # 0xee585
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56a76(%rip), %rsi     # 0xee034
leaq 0x81e59(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x5bc, %ecx            # imm = 0x5BC
jmp 0x9789d
leaq 0x82058(%rip), %rsi     # 0x119631
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x30af0
leaq 0x56a8d(%rip), %rsi     # 0xee082
leaq 0x8210e(%rip), %rdx     # 0x11970a
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56a15(%rip), %rsi     # 0xee034
leaq 0x81df8(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x555, %ecx            # imm = 0x555
movq %r15, %r8
jmp 0x97700
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56dac(%rip), %rsi     # 0xee3f0
leaq 0x820f2(%rip), %rdx     # 0x11973d
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x569cd(%rip), %rsi     # 0xee034
leaq 0x81db0(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x56a, %ecx            # imm = 0x56A
jmp 0x976fd
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56d67(%rip), %rsi     # 0xee3f0
leaq 0x82138(%rip), %rdx     # 0x1197c8
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56988(%rip), %rsi     # 0xee034
leaq 0x81d6b(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x57d, %ecx            # imm = 0x57D
jmp 0x976fd
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56d25(%rip), %rsi     # 0xee3f0
leaq 0x82180(%rip), %rdx     # 0x119852
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56946(%rip), %rsi     # 0xee034
leaq 0x81d29(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x592, %ecx            # imm = 0x592
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movq %r12, %rdi
callq 0x8410
movq 0x8(%rsp), %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
jmp 0x970d8
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 0x97768
leaq 0x83b97(%rip), %rdi     # 0x11b2f5
callq 0x8510
movq 0x8(%rsp), %rcx
movl 0x218(%r14), %edx
cmpl $0x1, %edx
je 0x977d8
testl %edx, %edx
jne 0x9784b
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rcx, %rbx
callq 0x9acbf
cmpl $0x1, %eax
jne 0x978ac
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56c4c(%rip), %rsi     # 0xee3f0
leaq 0x82175(%rip), %rdx     # 0x119920
leaq 0x80(%rsp), %r13
movq %r13, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x5686d(%rip), %rsi     # 0xee034
leaq 0x81c50(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x5ce, %ecx            # imm = 0x5CE
jmp 0x97831
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rcx, %rbx
callq 0x9b081
testl %eax, %eax
je 0x978ac
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56bf1(%rip), %rsi     # 0xee3f0
leaq 0x8214d(%rip), %rdx     # 0x119953
leaq 0x80(%rsp), %r13
movq %r13, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56812(%rip), %rsi     # 0xee034
leaq 0x81bf5(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x5d8, %ecx            # imm = 0x5D8
movq %r13, %r8
xorl %eax, %eax
callq 0x30af0
movq %r12, %rdi
callq 0x8410
movq %rbx, %rdi
jmp 0x97213
leaq 0x8213d(%rip), %rsi     # 0x11998f
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x56d1a(%rip), %rsi     # 0xee585
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %r14            # imm = 0x32A
leaq 0x567a6(%rip), %rsi     # 0xee034
leaq 0x81b89(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x5db, %ecx            # imm = 0x5DB
movq %r15, %r8
xorl %eax, %eax
callq 0x30af0
jmp 0x96f86
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 0x978de
cmpl $0x2, %eax
jne 0x978f0
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 0x9a126
addq $0x10, %rsp
testl %eax, %eax
je 0x9795e
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56ac9(%rip), %rsi     # 0xee3f0
leaq 0x82095(%rip), %rdx     # 0x1199c3
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x566ea(%rip), %rsi     # 0xee034
leaq 0x81acd(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x5f1, %ecx            # imm = 0x5F1
jmp 0x971fc
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 0x9a126
addq $0x10, %rsp
testl %eax, %eax
je 0x979e2
addq $0x32a, %r14            # imm = 0x32A
leaq 0x56a45(%rip), %rsi     # 0xee3f0
leaq 0x82073(%rip), %rdx     # 0x119a25
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x56666(%rip), %rsi     # 0xee034
leaq 0x81a49(%rip), %rdx     # 0x11941e
movq %r14, %rdi
movl $0x600, %ecx            # imm = 0x600
jmp 0x971fc
movslq 0x2d4(%r14), %rax
movsd (%r12,%rax,8), %xmm1
movsd %xmm1, 0x318(%r14)
cmpw $0x2, 0x328(%r14)
jl 0x97a1a
movsd 0x310(%r14), %xmm0
leaq 0x82074(%rip), %rdi     # 0x119a87
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 0x96f86