// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_init
int primordial_init(
                    struct precision  * ppr,
                    struct perturbations   * ppt,
                    struct primordial * ppm
                    ) {

  /** Summary: */

  /** - define local variables */

  double k,k_min,k_max;
  int index_md,index_ic1,index_ic2,index_ic1_ic2,index_k;
  double pk,pk1,pk2;
  double dlnk,lnpk_pivot,lnpk_minus,lnpk_plus,lnpk_minusminus,lnpk_plusplus;
  /* uncomment if you use optional test below
     (for correlated isocurvature modes) */
  //double cos_delta_k;

  /** - check that we really need to compute the primordial spectra */

  if (ppt->has_perturbations == _FALSE_) {
    ppm->lnk_size=0;
    if (ppm->primordial_verbose > 0)
      printf("No perturbations requested. Primordial module skipped.\n");
    return _SUCCESS_;
  }
  else {
    if (ppm->primordial_verbose > 0)
      printf("Computing primordial spectra");
  }

  /** - get kmin and kmax from perturbation structure. Test that they make sense. */

  k_min = ppt->k_min; /* first value, inferred from perturbations structure */
  if (ppm->has_k_max_for_primordial_pk == _TRUE_){
    k_max = ppm->k_max_for_primordial_pk; /* last value, user-defined (i.e. if specified in .ini file) */
  }
  else{
    k_max = ppt->k_max; /* last value, inferred from perturbations structure */
  }

  class_test(k_min <= 0.,
             ppm->error_message,
             "k_min negative or null: stop to avoid segmentation fault");

  class_test(k_max <= 0.,
             ppm->error_message,
             "k_max negative or null: stop to avoid segmentation fault");

  class_test(ppm->k_pivot <= 0.,
             ppm->error_message,
             "k_pivot negative or null: stop to avoid segmentation fault");

  class_test(ppr->k_per_decade_primordial <= 0.,
             ppm->error_message,
             "k_per_decade_primordial negative or null: stop to avoid segmentation fault");

  class_test(ppr->k_per_decade_primordial <= _K_PER_DECADE_PRIMORDIAL_MIN_,
             ppm->error_message,
             "k_per_decade_primordial = %e: you ask for such a sparse sampling of the primordial spectrum that this is probably a mistake",
             ppr->k_per_decade_primordial);

  /** - allocate and fill values of \f$ \ln{k}\f$'s */

  class_call(primordial_get_lnk_list(ppm,
                                     k_min,
                                     k_max,
                                     ppr->k_per_decade_primordial
                                     ),
             ppm->error_message,
             ppm->error_message);

  /** - define indices and allocate tables in primordial structure */

  class_call(primordial_indices(ppt,
                                ppm),
             ppm->error_message,
             ppm->error_message);

  /** - deal with case of analytic primordial spectra (with amplitudes, tilts, runnings, etc.) */

  if (ppm->primordial_spec_type == analytic_Pk) {

    if (ppm->primordial_verbose > 0)
      printf(" (analytic spectrum)\n");

    class_call_except(primordial_analytic_spectrum_init(ppt,
                                                        ppm),
                      ppm->error_message,
                      ppm->error_message,
                      primordial_free(ppm));

    for (index_k = 0; index_k < ppm->lnk_size; index_k++) {

      k=exp(ppm->lnk[index_k]);

      for (index_md = 0; index_md < ppt->md_size; index_md++) {
        for (index_ic1 = 0; index_ic1 < ppm->ic_size[index_md]; index_ic1++) {
          for (index_ic2 = index_ic1; index_ic2 < ppm->ic_size[index_md]; index_ic2++) {

            index_ic1_ic2 = index_symmetric_matrix(index_ic1,index_ic2,ppm->ic_size[index_md]);

            if (ppm->is_non_zero[index_md][index_ic1_ic2] == _TRUE_) {

              class_call(primordial_analytic_spectrum(ppm,
                                                      index_md,
                                                      index_ic1_ic2,
                                                      k,
                                                      &pk),
                         ppm->error_message,
                         ppm->error_message);

              if (index_ic1 == index_ic2) {

                /* diagonal coefficients: ln[P(k)] */

                ppm->lnpk[index_md][index_k*ppm->ic_ic_size[index_md]+index_ic1_ic2] = log(pk);
              }
              else {

                /* non-diagonal coefficients: cosDelta(k) = P(k)_12/sqrt[P(k)_1 P(k)_2] */

                class_call(primordial_analytic_spectrum(ppm,
                                                        index_md,
                                                        index_symmetric_matrix(index_ic1,index_ic1,ppm->ic_size[index_md]),
                                                        k,
                                                        &pk1),
                           ppm->error_message,
                           ppm->error_message);

                class_call(primordial_analytic_spectrum(ppm,
                                                        index_md,
                                                        index_symmetric_matrix(index_ic2,index_ic2,ppm->ic_size[index_md]),
                                                        k,
                                                        &pk2),
                           ppm->error_message,
                           ppm->error_message);

                /* either return an error if correlation is too large... */
                /*
                  cos_delta_k = pk/sqrt(pk1*pk2);
                  class_test_except((cos_delta_k < -1.) || (cos_delta_k > 1.),
                  ppm->error_message,
                  primordial_free(ppm),
                  "correlation angle between IC's takes unphysical values");

                  ppm->lnpk[index_md][index_k*ppm->ic_ic_size[index_md]+index_ic1_ic2] = cos_delta_k;
                */

                /* ... or enforce definite positive correlation matrix */

                if (pk > sqrt(pk1*pk2))
                  ppm->lnpk[index_md][index_k*ppm->ic_ic_size[index_md]+index_ic1_ic2] = 1.;
                else if (pk < -sqrt(pk1*pk2))
                  ppm->lnpk[index_md][index_k*ppm->ic_ic_size[index_md]+index_ic1_ic2] = -1.;
                else
                  ppm->lnpk[index_md][index_k*ppm->ic_ic_size[index_md]+index_ic1_ic2] = pk/sqrt(pk1*pk2);


              }
            }
            else {

              /* non-diagonal coefficients when ic's are uncorrelated */

              ppm->lnpk[index_md][index_k*ppm->ic_ic_size[index_md]+index_ic1_ic2] = 0.;
            }
          }
        }
      }
    }
  }

  /** - deal with case of inflation with given \f$V(\phi)\f$ or \f$H(\phi)\f$ */

  else if ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_H) || (ppm->primordial_spec_type == inflation_V_end)) {

    class_call(primordial_inflation_indices(ppm),
               ppm->error_message,
               ppm->error_message);

    if (ppm->primordial_verbose > 0)
      printf(" (simulating inflation)\n");

    class_call_except(primordial_inflation_solve_inflation(ppt,ppm,ppr),
                      ppm->error_message,
                      ppm->error_message,
                      primordial_free(ppm));

  }

  /** - deal with the case of external calculation of \f$ P_k \f$*/

  else if (ppm->primordial_spec_type == external_Pk) {

    class_test(ppt->has_scalars == _FALSE_,
               ppm->error_message,
               "external Pk module cannot work if you do not ask for scalar modes");

    class_test(ppt->has_vectors == _TRUE_,
               ppm->error_message,
               "external Pk module cannot work if you ask for vector modes");

    class_test(ppt->has_bi == _TRUE_ || ppt->has_cdi == _TRUE_ || ppt->has_nid == _TRUE_ || ppt->has_niv == _TRUE_,
               ppm->error_message,
               "external Pk module cannot work if you ask for isocurvature modes (but that could be implemented easily in the future!)");

    if (ppm->primordial_verbose > 0)
      printf(" (Pk calculated externally)\n");

    class_call_except(primordial_external_spectrum_init(ppt,ppm),
                      ppm->error_message,
                      ppm->error_message,
                      primordial_free(ppm));
  }

  else {

    class_test(0==0,
               ppm->error_message,
               "primordial spectrum type not recognized");

  }

  /** - compute second derivative of each \f$ \ln{P_k} \f$ versus lnk with spline, in view of interpolation */

  for (index_md = 0; index_md < ppm->md_size; index_md++) {

    class_call(array_spline_table_lines(ppm->lnk,
                                        ppm->lnk_size,
                                        ppm->lnpk[index_md],
                                        ppm->ic_ic_size[index_md],
                                        ppm->ddlnpk[index_md],
                                        _SPLINE_EST_DERIV_,
                                        ppm->error_message),
               ppm->error_message,
               ppm->error_message);

  }

  /** - derive spectral parameters from numerically computed spectra
      (not used by the rest of the code, but useful to keep in memory for several types of investigation) */

  if (ppm->primordial_spec_type != analytic_Pk) {

    dlnk = log(10.)/ppr->k_per_decade_primordial;

    if (ppt->has_scalars == _TRUE_) {

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_scalars,
                                          logarithmic,
                                          log(ppm->k_pivot),
                                          &lnpk_pivot),
                 ppm->error_message,
                 ppm->error_message);

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_scalars,
                                          logarithmic,
                                          log(ppm->k_pivot)+dlnk,

                                          &lnpk_plus),
                 ppm->error_message,
                 ppm->error_message);

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_scalars,
                                          logarithmic,
                                          log(ppm->k_pivot)-dlnk,
                                          &lnpk_minus),
                 ppm->error_message,
                 ppm->error_message);

      ppm->A_s = exp(lnpk_pivot);
      ppm->n_s = (lnpk_plus-lnpk_minus)/(2.*dlnk)+1.;
      ppm->alpha_s = (lnpk_plus-2.*lnpk_pivot+lnpk_minus)/pow(dlnk,2);

      /** - expression for alpha_s comes from:

          `ns_2 = (lnpk_plus-lnpk_pivot)/(dlnk)+1`

          `ns_1 = (lnpk_pivot-lnpk_minus)/(dlnk)+1`

          `alpha_s = dns/dlnk = (ns_2-ns_1)/dlnk = (lnpk_plus-lnpk_pivot-lnpk_pivot+lnpk_minus)/(dlnk)/(dlnk)`

      **/

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_scalars,
                                          logarithmic,
                                          log(ppm->k_pivot)+2.*dlnk,

                                          &lnpk_plusplus),
                 ppm->error_message,
                 ppm->error_message);

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_scalars,
                                          logarithmic,
                                          log(ppm->k_pivot)-2.*dlnk,
                                          &lnpk_minusminus),
                 ppm->error_message,
                 ppm->error_message);

      /** - expression for beta_s:

          `ppm->beta_s = (alpha_plus-alpha_minus)/dlnk = (lnpk_plusplus-2.*lnpk_plus+lnpk_pivot -
          (lnpk_pivot-2.*lnpk_minus+lnpk_minusminus)/pow(dlnk,3)`
      **/

      /* Simplification of the beta_s expression: */

      ppm->beta_s = (lnpk_plusplus-2.*lnpk_plus+2.*lnpk_minus-lnpk_minusminus)/pow(dlnk,3);

      if (ppm->primordial_verbose > 0)
        printf(" -> A_s=%g  n_s=%g  alpha_s=%g\n",ppm->A_s,ppm->n_s,ppm->alpha_s);

    }

    if (ppt->has_tensors == _TRUE_) {

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_tensors,
                                          logarithmic,
                                          log(ppm->k_pivot),
                                          &lnpk_pivot),
                 ppm->error_message,
                 ppm->error_message);

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_tensors,
                                          logarithmic,
                                          log(ppm->k_pivot)+dlnk,
                                          &lnpk_plus),
                 ppm->error_message,
                 ppm->error_message);

      class_call(primordial_spectrum_at_k(ppm,
                                          ppt->index_md_tensors,
                                          logarithmic,
                                          log(ppm->k_pivot)-dlnk,
                                          &lnpk_minus),
                 ppm->error_message,
                 ppm->error_message);

      ppm->r = exp(lnpk_pivot)/ppm->A_s;
      ppm->n_t = (lnpk_plus-lnpk_minus)/(2.*dlnk);
      ppm->alpha_t = (lnpk_plus-2.*lnpk_pivot+lnpk_minus)/pow(dlnk,2);

      if (ppm->primordial_verbose > 0)
        printf(" -> r=%g  n_t=%g  alpha_t=%g\n",ppm->r,ppm->n_t,ppm->alpha_t);

    }

  }

  ppm->is_allocated = _TRUE_;

  return _SUCCESS_;

}

// Assembly:
subq $0x12198, %rsp          # imm = 0x12198
movq %rdi, 0x12188(%rsp)
movq %rsi, 0x12180(%rsp)
movq %rdx, 0x12178(%rsp)
movq 0x12180(%rsp), %rax
movswl (%rax), %eax
cmpl $0x0, %eax
jne 0x111d73
movq 0x12178(%rsp), %rax
movl $0x0, 0x290(%rax)
movq 0x12178(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x0, %eax
jle 0x111d63
leaq 0xeab7b(%rip), %rdi     # 0x1fc8d7
movb $0x0, %al
callq 0x8030
movl $0x0, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x0, %eax
jle 0x111d95
leaq 0xeab81(%rip), %rdi     # 0x1fc90f
movb $0x0, %al
callq 0x8030
jmp 0x111d97
movq 0x12180(%rsp), %rax
movsd 0x9e0(%rax), %xmm0
movsd %xmm0, 0x12168(%rsp)
movq 0x12178(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x111dd6
movq 0x12178(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x12160(%rsp)
jmp 0x111def
movq 0x12180(%rsp), %rax
movsd 0x9e8(%rax), %xmm0
movsd %xmm0, 0x12160(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x12168(%rsp), %xmm0
jb 0x111e79
leaq 0x11900(%rsp), %rdi
leaq 0xeab20(%rip), %rsi     # 0x1fc92c
movb $0x0, %al
callq 0x5b9c0
leaq 0x11100(%rsp), %rdi
leaq 0x11900(%rsp), %rcx
leaq 0xc0258(%rip), %rsi     # 0x1d2082
leaq 0xeab34(%rip), %rdx     # 0x1fc965
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x11100(%rsp), %r8
leaq 0xc01de(%rip), %rsi     # 0x1d2034
leaq 0xeab14(%rip), %rdx     # 0x1fc971
movl $0x10c, %ecx            # imm = 0x10C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
xorps %xmm0, %xmm0
ucomisd 0x12160(%rsp), %xmm0
jb 0x111f03
leaq 0x10900(%rsp), %rdi
leaq 0xeaaeb(%rip), %rsi     # 0x1fc981
movb $0x0, %al
callq 0x5b9c0
leaq 0x10100(%rsp), %rdi
leaq 0x10900(%rsp), %rcx
leaq 0xc01ce(%rip), %rsi     # 0x1d2082
leaq 0xeaaff(%rip), %rdx     # 0x1fc9ba
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x10100(%rsp), %r8
leaq 0xc0154(%rip), %rsi     # 0x1d2034
leaq 0xeaa8a(%rip), %rdx     # 0x1fc971
movl $0x110, %ecx            # imm = 0x110
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jb 0x111f90
leaq 0xf900(%rsp), %rdi
leaq 0xeaaa3(%rip), %rsi     # 0x1fc9c6
movb $0x0, %al
callq 0x5b9c0
leaq 0xf100(%rsp), %rdi
leaq 0xf900(%rsp), %rcx
leaq 0xc0141(%rip), %rsi     # 0x1d2082
leaq 0xeaab9(%rip), %rdx     # 0x1fca01
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xf100(%rsp), %r8
leaq 0xc00c7(%rip), %rsi     # 0x1d2034
leaq 0xea9fd(%rip), %rdx     # 0x1fc971
movl $0x114, %ecx            # imm = 0x114
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12188(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x680(%rax), %xmm0
jb 0x112021
leaq 0xe900(%rsp), %rdi
leaq 0xeaa60(%rip), %rsi     # 0x1fca14
movb $0x0, %al
callq 0x5b9c0
leaq 0xe100(%rsp), %rdi
leaq 0xe900(%rsp), %rcx
leaq 0xc00b0(%rip), %rsi     # 0x1d2082
leaq 0xeaa86(%rip), %rdx     # 0x1fca5f
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xe100(%rsp), %r8
leaq 0xc0036(%rip), %rsi     # 0x1d2034
leaq 0xea96c(%rip), %rdx     # 0x1fc971
movl $0x118, %ecx            # imm = 0x118
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12188(%rsp), %rax
movsd 0xc0217(%rip), %xmm0    # 0x1d2248
ucomisd 0x680(%rax), %xmm0
jb 0x1120cb
leaq 0xd900(%rsp), %rdi
movq 0x12188(%rsp), %rax
movsd 0x680(%rax), %xmm0
leaq 0xeaa24(%rip), %rsi     # 0x1fca82
movb $0x1, %al
callq 0x5b9c0
leaq 0xd100(%rsp), %rdi
leaq 0xd900(%rsp), %rcx
leaq 0xc0006(%rip), %rsi     # 0x1d2082
leaq 0xeaa7b(%rip), %rdx     # 0x1fcafe
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xd100(%rsp), %r8
leaq 0xbff8c(%rip), %rsi     # 0x1d2034
leaq 0xea8c2(%rip), %rdx     # 0x1fc971
movl $0x11d, %ecx            # imm = 0x11D
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rdi
movsd 0x12168(%rsp), %xmm0
movsd 0x12160(%rsp), %xmm1
movq 0x12188(%rsp), %rax
movsd 0x680(%rax), %xmm2
callq 0x113a60
cmpl $0x1, %eax
jne 0x11216c
leaq 0xc900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xc02bb(%rip), %rsi     # 0x1d23d8
leaq 0xeaa18(%rip), %rdx     # 0x1fcb3c
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xc900(%rsp), %r8
leaq 0xbfeeb(%rip), %rsi     # 0x1d2034
leaq 0xea821(%rip), %rdx     # 0x1fc971
movl $0x127, %ecx            # imm = 0x127
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12180(%rsp), %rdi
movq 0x12178(%rsp), %rsi
callq 0x113d10
cmpl $0x1, %eax
jne 0x1121f3
leaq 0xc100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xc0234(%rip), %rsi     # 0x1d23d8
leaq 0xea9db(%rip), %rdx     # 0x1fcb86
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xc100(%rsp), %r8
leaq 0xbfe64(%rip), %rsi     # 0x1d2034
leaq 0xea79a(%rip), %rdx     # 0x1fc971
movl $0x12e, %ecx            # imm = 0x12E
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x112b4c
movq 0x12178(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x0, %eax
jle 0x112227
leaq 0xea983(%rip), %rdi     # 0x1fcba3
movb $0x0, %al
callq 0x8030
movq 0x12180(%rsp), %rdi
movq 0x12178(%rsp), %rsi
callq 0x1144d0
cmpl $0x1, %eax
jne 0x1122bb
leaq 0xb900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xc0179(%rip), %rsi     # 0x1d23d8
leaq 0xea953(%rip), %rdx     # 0x1fcbb9
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xb900(%rsp), %r8
leaq 0xbfda9(%rip), %rsi     # 0x1d2034
leaq 0xea6df(%rip), %rdx     # 0x1fc971
movl $0x13b, %ecx            # imm = 0x13B
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
callq 0x115f20
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movl $0x0, 0x1214c(%rsp)
movl 0x1214c(%rsp), %eax
movq 0x12178(%rsp), %rcx
cmpl 0x290(%rcx), %eax
jge 0x112b47
movq 0x12178(%rsp), %rax
movq 0x298(%rax), %rax
movslq 0x1214c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movsd %xmm0, 0x12170(%rsp)
movl $0x0, 0x1215c(%rsp)
movl 0x1215c(%rsp), %eax
movq 0x12180(%rsp), %rcx
cmpl 0x854(%rcx), %eax
jge 0x112b2f
movl $0x0, 0x12158(%rsp)
movl 0x12158(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x112b17
movl 0x12158(%rsp), %eax
movl %eax, 0x12154(%rsp)
movl 0x12154(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x112aff
movl 0x12158(%rsp), %eax
cmpl 0x12154(%rsp), %eax
jg 0x11240a
movl 0x12154(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x12158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xf8(%rsp)
movl 0x12158(%rsp), %eax
movl 0x12158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xf8(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xfc(%rsp)
jmp 0x11246a
movl 0x12158(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x12154(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xf4(%rsp)
movl 0x12154(%rsp), %eax
movl 0x12154(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xf4(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xfc(%rsp)
movl 0xfc(%rsp), %eax
movl %eax, 0x12150(%rsp)
movq 0x12178(%rsp), %rax
movq 0x2b0(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x12150(%rsp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x1, %eax
jne 0x112a98
movq 0x12178(%rsp), %rdi
movl 0x1215c(%rsp), %esi
movl 0x12150(%rsp), %edx
movsd 0x12170(%rsp), %xmm0
leaq 0x12140(%rsp), %rcx
callq 0x111ab0
cmpl $0x1, %eax
jne 0x112546
leaq 0xb100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbfee1(%rip), %rsi     # 0x1d23d8
leaq 0xea6e7(%rip), %rdx     # 0x1fcbe5
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xb100(%rsp), %r8
leaq 0xbfb11(%rip), %rsi     # 0x1d2034
leaq 0xea447(%rip), %rdx     # 0x1fc971
movl $0x14f, %ecx            # imm = 0x14F
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movl 0x12158(%rsp), %eax
cmpl 0x12154(%rsp), %eax
jne 0x1125b5
movsd 0x12140(%rsp), %xmm0
callq 0x82f0
movq 0x12178(%rsp), %rax
movq 0x2a0(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1214c(%rsp), %ecx
movq 0x12178(%rsp), %rdx
movq 0x288(%rdx), %rdx
movslq 0x1215c(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0x12150(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x112a96
movq 0x12178(%rsp), %rax
movq %rax, 0xe8(%rsp)
movl 0x1215c(%rsp), %eax
movl %eax, 0xf0(%rsp)
movl 0x12158(%rsp), %eax
cmpl 0x12158(%rsp), %eax
jg 0x112645
movl 0x12158(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x12158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xe0(%rsp)
movl 0x12158(%rsp), %eax
movl 0x12158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xe0(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xe4(%rsp)
jmp 0x1126a5
movl 0x12158(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x12158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xdc(%rsp)
movl 0x12158(%rsp), %eax
movl 0x12158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xdc(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xe4(%rsp)
movl 0xf0(%rsp), %esi
movq 0xe8(%rsp), %rdi
movl 0xe4(%rsp), %edx
movsd 0x12170(%rsp), %xmm0
leaq 0x12138(%rsp), %rcx
callq 0x111ab0
cmpl $0x1, %eax
jne 0x112743
leaq 0xa900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbfce4(%rip), %rsi     # 0x1d23d8
leaq 0xea52d(%rip), %rdx     # 0x1fcc28
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xa900(%rsp), %r8
leaq 0xbf914(%rip), %rsi     # 0x1d2034
leaq 0xea24a(%rip), %rdx     # 0x1fc971
movl $0x161, %ecx            # imm = 0x161
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movq %rax, 0xd0(%rsp)
movl 0x1215c(%rsp), %eax
movl %eax, 0xd8(%rsp)
movl 0x12154(%rsp), %eax
cmpl 0x12154(%rsp), %eax
jg 0x1127d3
movl 0x12154(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x12154(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xc8(%rsp)
movl 0x12154(%rsp), %eax
movl 0x12154(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xc8(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xcc(%rsp)
jmp 0x112833
movl 0x12154(%rsp), %eax
movq 0x12178(%rsp), %rcx
movq 0x280(%rcx), %rcx
movslq 0x1215c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x12154(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xc4(%rsp)
movl 0x12154(%rsp), %eax
movl 0x12154(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xc4(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xcc(%rsp)
movl 0xd8(%rsp), %esi
movq 0xd0(%rsp), %rdi
movl 0xcc(%rsp), %edx
movsd 0x12170(%rsp), %xmm0
leaq 0x12130(%rsp), %rcx
callq 0x111ab0
cmpl $0x1, %eax
jne 0x1128d1
leaq 0xa100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbfb56(%rip), %rsi     # 0x1d23d8
leaq 0xea498(%rip), %rdx     # 0x1fcd21
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0xa100(%rsp), %r8
leaq 0xbf786(%rip), %rsi     # 0x1d2034
leaq 0xea0bc(%rip), %rdx     # 0x1fc971
movl $0x169, %ecx            # imm = 0x169
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movsd 0x12140(%rsp), %xmm0
movsd %xmm0, 0xb8(%rsp)
movsd 0x12138(%rsp), %xmm0
mulsd 0x12130(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0xb8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x112965
movq 0x12178(%rsp), %rax
movq 0x2a0(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1214c(%rsp), %ecx
movq 0x12178(%rsp), %rdx
movq 0x288(%rdx), %rdx
movslq 0x1215c(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0x12150(%rsp), %ecx
movslq %ecx, %rcx
movsd 0xbf8ed(%rip), %xmm0    # 0x1d2248
movsd %xmm0, (%rax,%rcx,8)
jmp 0x112a94
movsd 0x12140(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0x12138(%rsp), %xmm0
mulsd 0x12130(%rsp), %xmm0
callq 0x82e0
movsd 0xb0(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x112a0d
movq 0x12178(%rsp), %rax
movq 0x2a0(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1214c(%rsp), %ecx
movq 0x12178(%rsp), %rdx
movq 0x288(%rdx), %rdx
movslq 0x1215c(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0x12150(%rsp), %ecx
movslq %ecx, %rcx
movsd 0xbfdcd(%rip), %xmm0    # 0x1d27d0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x112a92
movsd 0x12140(%rsp), %xmm0
movsd %xmm0, 0xa8(%rsp)
movsd 0x12138(%rsp), %xmm0
mulsd 0x12130(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0xa8(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x12178(%rsp), %rax
movq 0x2a0(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1214c(%rsp), %ecx
movq 0x12178(%rsp), %rdx
movq 0x288(%rdx), %rdx
movslq 0x1215c(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0x12150(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x112a94
jmp 0x112a96
jmp 0x112ae7
movq 0x12178(%rsp), %rax
movq 0x2a0(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1214c(%rsp), %ecx
movq 0x12178(%rsp), %rdx
movq 0x288(%rdx), %rdx
movslq 0x1215c(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0x12150(%rsp), %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x112ae9
movl 0x12154(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x12154(%rsp)
jmp 0x112371
jmp 0x112b01
movl 0x12158(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x12158(%rsp)
jmp 0x11233c
jmp 0x112b19
movl 0x1215c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1215c(%rsp)
jmp 0x112316
jmp 0x112b31
movl 0x1214c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1214c(%rsp)
jmp 0x1122c6
jmp 0x112fe0
movq 0x12178(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x112b7a
movq 0x12178(%rsp), %rax
cmpl $0x3, 0x18(%rax)
je 0x112b7a
movq 0x12178(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x112cbc
movq 0x12178(%rsp), %rdi
callq 0x116100
cmpl $0x1, %eax
jne 0x112bf9
leaq 0x9900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbf82e(%rip), %rsi     # 0x1d23d8
leaq 0xea269(%rip), %rdx     # 0x1fce1a
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x9900(%rsp), %r8
leaq 0xbf45e(%rip), %rsi     # 0x1d2034
leaq 0xe9d94(%rip), %rdx     # 0x1fc971
movl $0x194, %ecx            # imm = 0x194
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x0, %eax
jle 0x112c1b
leaq 0xea228(%rip), %rdi     # 0x1fce3c
movb $0x0, %al
callq 0x8030
movq 0x12180(%rsp), %rdi
movq 0x12178(%rsp), %rsi
movq 0x12188(%rsp), %rdx
callq 0x116270
cmpl $0x1, %eax
jne 0x112cb7
leaq 0x9100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbf77d(%rip), %rsi     # 0x1d23d8
leaq 0xea1f3(%rip), %rdx     # 0x1fce55
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x9100(%rsp), %r8
leaq 0xbf3ad(%rip), %rsi     # 0x1d2034
leaq 0xe9ce3(%rip), %rdx     # 0x1fc971
movl $0x19c, %ecx            # imm = 0x19C
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
callq 0x115f20
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
jmp 0x112fde
movq 0x12178(%rsp), %rax
cmpl $0x5, 0x18(%rax)
jne 0x112f60
movq 0x12180(%rsp), %rax
movswl 0xe(%rax), %eax
cmpl $0x0, %eax
jne 0x112d5b
leaq 0x8900(%rsp), %rdi
leaq 0xea199(%rip), %rsi     # 0x1fce87
movb $0x0, %al
callq 0x5b9c0
leaq 0x8100(%rsp), %rdi
leaq 0x8900(%rsp), %rcx
leaq 0xbf376(%rip), %rsi     # 0x1d2082
leaq 0xd81e2(%rip), %rdx     # 0x1eaef5
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x8100(%rsp), %r8
leaq 0xbf2fc(%rip), %rsi     # 0x1d2034
leaq 0xe9c32(%rip), %rdx     # 0x1fc971
movl $0x1a6, %ecx            # imm = 0x1A6
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12180(%rsp), %rax
movswl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x112de8
leaq 0x7900(%rsp), %rdi
leaq 0xea14e(%rip), %rsi     # 0x1fcec9
movb $0x0, %al
callq 0x5b9c0
leaq 0x7100(%rsp), %rdi
leaq 0x7900(%rsp), %rcx
leaq 0xbf2e9(%rip), %rsi     # 0x1d2082
leaq 0xd81ad(%rip), %rdx     # 0x1eaf4d
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x7100(%rsp), %r8
leaq 0xbf26f(%rip), %rsi     # 0x1d2034
leaq 0xe9ba5(%rip), %rdx     # 0x1fc971
movl $0x1aa, %ecx            # imm = 0x1AA
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12180(%rsp), %rax
movswl 0x16(%rax), %eax
cmpl $0x1, %eax
je 0x112e2c
movq 0x12180(%rsp), %rax
movswl 0x18(%rax), %eax
cmpl $0x1, %eax
je 0x112e2c
movq 0x12180(%rsp), %rax
movswl 0x1a(%rax), %eax
cmpl $0x1, %eax
je 0x112e2c
movq 0x12180(%rsp), %rax
movswl 0x1c(%rax), %eax
cmpl $0x1, %eax
jne 0x112ea8
leaq 0x6900(%rsp), %rdi
leaq 0xea0c9(%rip), %rsi     # 0x1fcf04
movb $0x0, %al
callq 0x5b9c0
leaq 0x6100(%rsp), %rdi
leaq 0x6900(%rsp), %rcx
leaq 0xbf229(%rip), %rsi     # 0x1d2082
leaq 0xd81a9(%rip), %rdx     # 0x1eb009
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x6100(%rsp), %r8
leaq 0xbf1af(%rip), %rsi     # 0x1d2034
leaq 0xe9ae5(%rip), %rdx     # 0x1fc971
movl $0x1ae, %ecx            # imm = 0x1AE
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x0, %eax
jle 0x112eca
leaq 0xea0b8(%rip), %rdi     # 0x1fcf7b
movb $0x0, %al
callq 0x8030
movq 0x12180(%rsp), %rdi
movq 0x12178(%rsp), %rsi
callq 0x1178c0
cmpl $0x1, %eax
jne 0x112f5e
leaq 0x5900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbf4d6(%rip), %rsi     # 0x1d23d8
leaq 0xea08f(%rip), %rdx     # 0x1fcf98
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x5900(%rsp), %r8
leaq 0xbf106(%rip), %rsi     # 0x1d2034
leaq 0xe9a3c(%rip), %rdx     # 0x1fc971
movl $0x1b6, %ecx            # imm = 0x1B6
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
callq 0x115f20
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
jmp 0x112fdc
leaq 0x5100(%rsp), %rdi
leaq 0xea054(%rip), %rsi     # 0x1fcfc3
movb $0x0, %al
callq 0x5b9c0
leaq 0x4900(%rsp), %rdi
leaq 0x5100(%rsp), %rcx
leaq 0xbf0f5(%rip), %rsi     # 0x1d2082
leaq 0xea057(%rip), %rdx     # 0x1fcfeb
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x4900(%rsp), %r8
leaq 0xbf07b(%rip), %rsi     # 0x1d2034
leaq 0xe99b1(%rip), %rdx     # 0x1fc971
movl $0x1bd, %ecx            # imm = 0x1BD
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
jmp 0x112fde
jmp 0x112fe0
movl $0x0, 0x1215c(%rsp)
movl 0x1215c(%rsp), %eax
movq 0x12178(%rsp), %rcx
cmpl 0x278(%rcx), %eax
jge 0x11311a
movq 0x12178(%rsp), %rax
movq 0x298(%rax), %rdi
movq 0x12178(%rsp), %rax
movl 0x290(%rax), %esi
movq 0x12178(%rsp), %rax
movq 0x2a0(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x12178(%rsp), %rax
movq 0x288(%rax), %rax
movslq 0x1215c(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq 0x12178(%rsp), %rax
movq 0x2a8(%rax), %rax
movslq 0x1215c(%rsp), %r8
movq (%rax,%r8,8), %r8
movq 0x12178(%rsp), %rax
addq $0x32a, %rax            # imm = 0x32A
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x1cf90
cmpl $0x1, %eax
jne 0x113102
leaq 0x4100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbf325(%rip), %rsi     # 0x1d23d8
leaq 0xe9f36(%rip), %rdx     # 0x1fcff0
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x4100(%rsp), %r8
leaq 0xbef55(%rip), %rsi     # 0x1d2034
leaq 0xe988b(%rip), %rdx     # 0x1fc971
movl $0x1cd, %ecx            # imm = 0x1CD
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
jmp 0x113104
movl 0x1215c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1215c(%rsp)
jmp 0x112feb
movq 0x12178(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x113a2d
movsd 0xbf6ac(%rip), %xmm0    # 0x1d27e0
callq 0x82f0
movq 0x12188(%rsp), %rax
divsd 0x680(%rax), %xmm0
movsd %xmm0, 0x12128(%rsp)
movq 0x12180(%rsp), %rax
movswl 0xe(%rax), %eax
cmpl $0x1, %eax
jne 0x1136d0
movq 0x12178(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x12180(%rsp), %rax
movl 0x848(%rax), %eax
movl %eax, 0xa4(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x98(%rsp), %rdi
movl 0xa4(%rsp), %esi
movl $0x1, %edx
leaq 0x12120(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x113230
leaq 0x3900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbf1f7(%rip), %rsi     # 0x1d23d8
leaq 0xe9e98(%rip), %rdx     # 0x1fd080
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x3900(%rsp), %r8
leaq 0xbee27(%rip), %rsi     # 0x1d2034
leaq 0xe975d(%rip), %rdx     # 0x1fc971
movl $0x1e0, %ecx            # imm = 0x1E0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x12180(%rsp), %rax
movl 0x848(%rax), %eax
movl %eax, 0x94(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x88(%rsp), %rdi
movl 0x94(%rsp), %esi
addsd 0x12128(%rsp), %xmm0
movl $0x1, %edx
leaq 0x12110(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x113302
leaq 0x3100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbf125(%rip), %rsi     # 0x1d23d8
leaq 0xe9e28(%rip), %rdx     # 0x1fd0e2
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x3100(%rsp), %r8
leaq 0xbed55(%rip), %rsi     # 0x1d2034
leaq 0xe968b(%rip), %rdx     # 0x1fc971
movl $0x1e9, %ecx            # imm = 0x1E9
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x12180(%rsp), %rax
movl 0x848(%rax), %eax
movl %eax, 0x84(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x78(%rsp), %rdi
movl 0x84(%rsp), %esi
subsd 0x12128(%rsp), %xmm0
movl $0x1, %edx
leaq 0x12118(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x1133ce
leaq 0x2900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbf059(%rip), %rsi     # 0x1d23d8
leaq 0xe9dc2(%rip), %rdx     # 0x1fd148
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x2900(%rsp), %r8
leaq 0xbec89(%rip), %rsi     # 0x1d2034
leaq 0xe95bf(%rip), %rdx     # 0x1fc971
movl $0x1f1, %ecx            # imm = 0x1F1
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movsd 0x12120(%rsp), %xmm0
callq 0x8670
movq 0x12178(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movsd 0x12110(%rsp), %xmm0
subsd 0x12118(%rsp), %xmm0
movsd 0xbf87d(%rip), %xmm1    # 0x1d2c80
mulsd 0x12128(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0xbee30(%rip), %xmm1    # 0x1d2248
addsd %xmm1, %xmm0
movq 0x12178(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movsd 0x12110(%rsp), %xmm0
movsd 0x12120(%rsp), %xmm1
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
addsd 0x12118(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x12128(%rsp), %xmm0
movl $0x2, %edi
callq 0x5b970
movaps %xmm0, %xmm1
movsd 0x60(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x12178(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x12178(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x12180(%rsp), %rax
movl 0x848(%rax), %eax
movl %eax, 0x74(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x68(%rsp), %rdi
movl 0x74(%rsp), %esi
movaps %xmm0, %xmm1
movsd 0x12128(%rsp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movl $0x1, %edx
leaq 0x12100(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x113550
leaq 0x2100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbeed7(%rip), %rsi     # 0x1d23d8
leaq 0xe9ca7(%rip), %rdx     # 0x1fd1af
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x2100(%rsp), %r8
leaq 0xbeb07(%rip), %rsi     # 0x1d2034
leaq 0xe943d(%rip), %rdx     # 0x1fc971
movl $0x208, %ecx            # imm = 0x208
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x12180(%rsp), %rax
movl 0x848(%rax), %eax
movl %eax, 0x5c(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x50(%rsp), %rdi
movl 0x5c(%rsp), %esi
movsd 0x12128(%rsp), %xmm1
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
movl $0x1, %edx
leaq 0x12108(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x11361e
leaq 0x1900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbee09(%rip), %rsi     # 0x1d23d8
leaq 0xe9c46(%rip), %rdx     # 0x1fd21c
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x1900(%rsp), %r8
leaq 0xbea39(%rip), %rsi     # 0x1d2034
leaq 0xe936f(%rip), %rdx     # 0x1fc971
movl $0x210, %ecx            # imm = 0x210
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movsd 0x12100(%rsp), %xmm1
movsd 0x12110(%rsp), %xmm0
addsd %xmm0, %xmm0
subsd %xmm0, %xmm1
movsd 0x12118(%rsp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
subsd 0x12108(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x12128(%rsp), %xmm0
movl $0x3, %edi
callq 0x5b970
movaps %xmm0, %xmm1
movsd 0x48(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x12178(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq 0x12178(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x0, %eax
jle 0x1136ce
movq 0x12178(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x12178(%rsp), %rax
movsd 0x28(%rax), %xmm1
movq 0x12178(%rsp), %rax
movsd 0x30(%rax), %xmm2
leaq 0xe9bc4(%rip), %rdi     # 0x1fd28b
movb $0x3, %al
callq 0x8030
jmp 0x1136d0
movq 0x12180(%rsp), %rax
movswl 0x12(%rax), %eax
cmpl $0x1, %eax
jne 0x113a2b
movq 0x12178(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x12180(%rsp), %rax
movl 0x84c(%rax), %eax
movl %eax, 0x44(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %esi
movl $0x1, %edx
leaq 0x12120(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x1137a2
leaq 0x1100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbec85(%rip), %rsi     # 0x1d23d8
leaq 0xe9b51(%rip), %rdx     # 0x1fd2ab
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x1100(%rsp), %r8
leaq 0xbe8b5(%rip), %rsi     # 0x1d2034
leaq 0xe91eb(%rip), %rdx     # 0x1fc971
movl $0x229, %ecx            # imm = 0x229
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x12180(%rsp), %rax
movl 0x84c(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %esi
addsd 0x12128(%rsp), %xmm0
movl $0x1, %edx
leaq 0x12110(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x113868
leaq 0x900(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbebbf(%rip), %rsi     # 0x1d23d8
leaq 0xe9aed(%rip), %rdx     # 0x1fd30d
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x900(%rsp), %r8
leaq 0xbe7ef(%rip), %rsi     # 0x1d2034
leaq 0xe9125(%rip), %rdx     # 0x1fc971
movl $0x231, %ecx            # imm = 0x231
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movq 0x12178(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x12180(%rsp), %rax
movl 0x84c(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x12178(%rsp), %rax
movsd (%rax), %xmm0
callq 0x82f0
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
subsd 0x12128(%rsp), %xmm0
movl $0x1, %edx
leaq 0x12118(%rsp), %rcx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x11392e
leaq 0x100(%rsp), %rdi
movq 0x12178(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xbeaf9(%rip), %rsi     # 0x1d23d8
leaq 0xe9a8d(%rip), %rdx     # 0x1fd373
movb $0x0, %al
callq 0x5b9c0
movq 0x12178(%rsp), %rdi
addq $0x32a, %rdi            # imm = 0x32A
leaq 0x100(%rsp), %r8
leaq 0xbe729(%rip), %rsi     # 0x1d2034
leaq 0xe905f(%rip), %rdx     # 0x1fc971
movl $0x239, %ecx            # imm = 0x239
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x12194(%rsp)
jmp 0x113a49
movsd 0x12120(%rsp), %xmm0
callq 0x8670
movq 0x12178(%rsp), %rax
divsd 0x20(%rax), %xmm0
movq 0x12178(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movsd 0x12110(%rsp), %xmm0
subsd 0x12118(%rsp), %xmm0
movsd 0xbf310(%rip), %xmm1    # 0x1d2c80
mulsd 0x12128(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x12178(%rsp), %rax
movsd %xmm0, 0x48(%rax)
movsd 0x12110(%rsp), %xmm0
movsd 0x12120(%rsp), %xmm1
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
addsd 0x12118(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x12128(%rsp), %xmm0
movl $0x2, %edi
callq 0x5b970
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x12178(%rsp), %rax
movsd %xmm0, 0x50(%rax)
movq 0x12178(%rsp), %rax
movswl 0x328(%rax), %eax
cmpl $0x0, %eax
jle 0x113a29
movq 0x12178(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq 0x12178(%rsp), %rax
movsd 0x48(%rax), %xmm1
movq 0x12178(%rsp), %rax
movsd 0x50(%rax), %xmm2
leaq 0xe99b8(%rip), %rdi     # 0x1fd3da
movb $0x3, %al
callq 0x8030
jmp 0x113a2b
jmp 0x113a2d
movq 0x12178(%rsp), %rax
movw $0x1, 0xb48(%rax)
movl $0x0, 0x12194(%rsp)
movl 0x12194(%rsp), %eax
addq $0x12198, %rsp          # imm = 0x12198
retq
nopl (%rax,%rax)