// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xb8f8, %rsp           # imm = 0xB8F8
movq %rdi, 0xb8e8(%rsp)
movq %rsi, 0xb8e0(%rsp)
movq %rdx, 0xb8d8(%rsp)
movq 0xb8e0(%rsp), %rax
movslq 0x300(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xb8d0(%rsp)
cmpq $0x0, 0xb8d0(%rsp)
jne 0x116339
movq 0xb8e0(%rsp), %rax
movslq 0x300(%rax), %rax
shlq $0x3, %rax
movl %eax, 0xb844(%rsp)
leaq 0xb040(%rsp), %rdi
movl 0xb844(%rsp), %ecx
leaq 0xbbd1a(%rip), %rsi     # 0x1d2004
leaq 0xbf135(%rip), %rdx     # 0x1d5426
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xb040(%rsp), %r8
leaq 0xbbd1e(%rip), %rsi     # 0x1d2034
leaq 0xe7384(%rip), %rdx     # 0x1fd6a1
movl $0x4b7, %ecx            # imm = 0x4B7
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8e0(%rsp), %rax
movslq 0x300(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xb8c8(%rsp)
cmpq $0x0, 0xb8c8(%rsp)
jne 0x1163e3
movq 0xb8e0(%rsp), %rax
movslq 0x300(%rax), %rax
shlq $0x3, %rax
movl %eax, 0xb03c(%rsp)
leaq 0xa830(%rsp), %rdi
movl 0xb03c(%rsp), %ecx
leaq 0xbbc70(%rip), %rsi     # 0x1d2004
leaq 0xc4a3d(%rip), %rdx     # 0x1dadd8
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xa830(%rsp), %r8
leaq 0xbbc74(%rip), %rsi     # 0x1d2034
leaq 0xe72da(%rip), %rdx     # 0x1fd6a1
movl $0x4b8, %ecx            # imm = 0x4B8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8e0(%rsp), %rax
movslq 0x300(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xb8c0(%rsp)
cmpq $0x0, 0xb8c0(%rsp)
jne 0x11648d
movq 0xb8e0(%rsp), %rax
movslq 0x300(%rax), %rax
shlq $0x3, %rax
movl %eax, 0xa82c(%rsp)
leaq 0xa020(%rsp), %rdi
movl 0xa82c(%rsp), %ecx
leaq 0xbbbc6(%rip), %rsi     # 0x1d2004
leaq 0xe4670(%rip), %rdx     # 0x1faab5
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xa020(%rsp), %r8
leaq 0xbbbca(%rip), %rsi     # 0x1d2034
leaq 0xe7230(%rip), %rdx     # 0x1fd6a1
movl $0x4b9, %ecx            # imm = 0x4B9
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8e0(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x116538
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
callq 0x119780
cmpl $0x1, %eax
jne 0x116536
leaq 0x9820(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbbef1(%rip), %rsi     # 0x1d23d8
leaq 0xe71d8(%rip), %rdx     # 0x1fd6c6
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x9820(%rsp), %r8
leaq 0xbbb21(%rip), %rsi     # 0x1d2034
leaq 0xe7187(%rip), %rdx     # 0x1fd6a1
movl $0x4c0, %ecx            # imm = 0x4C0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
jmp 0x11654b
movq 0xb8e0(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x308(%rax)
movq 0xb8e0(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x2, %eax
je 0x11657f
jmp 0x116561
movl 0x1c(%rsp), %eax
subl $0x3, %eax
je 0x116698
jmp 0x116570
movl 0x1c(%rsp), %eax
subl $0x4, %eax
jne 0x116777
jmp 0x11657f
movq 0xb8e0(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x1, %eax
jle 0x1165a1
leaq 0xe715e(%rip), %rdi     # 0x1fd6f8
movb $0x0, %al
callq 0x8030
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8e0(%rsp), %rax
movsd 0x308(%rax), %xmm0
movq 0xb8d8(%rsp), %rax
movsd 0x6b8(%rax), %xmm1
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
leaq 0xb8a8(%rsp), %r8
leaq 0xb890(%rsp), %r9
callq 0x11b7f0
cmpl $0x1, %eax
jne 0x116693
leaq 0x9020(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbbdbb(%rip), %rsi     # 0x1d23d8
leaq 0xe70f2(%rip), %rdx     # 0x1fd716
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x9020(%rsp), %r8
leaq 0xbb9eb(%rip), %rsi     # 0x1d2034
leaq 0xe7051(%rip), %rdx     # 0x1fd6a1
movl $0x4f0, %ecx            # imm = 0x4F0
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
jmp 0x11681e
movq 0xb8e0(%rsp), %rdi
movq 0xb8e0(%rsp), %rax
movsd 0x308(%rax), %xmm0
leaq 0xb8a8(%rsp), %rsi
leaq 0xb858(%rsp), %rdx
leaq 0xb850(%rsp), %rcx
leaq 0xb848(%rsp), %r8
callq 0x11be30
cmpl $0x1, %eax
jne 0x116772
leaq 0x8820(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbbcdc(%rip), %rsi     # 0x1d23d8
leaq 0xe70a6(%rip), %rdx     # 0x1fd7a9
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x8820(%rsp), %r8
leaq 0xbb90c(%rip), %rsi     # 0x1d2034
leaq 0xe6f72(%rip), %rdx     # 0x1fd6a1
movl $0x500, %ecx            # imm = 0x500
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
jmp 0x11681e
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
leaq 0x8020(%rsp), %rdi
movq 0xb8e0(%rsp), %rax
movl 0x18(%rax), %edx
leaq 0xe7044(%rip), %rsi     # 0x1fd7fc
movb $0x0, %al
callq 0x5b9c0
leaq 0x7820(%rsp), %rdi
leaq 0x8020(%rsp), %rdx
leaq 0xbbd97(%rip), %rsi     # 0x1d256d
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x7820(%rsp), %r8
leaq 0xbb839(%rip), %rsi     # 0x1d2034
leaq 0xe6e9f(%rip), %rdx     # 0x1fd6a1
movl $0x505, %ecx            # imm = 0x505
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8e0(%rsp), %rax
movsd (%rax), %xmm0
divsd 0xb8a8(%rsp), %xmm0
movsd %xmm0, 0xb8b8(%rsp)
movq 0xb8e0(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x1, %eax
jle 0x11686e
movq 0xb8e0(%rsp), %rax
movsd 0x308(%rax), %xmm0
leaq 0xe6fd9(%rip), %rdi     # 0x1fd840
movb $0x1, %al
callq 0x8030
movq 0xb8e0(%rsp), %rax
movq 0x298(%rax), %rax
movq 0xb8e0(%rsp), %rcx
movl 0x290(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movsd %xmm0, 0xb870(%rsp)
movsd 0xb870(%rsp), %xmm0
movq 0xb8d8(%rsp), %rax
divsd 0x690(%rax), %xmm0
movsd %xmm0, 0xb878(%rsp)
movsd 0xb8b8(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rax
movsd 0x308(%rax), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x116933
movq 0xb8e0(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x116961
movsd 0xb8b8(%rsp), %xmm0
mulsd 0xb890(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
movsd 0xb878(%rsp), %xmm0
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x11c060
cmpl $0x1, %eax
jne 0x116a44
leaq 0x7020(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbba0a(%rip), %rsi     # 0x1d23d8
leaq 0xe6e9b(%rip), %rdx     # 0x1fd870
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x7020(%rsp), %r8
leaq 0xbb63a(%rip), %rsi     # 0x1d2034
leaq 0xe6ca0(%rip), %rdx     # 0x1fd6a1
movl $0x529, %ecx            # imm = 0x529
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8e0(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x1, %eax
jle 0x116a66
leaq 0xe6e73(%rip), %rdi     # 0x1fd8d2
movb $0x0, %al
callq 0x8030
movq 0xb8e0(%rsp), %rax
movq 0x298(%rax), %rax
movsd (%rax), %xmm0
callq 0x8670
movsd %xmm0, 0xb868(%rsp)
movsd 0xb868(%rsp), %xmm0
movq 0xb8d8(%rsp), %rax
movsd 0x688(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0xb880(%rsp)
movq 0xb8e0(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x18(%rsp)
subl $0x2, %eax
je 0x116ae1
jmp 0x116ac3
movl 0x18(%rsp), %eax
subl $0x3, %eax
je 0x1170b5
jmp 0x116ad2
movl 0x18(%rsp), %eax
subl $0x4, %eax
jne 0x11725e
jmp 0x116ae1
movl $0x0, 0xb864(%rsp)
movsd 0xb8b8(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rax
movsd 0x308(%rax), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xb864(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb864(%rsp)
movl 0xb864(%rsp), %eax
movq 0xb8d8(%rsp), %rcx
cmpl 0x698(%rcx), %eax
jl 0x116c13
leaq 0x6820(%rsp), %rdi
movl 0xb864(%rsp), %edx
leaq 0xe6d7d(%rip), %rsi     # 0x1fd8fc
movb $0x0, %al
callq 0x5b9c0
leaq 0x6020(%rsp), %rdi
leaq 0x6820(%rsp), %rcx
leaq 0xbb4e5(%rip), %rsi     # 0x1d2082
leaq 0xe6e31(%rip), %rdx     # 0x1fd9d5
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x6020(%rsp), %r8
leaq 0xbb46b(%rip), %rsi     # 0x1d2034
leaq 0xe6ad1(%rip), %rdx     # 0x1fd6a1
movl $0x555, %ecx            # imm = 0x555
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
movsd 0xb880(%rsp), %xmm0
movq 0xb8d8(%rsp), %rax
mulsd 0x6d8(%rax), %xmm0
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x11c060
cmpl $0x1, %eax
jne 0x116d06
leaq 0x5820(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbb748(%rip), %rsi     # 0x1d23d8
leaq 0xe6d71(%rip), %rdx     # 0x1fda08
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x5820(%rsp), %r8
leaq 0xbb378(%rip), %rsi     # 0x1d2034
leaq 0xe69de(%rip), %rdx     # 0x1fd6a1
movl $0x56a, %ecx            # imm = 0x56A
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xb898(%rsp)
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movsd 0xb898(%rsp), %xmm0
movq 0xb8d8(%rsp), %rax
movsd 0x6c0(%rax), %xmm1
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
leaq 0xb8a0(%rsp), %r8
leaq 0xb888(%rsp), %r9
callq 0x11b7f0
cmpl $0x1, %eax
jne 0x116e16
leaq 0x5020(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbb638(%rip), %rsi     # 0x1d23d8
leaq 0xe6cec(%rip), %rdx     # 0x1fda93
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x5020(%rsp), %r8
leaq 0xbb268(%rip), %rsi     # 0x1d2034
leaq 0xe68ce(%rip), %rdx     # 0x1fd6a1
movl $0x57d, %ecx            # imm = 0x57D
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd 0xbb413(%rip), %xmm0    # 0x1d2248
movsd %xmm0, (%rax,%rcx,8)
movsd 0xb898(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0xb888(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
movq 0xb8e0(%rsp), %rax
movsd 0x308(%rax), %xmm0
movl $0x1, %r9d
xorl %eax, %eax
movl %r9d, %r8d
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x11c060
cmpl $0x1, %eax
jne 0x116f8c
leaq 0x4820(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbb4c2(%rip), %rsi     # 0x1d23d8
leaq 0xe6c00(%rip), %rdx     # 0x1fdb1d
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x4820(%rsp), %r8
leaq 0xbb0f2(%rip), %rsi     # 0x1d2034
leaq 0xe6758(%rip), %rdx     # 0x1fd6a1
movl $0x592, %ecx            # imm = 0x592
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movsd 0xb8b8(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xb8b0(%rsp)
movsd 0xb8b0(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd 0xb898(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd 0xb8b0(%rsp), %xmm0
mulsd 0xb8a0(%rsp), %xmm0
ucomisd 0xb880(%rsp), %xmm0
ja 0x116b3d
movsd 0xb8b0(%rsp), %xmm0
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd 0xb898(%rsp), %xmm0
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0xb888(%rsp), %xmm0
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x117305
movsd 0xb8b8(%rsp), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rax
movsd 0x308(%rax), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
movsd 0xb880(%rsp), %xmm0
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x11c060
cmpl $0x1, %eax
jne 0x1171e9
leaq 0x4020(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbb265(%rip), %rsi     # 0x1d23d8
leaq 0xe6a0e(%rip), %rdx     # 0x1fdb88
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x4020(%rsp), %r8
leaq 0xbae95(%rip), %rsi     # 0x1d2034
leaq 0xe64fb(%rip), %rdx     # 0x1fd6a1
movl $0x5b3, %ecx            # imm = 0x5B3
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x117305
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
leaq 0x3820(%rsp), %rdi
movq 0xb8e0(%rsp), %rax
movl 0x18(%rax), %edx
leaq 0xe655d(%rip), %rsi     # 0x1fd7fc
movb $0x0, %al
callq 0x5b9c0
leaq 0x3020(%rsp), %rdi
leaq 0x3820(%rsp), %rdx
leaq 0xbb2b0(%rip), %rsi     # 0x1d256d
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x3020(%rsp), %r8
leaq 0xbad52(%rip), %rsi     # 0x1d2034
leaq 0xe63b8(%rip), %rdx     # 0x1fd6a1
movl $0x5bc, %ecx            # imm = 0x5BC
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8e0(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x1, %eax
jle 0x117327
leaq 0xe68cb(%rip), %rdi     # 0x1fdbeb
movb $0x0, %al
callq 0x8030
movq 0xb8e0(%rsp), %rax
cmpl $0x0, 0x218(%rax)
jne 0x117403
movq 0xb8e8(%rsp), %rdi
movq 0xb8e0(%rsp), %rsi
movq 0xb8d8(%rsp), %rdx
movq 0xb8c8(%rsp), %rcx
callq 0x11d900
cmpl $0x1, %eax
jne 0x1173fe
leaq 0x2820(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbb050(%rip), %rsi     # 0x1d23d8
leaq 0xe6871(%rip), %rdx     # 0x1fdc00
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x2820(%rsp), %r8
leaq 0xbac80(%rip), %rsi     # 0x1d2034
leaq 0xe62e6(%rip), %rdx     # 0x1fd6a1
movl $0x5ce, %ecx            # imm = 0x5CE
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
jmp 0x117564
movq 0xb8e0(%rsp), %rax
cmpl $0x1, 0x218(%rax)
jne 0x1174df
movq 0xb8e8(%rsp), %rdi
movq 0xb8e0(%rsp), %rsi
movq 0xb8d8(%rsp), %rdx
movq 0xb8c8(%rsp), %rcx
callq 0x11db80
cmpl $0x1, %eax
jne 0x1174da
leaq 0x2020(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbaf74(%rip), %rsi     # 0x1d23d8
leaq 0xe67c8(%rip), %rdx     # 0x1fdc33
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x2020(%rsp), %r8
leaq 0xbaba4(%rip), %rsi     # 0x1d2034
leaq 0xe620a(%rip), %rdx     # 0x1fd6a1
movl $0x5d8, %ecx            # imm = 0x5D8
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
jmp 0x117562
leaq 0x1820(%rsp), %rdi
movq 0xb8e0(%rsp), %rax
movl 0x218(%rax), %edx
leaq 0xe6773(%rip), %rsi     # 0x1fdc6f
movb $0x0, %al
callq 0x5b9c0
leaq 0x1020(%rsp), %rdi
leaq 0x1820(%rsp), %rdx
leaq 0xbb053(%rip), %rsi     # 0x1d256d
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x1020(%rsp), %r8
leaq 0xbaaf5(%rip), %rsi     # 0x1d2034
leaq 0xe615b(%rip), %rdx     # 0x1fd6a1
movl $0x5db, %ecx            # imm = 0x5DB
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
jmp 0x117564
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d0(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x1175f0
movq 0xb8e0(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x117628
movq 0xb8c8(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d8(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
movsd 0xb868(%rsp), %xmm0
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x11c060
cmpl $0x1, %eax
jne 0x117708
leaq 0x820(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbad46(%rip), %rsi     # 0x1d23d8
leaq 0xe660a(%rip), %rdx     # 0x1fdca3
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x820(%rsp), %r8
leaq 0xba976(%rip), %rsi     # 0x1d2034
leaq 0xe5fdc(%rip), %rdx     # 0x1fd6a1
movl $0x5f1, %ecx            # imm = 0x5F1
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb8e0(%rsp), %rax
movsd %xmm0, 0x310(%rax)
movq 0xb8e0(%rsp), %rdi
movq 0xb8d8(%rsp), %rsi
movq 0xb8d0(%rsp), %rdx
movq 0xb8c0(%rsp), %rcx
movsd 0xb870(%rsp), %xmm0
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x11c060
cmpl $0x1, %eax
jne 0x11780e
leaq 0x20(%rsp), %rdi
movq 0xb8e0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbac3d(%rip), %rsi     # 0x1d23d8
leaq 0xe6563(%rip), %rdx     # 0x1fdd05
movb $0x0, %al
callq 0x5b9c0
movq 0xb8e0(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x20(%rsp), %r8
leaq 0xba870(%rip), %rsi     # 0x1d2034
leaq 0xe5ed6(%rip), %rdx     # 0x1fd6a1
movl $0x600, %ecx            # imm = 0x600
movb $0x0, %al
callq 0x5b9c0
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x1, 0xb8f4(%rsp)
jmp 0x1178ae
movq 0xb8d0(%rsp), %rax
movq 0xb8e0(%rsp), %rcx
movslq 0x2d4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb8e0(%rsp), %rax
movsd %xmm0, 0x318(%rax)
movq 0xb8e0(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x1, %eax
jle 0x11787c
movq 0xb8e0(%rsp), %rax
movsd 0x310(%rax), %xmm0
movq 0xb8e0(%rsp), %rax
movsd 0x318(%rax), %xmm1
leaq 0xe64f2(%rip), %rdi     # 0x1fdd67
movb $0x2, %al
callq 0x8030
movq 0xb8d0(%rsp), %rdi
callq 0x8420
movq 0xb8c8(%rsp), %rdi
callq 0x8420
movq 0xb8c0(%rsp), %rdi
callq 0x8420
movl $0x0, 0xb8f4(%rsp)
movl 0xb8f4(%rsp), %eax
addq $0xb8f8, %rsp           # imm = 0xB8F8
retq
nopl (%rax)