// File: /workspace/github_c_makefile_star2_O2/lesgourg[P]class_public/build/../source/perturbations.c
// Function: perturbations_init
int perturbations_init(
                       struct precision * ppr,
                       struct background * pba,
                       struct thermodynamics * pth,
                       struct perturbations * ppt
                       ) {

  /** Summary: */

  /** - define local variables */

  /* running index for modes */
  int index_md;
  /* running index for initial conditions */
  int index_ic;
  /* running index for wavenumbers */
  int index_k;
  /* running index for type of perturbation */
  int index_tp;
  /* background quantities */
  double w_fld_ini, w_fld_0,dw_over_da_fld,integral_fld;

  /** - perform preliminary checks */

  if (ppt->has_perturbations == _FALSE_) {
    if (ppt->perturbations_verbose > 0)
      printf("No sources requested. Perturbation module skipped.\n");
    return _SUCCESS_;
  }
  else {
    if (ppt->perturbations_verbose > 0)
      printf("Computing sources\n");
  }

  class_test((ppt->gauge == synchronous) && (pba->has_cdm == _FALSE_),
             ppt->error_message,
             "In the synchronous gauge, it is not self-consistent to assume no CDM: the later is used to define the initial timelike hypersurface. You can either add a negligible amount of CDM, or switch to newtonian gauge");

  class_test ((ppr->tight_coupling_approximation < first_order_MB) ||
              (ppr->tight_coupling_approximation > compromise_CLASS),
              ppt->error_message,
              "your tight_coupling_approximation is set to %d, out of range defined in perturbations.h",ppr->tight_coupling_approximation);

  class_test ((ppr->radiation_streaming_approximation < rsa_null) ||
              (ppr->radiation_streaming_approximation > rsa_none),
              ppt->error_message,
              "your radiation_streaming_approximation is set to %d, out of range defined in perturbations.h",ppr->radiation_streaming_approximation);

  if (pba->has_idr == _TRUE_){
    class_test ((ppr->idr_streaming_approximation < rsa_idr_none) ||
                (ppr->idr_streaming_approximation > rsa_idr_MD),
                ppt->error_message,
                "your idr_radiation_streaming_approximation is set to %d, out of range defined in perturbations.h",ppr->idr_streaming_approximation);
  }

  if (pba->has_ur == _TRUE_) {

    class_test ((ppr->ur_fluid_approximation < ufa_mb) ||
                (ppr->ur_fluid_approximation > ufa_none),
                ppt->error_message,
                "your ur_fluid_approximation is set to %d, out of range defined in perturbations.h",ppr->ur_fluid_approximation);
  }

  if (pba->has_ncdm == _TRUE_) {

    class_test ((ppr->ncdm_fluid_approximation < ncdmfa_mb) ||
                (ppr->ncdm_fluid_approximation > ncdmfa_none),
                ppt->error_message,
                "your ncdm_fluid_approximation is set to %d, out of range defined in perturbations.h",ppr->ncdm_fluid_approximation);

    if (ppt->has_nc_density == _TRUE_) {
      if (ppt->perturbations_verbose > 0) {
        fprintf(stdout," -> [WARNING:] You request the number count Cl's in presence of non-cold dark matter.\n    Like in all previous CLASS and CLASSgal versions, this will be inferred from the total matter density,\n    but it could make much more sense physically to compute it from the CDM+baryon density only.\n    To get the latter behavior you would just need to change one line in transfer.c:\n    search there for a comment starting with 'use here delta_cb'\n");
      }
    }

  }

  if (pba->has_fld == _TRUE_) {

    /* check values of w_fld at initial time and today. Since 'a' in the code stands for 'a/a_0', its current value is 1 by definition */
    class_call(background_w_fld(pba, 0., &w_fld_ini, &dw_over_da_fld, &integral_fld), pba->error_message, ppt->error_message);
    class_call(background_w_fld(pba, 1.,   &w_fld_0, &dw_over_da_fld, &integral_fld), pba->error_message, ppt->error_message);

    class_test(w_fld_ini >= 0.,
               ppt->error_message,
               "The fluid is meant to be negligible at early time, and unimportant for defining the initial conditions of other species. You are using parameters for which this assumption may break down, since at early times you have w_fld(a--->0) = %e >= 0",w_fld_ini);

    if (pba->use_ppf == _FALSE_) {

      class_test((w_fld_ini +1.0)*(w_fld_0+1.0) <= 0.0,
                 ppt->error_message,
                 "w crosses -1 between the infinite past and today, and this would lead to divergent perturbation equations for the fluid perturbations. Try to switch to PPF scheme: use_ppf = yes");

      /* the next check is meaningful at least for w(a) = w0 + wa*(1-a/a0); for general formulas and with use_ppf=no, you may prefer to comment it out... */
      class_test((w_fld_0 == -1.) && (dw_over_da_fld == 0.),
                 ppt->error_message,
                 "Your choice of a fluid with (w0,wa)=(-1,0) is not valid due to instabilities in the unphysical perturbations of such a fluid. Try instead with a plain cosmological constant or with PPF scheme: use_ppf = yes");

    }

  }

  if (pba->has_dcdm == _TRUE_) {

    class_test((ppt->has_cdi == _TRUE_) || (ppt->has_bi == _TRUE_) || (ppt->has_nid == _TRUE_) || (ppt->has_niv == _TRUE_),
               ppt->error_message,
               "Non-adiabatic initial conditions not coded in presence of decaying dark matter");

  }

  class_test(ppt->has_vectors == _TRUE_,
             ppt->error_message,
             "Vectors not coded yet");

  if ((ppt->has_niv == _TRUE_) && (ppt->perturbations_verbose > 0)) {
    printf("Warning: the niv initial conditions in CLASS (and also in CAMB) should still be double-checked: if you want to do it and send feedback, you are welcome!\n");
  }

  if (ppt->has_tensors == _TRUE_) {

    ppt->evolve_tensor_ur = _FALSE_;
    ppt->evolve_tensor_ncdm = _FALSE_;

    switch (ppt->tensor_method) {

    case (tm_photons_only):
      break;

    case (tm_massless_approximation):
      if ((pba->has_ur == _TRUE_) || (pba->has_ncdm == _TRUE_))
        ppt->evolve_tensor_ur = _TRUE_;
      break;

    case (tm_exact):
      if (pba->has_ur == _TRUE_)
        ppt->evolve_tensor_ur = _TRUE_;
      if (pba->has_ncdm == _TRUE_)
        ppt->evolve_tensor_ncdm = _TRUE_;
      break;
    }
  }

  /*
    class_test((pba->h > _h_BIG_) || (pba->h < _h_SMALL_),
    ppt->error_message,
    "Your value of pba->h=%e is out of the bounds [%e , %e] and could cause a crash of the perturbation ODE integration. If you want to force this barrier, you may comment it out in perturbation.c",
    pba->h,
    _h_SMALL_,
    _h_BIG_);

    class_test((pba->Omega0_b*pba->h*pba->h < _omegab_SMALL_) || (pba->Omega0_b*pba->h*pba->h > _omegab_BIG_),
    ppt->error_message,
    "Your value of omega_b=%e is out of the bounds [%e , %e] and could cause a crash of the perturbation ODE integration. If you want to force this barrier, you may comment it out in perturbation.c",
    pba->Omega0_b*pba->h*pba->h,
    _omegab_SMALL_,
    _omegab_BIG_);
  */

  /** - initialize all indices and lists in perturbations structure using perturbations_indices() */

  class_call(perturbations_indices(ppr,
                                   pba,
                                   pth,
                                   ppt),
             ppt->error_message,
             ppt->error_message);


  if (ppt->z_max_pk > pth->z_rec) {

    class_test(ppt->has_cmb == _TRUE_,
               ppt->error_message,
               "You requested a very high z_pk=%e, higher than z_rec=%e. This works very well when you don't ask for a calculation of the CMB source function(s). Remove any CMB from your output and try e.g. with 'output=mTk' or 'output=mTk,vTk'",
               ppt->z_max_pk,
               pth->z_rec);

    class_test((ppt->has_source_delta_m == _TRUE_) && (ppt->has_matter_source_in_current_gauge == _FALSE_),
               ppt->error_message,
               "You requested a very high z_pk=%e, higher than z_rec=%e. This works very well when you ask only transfer functions, e.g. with 'output=mTk' or 'output=mTk,vTk'. But if you need the total matter (e.g. with 'mPk', 'dCl', etc.) there is an issue with the calculation of delta_m (or delta_cb) at very early times. By default, delta_m and delta_cb are expressed by the code as gauge-invariant variables (the density fluctuation in comoving gauge). This quantity is hard to get accurately at very early times. The solution is to define delta_m and delta_cb as density fluctuations in the current gauge, e.g. synchronous or newtonian. This is done by setting the input flag 'matter_source_in_current_gauge' to 'yes'.",
               ppt->z_max_pk,
               pth->z_rec);

  }



  /** - define the common time sampling for all sources using
      perturbations_timesampling_for_sources() */

  class_call(perturbations_timesampling_for_sources(ppr,
                                                    pba,
                                                    pth,
                                                    ppt),
             ppt->error_message,
             ppt->error_message);

  /** - if we want to store perturbations for given k values, write titles and allocate storage */
  class_call(perturbations_prepare_k_output(pba,ppt),
             ppt->error_message,
             ppt->error_message);

  /* Setup task system */
  class_setup_parallel();
  /** - loop over modes (scalar, tensors, etc). For each mode: */
  for (index_md = 0; index_md < ppt->md_size; index_md++) {

    if (ppt->perturbations_verbose > 1)
      printf("Evolving mode %d/%d\n",index_md+1,ppt->md_size);

    /** - --> loop over initial conditions and wavenumbers; for each of them, evolve perturbations and compute source functions with perturbations_solve() */

    for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {

      if (ppt->perturbations_verbose > 1) {
        printf("Evolving ic %d/%d\n",index_ic+1,ppt->ic_size[index_md]);
        printf("evolving %d wavenumbers\n",ppt->k_size[index_md]);
      }

      /* integrating backwards is slightly more optimal for parallel runs */
      //for (index_k = 0; index_k < ppt->k_size; index_k++) {
      for (index_k = ppt->k_size[index_md]-1; index_k >=0; index_k--) {

        class_run_parallel(with_arguments(ppr,pba,pth,ppt,index_md,index_ic,index_k),

          if (ppt->perturbations_verbose > 2) {
            printf("evolving mode k=%e /Mpc  (%d/%d)",ppt->k[index_md][index_k],index_k+1,ppt->k_size[index_md]);
            if (pba->sgnK != 0)
              printf(" (for scalar modes, corresponds to nu=%e)",sqrt(ppt->k[index_md][index_k]*ppt->k[index_md][index_k]+pba->K)/sqrt(pba->sgnK*pba->K));
            printf("\n");
          }

          struct perturbations_workspace pw;
          class_call(perturbations_workspace_init(ppr,
                                                  pba,
                                                  pth,
                                                  ppt,
                                                  index_md,
                                                  &pw),
                     ppt->error_message,
                     ppt->error_message);

          class_call(perturbations_solve(ppr,
                                         pba,
                                         pth,
                                         ppt,
                                         index_md,
                                         index_ic,
                                         index_k,
                                         &pw),
                     ppt->error_message,
                     ppt->error_message);

          class_call(perturbations_workspace_free(ppt,index_md,&pw),
                     ppt->error_message,
                     ppt->error_message);
          return _SUCCESS_;

        );

      } /* end of loop over wavenumbers */

    } /* end of loop over initial conditions */

  } /* end loop over modes */

  class_finish_parallel();


  /** - spline the source array with respect to the time variable */

  if (ppt->ln_tau_size > 1) {

    class_setup_parallel();

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

      for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {

        for (index_tp = 0; index_tp < ppt->tp_size[index_md]; index_tp++) {

          class_run_parallel(with_arguments(ppt, index_md, index_ic, index_tp),
            class_call(array_spline_table_lines(ppt->ln_tau,
                                                ppt->ln_tau_size,
                                                ppt->late_sources[index_md][index_ic * ppt->tp_size[index_md] + index_tp],
                                                ppt->k_size[index_md],
                                                ppt->ddlate_sources[index_md][index_ic*ppt->tp_size[index_md] + index_tp],
                                                _SPLINE_EST_DERIV_,
                                                ppt->error_message),
                       ppt->error_message,
                       ppt->error_message);
            return _SUCCESS_;
          );

        } /* end of loop over type of source function*/

      } /* end of loop over initial condition */

    } /* end of loop over mode */

    class_finish_parallel();
  }

  ppt->is_allocated = _TRUE_;

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1108, %rsp           # imm = 0x1108
movq %rcx, %r15
cmpw $0x0, (%rcx)
movzwl 0x6bf0(%rcx), %eax
je 0x64b83
movq %rdx, %rcx
movq %rsi, %r14
testw %ax, %ax
jle 0x64af6
movq %rdi, %r12
leaq 0x9778f(%rip), %rdi     # 0xfc277
movq %rcx, %rbx
callq 0x8540
movq %r12, %rdi
movq %rbx, %rcx
cmpl $0x1, 0x7f4(%r15)
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
jne 0x64b16
cmpw $0x0, 0x320(%r14)
je 0x64c87
movl 0x5a0(%rdi), %edx
cmpl $0x6, %edx
jb 0x64ba5
leaq 0x92b3e(%rip), %rsi     # 0xf766a
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x7153d(%rip), %rsi     # 0xd6082
leaq 0x92b76(%rip), %rdx     # 0xf76c2
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x714c5(%rip), %rsi     # 0xd6034
leaq 0x92ae1(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x2dd, %ecx            # imm = 0x2DD
jmp 0x64ce0
movl $0x0, 0x10(%rsp)
testw %ax, %ax
jle 0x64cea
leaq 0x97787(%rip), %rdi     # 0xfc322
callq 0x8540
jmp 0x64cea
movl 0x620(%rdi), %edx
cmpl $0x4, %edx
jb 0x64c0e
leaq 0x92b7a(%rip), %rsi     # 0xf7731
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x714b2(%rip), %rsi     # 0xd6082
leaq 0x92bb7(%rip), %rdx     # 0xf778e
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x7143a(%rip), %rsi     # 0xd6034
leaq 0x92a56(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x2e2, %ecx            # imm = 0x2E2
jmp 0x64ce0
cmpw $0x1, 0x332(%r14)
jne 0x64d00
movl 0x638(%rdi), %edx
cmpl $0x2, %edx
jb 0x64d00
leaq 0x92bc6(%rip), %rsi     # 0xf77f9
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x71436(%rip), %rsi     # 0xd6082
leaq 0x92c07(%rip), %rdx     # 0xf785a
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x713be(%rip), %rsi     # 0xd6034
leaq 0x929da(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x2e8, %ecx            # imm = 0x2E8
jmp 0x64ce0
leaq 0x928bf(%rip), %rsi     # 0xf754d
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x713db(%rip), %rsi     # 0xd6082
leaq 0x92970(%rip), %rdx     # 0xf761e
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x71363(%rip), %rsi     # 0xd6034
leaq 0x9297f(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x2d8, %ecx            # imm = 0x2D8
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
movl 0x10(%rsp), %eax
addq $0x1108, %rsp           # imm = 0x1108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpw $0x1, 0x330(%r14)
jne 0x64d74
movl 0x650(%rdi), %edx
cmpl $0x4, %edx
jb 0x64d74
leaq 0x92ba2(%rip), %rsi     # 0xf78bf
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x7134c(%rip), %rsi     # 0xd6082
leaq 0x92bd4(%rip), %rdx     # 0xf7911
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x712d4(%rip), %rsi     # 0xd6034
leaq 0x928f0(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x2f0, %ecx            # imm = 0x2F0
jmp 0x64ce0
cmpw $0x1, 0x32a(%r14)
jne 0x64e29
movl 0x660(%rdi), %edx
cmpl $0x4, %edx
jb 0x64dec
leaq 0x92bcf(%rip), %rsi     # 0xf7964
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x712d4(%rip), %rsi     # 0xd6082
leaq 0x92c03(%rip), %rdx     # 0xf79b8
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x7125c(%rip), %rsi     # 0xd6034
leaq 0x92878(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x2f8, %ecx            # imm = 0x2F8
jmp 0x64ce0
cmpw $0x1, 0x36(%r15)
jne 0x64e29
cmpw $0x0, 0x6bf0(%r15)
jle 0x64e29
movq 0xca14a(%rip), %rax     # 0x12ef50
movq %rcx, %rbx
movq (%rax), %rcx
movq %rdi, %r12
leaq 0x92bff(%rip), %rdi     # 0xf7a15
pushq $0x1
popq %rdx
movl $0x1b8, %esi            # imm = 0x1B8
callq 0x8700
movq %r12, %rdi
movq %rbx, %rcx
cmpw $0x1, 0x32e(%r14)
jne 0x64f58
movq %rdi, %r12
movq %rcx, %rbx
leaq 0xf8(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
leaq 0xe8(%rsp), %rcx
xorpd %xmm0, %xmm0
movq %r14, %rdi
callq 0x521cf
cmpl $0x1, %eax
jne 0x64eb3
addq $0xb84, %r14            # imm = 0xB84
leaq 0x7157b(%rip), %rsi     # 0xd63f0
leaq 0x92d52(%rip), %rdx     # 0xf7bce
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x71195(%rip), %rsi     # 0xd6034
leaq 0x927b1(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x305, %ecx            # imm = 0x305
jmp 0x65352
movsd 0x713a5(%rip), %xmm0    # 0xd6260
leaq 0xf0(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
leaq 0xe8(%rsp), %rcx
movq %r14, %rdi
callq 0x521cf
cmpl $0x1, %eax
jne 0x64f2c
addq $0xb84, %r14            # imm = 0xB84
leaq 0x71502(%rip), %rsi     # 0xd63f0
leaq 0x92d1f(%rip), %rdx     # 0xf7c14
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x7111c(%rip), %rsi     # 0xd6034
leaq 0x92738(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x306, %ecx            # imm = 0x306
jmp 0x65352
movsd 0xf8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x650bf
cmpw $0x0, 0x110(%r14)
movq %rbx, %rcx
movq %r12, %rdi
je 0x65229
cmpw $0x1, 0x324(%r14)
jne 0x64fe1
cmpw $0x1, 0xe(%r15)
je 0x64f83
cmpw $0x1, 0xc(%r15)
je 0x64f83
cmpw $0x1, 0x10(%r15)
je 0x64f83
cmpw $0x1, 0x12(%r15)
jne 0x64fe1
leaq 0x92fa2(%rip), %rsi     # 0xf7f2c
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x710df(%rip), %rsi     # 0xd6082
leaq 0x92fd1(%rip), %rdx     # 0xf7f7b
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x71067(%rip), %rsi     # 0xd6034
leaq 0x92683(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x31f, %ecx            # imm = 0x31F
jmp 0x64ce0
cmpw $0x1, 0x6(%r15)
jne 0x65047
leaq 0x92ff7(%rip), %rsi     # 0xf7fe7
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x71079(%rip), %rsi     # 0xd6082
leaq 0x8693e(%rip), %rdx     # 0xeb94e
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x71001(%rip), %rsi     # 0xd6034
leaq 0x9261d(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x325, %ecx            # imm = 0x325
jmp 0x64ce0
cmpw $0x1, 0x12(%r15)
jne 0x65072
cmpw $0x0, 0x6bf0(%r15)
jle 0x65072
movq %rdi, %r12
leaq 0x97225(%rip), %rdi     # 0xfc289
movq %rcx, %rbx
callq 0x8540
movq %r12, %rdi
movq %rbx, %rcx
cmpw $0x1, 0x8(%r15)
jne 0x65141
andl $0x0, 0x1c(%r15)
movl 0x18(%r15), %eax
cmpl $0x2, %eax
je 0x6511d
cmpl $0x1, %eax
jne 0x65141
cmpw $0x1, 0x330(%r14)
je 0x650b3
cmpw $0x1, 0x32a(%r14)
jne 0x65141
movw $0x1, 0x1c(%r15)
jmp 0x65141
leaq 0x92b92(%rip), %rsi     # 0xf7c58
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x70fa3(%rip), %rsi     # 0xd6082
leaq 0x92c64(%rip), %rdx     # 0xf7d4a
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x70f2b(%rip), %rsi     # 0xd6034
leaq 0x92547(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x30a, %ecx            # imm = 0x30A
jmp 0x64ce0
cmpw $0x1, 0x330(%r14)
jne 0x6512f
movw $0x1, 0x1c(%r15)
cmpw $0x1, 0x32a(%r14)
jne 0x65141
movw $0x1, 0x1e(%r15)
movq %rdi, %r12
movq %r14, %rsi
movq %rcx, %rdx
movq %rcx, %rbx
movq %r15, %rcx
callq 0x65c1b
testl %eax, %eax
je 0x6519e
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x71289(%rip), %rsi     # 0xd63f0
leaq 0x92e8f(%rip), %rdx     # 0xf7ffd
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x70eaa(%rip), %rsi     # 0xd6034
leaq 0x924c6(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x35a, %ecx            # imm = 0x35A
jmp 0x65352
movsd 0x7d0(%r15), %xmm0
movsd 0xf30(%rbx), %xmm1
ucomisd %xmm1, %xmm0
movq %rbx, %rdx
jbe 0x652fd
cmpw $0x1, 0x7ec(%r15)
jne 0x652e3
leaq 0x92e55(%rip), %rsi     # 0xf8027
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x70e97(%rip), %rsi     # 0xd6082
leaq 0x92f1a(%rip), %rdx     # 0xf810c
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x70e1f(%rip), %rsi     # 0xd6034
leaq 0x9243b(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x363, %ecx            # imm = 0x363
jmp 0x64ce0
movsd 0x7102f(%rip), %xmm2    # 0xd6260
addsd %xmm2, %xmm0
movsd 0xf0(%rsp), %xmm1
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jae 0x656e3
ucomisd 0x7158c(%rip), %xmm1    # 0xd67e8
jne 0x64f58
jp 0x64f58
movsd 0xa8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x64f58
jp 0x64f58
leaq 0x92ba6(%rip), %rsi     # 0xf7e32
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x70ddd(%rip), %rsi     # 0xd6082
leaq 0x92c55(%rip), %rdx     # 0xf7f01
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x70d65(%rip), %rsi     # 0xd6034
leaq 0x92381(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x315, %ecx            # imm = 0x315
jmp 0x64ce0
cmpw $0x1, 0x834(%r15)
jne 0x652fd
cmpw $0x0, 0x7f8(%r15)
je 0x65a4c
movq %r12, %rdi
movq %r14, %rsi
movq %rdx, %rbx
movq %r15, %rcx
callq 0x66a07
testl %eax, %eax
je 0x6535a
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x710d0(%rip), %rsi     # 0xd63f0
leaq 0x9311d(%rip), %rdx     # 0xf8444
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x70cf1(%rip), %rsi     # 0xd6034
leaq 0x9230d(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x377, %ecx            # imm = 0x377
movq %rbx, %r8
jmp 0x64ce3
movq %r12, 0xd0(%rsp)
movq %rbx, 0xd8(%rsp)
movq %r14, 0xe0(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x67da3
callq 0x1a2a0
leaq 0x900(%rsp), %rdi
movl %eax, %esi
callq 0x1a33e
xorpd %xmm0, %xmm0
leaq 0xb0(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0xc7eb3(%rip), %rax     # 0x12d260
addq $0x10, %rax
movq %rax, 0x90(%rsp)
leaq 0x100(%rsp), %r14
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
xorl %ebx, %ebx
movq %r15, 0x48(%rsp)
movslq 0x808(%r15), %rdx
cmpq %rdx, %rbx
jge 0x656b9
cmpw $0x2, 0x6bf0(%r15)
jl 0x653fb
leal 0x1(%rbx), %esi
leaq 0x9308b(%rip), %rdi     # 0xf847f
xorl %eax, %eax
callq 0x8030
xorl %r12d, %r12d
movq %rbx, 0x38(%rsp)
movq 0x828(%r15), %rax
movl (%rax,%rbx,4), %edx
cmpl %edx, %r12d
jge 0x656b1
cmpw $0x2, 0x6bf0(%r15)
jl 0x6544c
leal 0x1(%r12), %esi
leaq 0x93067(%rip), %rdi     # 0xf8494
xorl %eax, %eax
callq 0x8030
movq 0x950(%r15), %rax
movl (%rax,%rbx,4), %esi
leaq 0x93062(%rip), %rdi     # 0xf84a7
xorl %eax, %eax
callq 0x8030
movq %r12, 0x40(%rsp)
movq 0x950(%r15), %rax
movl (%rax,%rbx,4), %r13d
testl %r13d, %r13d
leaq 0xf(%rsp), %rdi
jle 0x6569a
andq $0x0, 0x18(%rsp)
pushq $0x1
popq %rsi
movq %rdi, %rbx
callq 0x1b0f6
movq %rax, %r12
movq %rbx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movabsq $0x100000001, %rbx      # imm = 0x100000001
movq %rbx, 0x8(%rax)
movq 0x90(%rsp), %rax
movq %rax, (%r12)
pushq $0x68
popq %rdi
callq 0x83d0
movq %rax, %r15
leaq 0x80(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r15, 0x108(%rsp)
movq %rbx, 0x8(%r15)
leaq 0xc8450(%rip), %rax     # 0x12d920
movq %rax, (%r15)
movq %r15, %rbx
addq $0x10, %rbx
movq %rbx, %rdi
leaq 0x98(%rsp), %rsi
callq 0x1b18a
decl %r13d
movq %r12, %rbp
addq $0x10, %rbp
leaq 0xc8475(%rip), %rax     # 0x12d970
movq %rax, 0x10(%r15)
movq 0xd0(%rsp), %rax
movq %rax, 0x38(%r15)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%r15)
movq 0xd8(%rsp), %rax
movq %rax, 0x48(%r15)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%r15)
movq 0x38(%rsp), %rax
movl %eax, 0x58(%r15)
movq 0x40(%rsp), %rax
movl %eax, 0x5c(%r15)
movl %r13d, 0x60(%r15)
andq $0x0, 0x108(%rsp)
movq %r14, %rdi
callq 0x7f2e8
movq %rbx, 0x10(%r12)
andq $0x0, 0x58(%rsp)
movq %r15, 0x18(%r12)
andq $0x0, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1afb0
andq $0x0, 0x30(%rsp)
movq %r12, 0x20(%rsp)
movq %rbp, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1b0e8
leaq 0x70(%rsp), %rdi
movq %rbp, %rsi
callq 0x1b09c
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1b986
pushq $0x1
popq %rax
movl %eax, %r12d
lock
xaddl %r12d, 0x920(%rsp)
xorl %ebx, %ebx
movl 0x900(%rsp), %ecx
cmpl %ecx, %ebx
jae 0x65609
leal (%r12,%rbx), %eax
xorl %edx, %edx
divl %ecx
movq 0x928(%rsp), %r15
imulq $0xb0, %rdx, %rbp
leaq (%r15,%rbp), %rdi
addq $0x58, %rdi
movq %rdi, 0x100(%rsp)
callq 0x1add8
movb %al, 0x108(%rsp)
testb %al, %al
jne 0x65641
movq %r14, %rdi
callq 0x1adc2
incl %ebx
jmp 0x655bb
movl %r12d, %eax
xorl %edx, %edx
divl %ecx
movq 0x928(%rsp), %r15
imulq $0xb0, %rdx, %rbx
leaq (%r15,%rbx), %rsi
addq $0x58, %rsi
movq %r14, %rdi
callq 0x1ae48
addq %rbx, %r15
movq %r15, %rdi
leaq 0x50(%rsp), %rsi
callq 0x7f8e6
jmp 0x65651
addq %rbp, %r15
movq %r15, %rdi
leaq 0x50(%rsp), %rsi
callq 0x7f8e6
movq %r14, %rdi
callq 0x1adc2
subq $-0x80, %r15
movq %r15, %rdi
callq 0x81e0
leaq 0x58(%rsp), %rdi
callq 0x1afb0
leaq 0x20(%rsp), %rdi
callq 0x1afb0
leaq 0xb0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1bb4a
leaq 0x78(%rsp), %rdi
callq 0x1afb0
jmp 0x6545c
movq 0x40(%rsp), %r12
incl %r12d
movq 0x48(%rsp), %r15
movq 0x38(%rsp), %rbx
jmp 0x65403
incq %rbx
jmp 0x653cf
movq 0xb0(%rsp), %rbx
movq 0xb8(%rsp), %r14
cmpq %r14, %rbx
je 0x65741
movq %rbx, %rdi
callq 0x1a3be
addq $0x10, %rbx
testl %eax, %eax
je 0x656c9
jmp 0x65ade
leaq 0x92670(%rip), %rsi     # 0xf7d5a
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x7097f(%rip), %rsi     # 0xd6082
leaq 0x92702(%rip), %rdx     # 0xf7e0c
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x70907(%rip), %rsi     # 0xd6034
leaq 0x91f23(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x310, %ecx            # imm = 0x310
jmp 0x64ce0
leaq 0xb0(%rsp), %rdi
callq 0x1a3f0
cmpl $0x2, 0x9c8(%r15)
jl 0x65acc
callq 0x1a2a0
leaq 0x100(%rsp), %rdi
movl %eax, %esi
callq 0x1a33e
xorpd %xmm0, %xmm0
leaq 0x50(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %r13d, %r13d
leaq 0xe(%rsp), %rbx
leaq 0x28(%rsp), %rbp
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
movslq 0x808(%r15), %rax
cmpq %rax, %r13
jge 0x65a0d
xorl %ecx, %ecx
movq 0x828(%r15), %rax
cmpl (%rax,%r13,4), %ecx
jge 0x65a05
movl %ecx, 0x38(%rsp)
xorl %ecx, %ecx
movq 0x48(%rsp), %rax
movq 0x930(%rax), %rax
cmpl (%rax,%r13,4), %ecx
jge 0x659f5
movl %ecx, 0x40(%rsp)
andq $0x0, 0x80(%rsp)
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x1b0f6
movq %rax, %r14
movq %rbx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
movabsq $0x100000001, %r15      # imm = 0x100000001
movq %r15, 0x8(%rax)
movq 0x90(%rsp), %rax
movq %rax, (%r14)
pushq $0x50
popq %rdi
callq 0x83d0
movq %rax, %rbx
leaq 0xf(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r15, 0x8(%rbx)
leaq 0xc81c8(%rip), %rax     # 0x12da00
movq %rax, (%rbx)
movq %rbx, %r15
addq $0x10, %r15
movq %r15, %rdi
leaq 0x17(%rsp), %rsi
callq 0x1b18a
movq %r14, %r12
addq $0x10, %r12
leaq 0xc81f3(%rip), %rax     # 0x12da50
movq %rax, 0x10(%rbx)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rbx)
movl %r13d, 0x40(%rbx)
movl 0x38(%rsp), %eax
movl %eax, 0x44(%rbx)
movl 0x40(%rsp), %eax
movl %eax, 0x48(%rbx)
andq $0x0, 0x30(%rsp)
movq %rbp, %rdi
callq 0x7fa94
movq %r15, 0x10(%r14)
andq $0x0, 0x20(%rsp)
movq %rbx, 0x18(%r14)
andq $0x0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1afb0
andq $0x0, 0x78(%rsp)
movq %r14, 0x88(%rsp)
movq %r12, 0x80(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1b0e8
leaq 0x98(%rsp), %rdi
movq %r12, %rsi
callq 0x1b09c
leaq 0x18(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1b986
pushq $0x1
popq %rax
movl %eax, %r14d
lock
xaddl %r14d, 0x120(%rsp)
xorl %ebx, %ebx
movl 0x100(%rsp), %ecx
cmpl %ecx, %ebx
jae 0x65944
leal (%r14,%rbx), %eax
xorl %edx, %edx
divl %ecx
movq 0x128(%rsp), %r15
imulq $0xb0, %rdx, %r12
leaq (%r15,%r12), %rdi
addq $0x58, %rdi
movq %rdi, 0x28(%rsp)
callq 0x1add8
movb %al, 0x30(%rsp)
testb %al, %al
jne 0x6598b
movq %rbp, %rdi
callq 0x1adc2
incl %ebx
jmp 0x658fc
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movq 0x128(%rsp), %r14
imulq $0xb0, %rdx, %rbx
leaq (%r14,%rbx), %rsi
addq $0x58, %rsi
movq %rbp, %rdi
callq 0x1ae48
addq %rbx, %r14
movq %r14, %rdi
leaq 0x18(%rsp), %rsi
callq 0x7ff66
movq %rbp, %rdi
callq 0x1adc2
subq $-0x80, %r14
movq %r14, %rdi
jmp 0x659aa
addq %r12, %r15
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
callq 0x7ff66
movq %rbp, %rdi
callq 0x1adc2
subq $-0x80, %r15
movq %r15, %rdi
callq 0x81e0
leaq 0x20(%rsp), %rdi
callq 0x1afb0
leaq 0x88(%rsp), %rdi
callq 0x1afb0
leaq 0x50(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1bb4a
leaq 0xa0(%rsp), %rdi
callq 0x1afb0
movl 0x40(%rsp), %ecx
incl %ecx
leaq 0xe(%rsp), %rbx
jmp 0x657bf
movl 0x38(%rsp), %ecx
incl %ecx
movq 0x48(%rsp), %r15
jmp 0x657a8
incq %r13
jmp 0x65796
movq 0x50(%rsp), %rbx
movq 0x58(%rsp), %r14
cmpq %r14, %rbx
je 0x65aaa
movq %rbx, %rdi
callq 0x1a3be
addq $0x10, %rbx
testl %eax, %eax
je 0x65a17
leaq 0x50(%rsp), %rdi
callq 0x1a3f8
leaq 0x100(%rsp), %rdi
callq 0x1a41a
jmp 0x65ade
leaq 0x926d0(%rip), %rsi     # 0xf8123
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x70616(%rip), %rsi     # 0xd6082
leaq 0x92975(%rip), %rdx     # 0xf83e8
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6bf2, %r15           # imm = 0x6BF2
leaq 0x7059e(%rip), %rsi     # 0xd6034
leaq 0x91bba(%rip), %rdx     # 0xf7657
movq %r15, %rdi
movl $0x369, %ecx            # imm = 0x369
jmp 0x64ce0
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a3f0
movq %rbx, %rdi
callq 0x1a3f8
leaq 0x100(%rsp), %rdi
callq 0x1a41a
movw $0x1, 0x73f2(%r15)
movl $0x0, 0x10(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x1a3f8
leaq 0x900(%rsp), %rdi
callq 0x1a41a
jmp 0x64cea
jmp 0x65bc1
jmp 0x65b73
jmp 0x65bc1
jmp 0x65b0b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1adc2
jmp 0x65b1d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1afb0
leaq 0xa0(%rsp), %rdi
callq 0x1afb0
jmp 0x65b46
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
jmp 0x65b4e
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x1afb0
jmp 0x65b76
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7fa94
jmp 0x65b67
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1b0e8
jmp 0x65b76
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1a3f8
leaq 0x100(%rsp), %rdi
callq 0x1a41a
jmp 0x65bf9
jmp 0x65b91
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x1adc2
jmp 0x65ba6
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1afb0
leaq 0x78(%rsp), %rdi
callq 0x1afb0
jmp 0x65bc9
movq %rax, %rbx
jmp 0x65be0
movq %rax, %rbx
jmp 0x65bf9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x65bf4
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x7f2e8
leaq 0x28(%rsp), %rdi
callq 0x1b0e8
jmp 0x65bf9
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x1afb0
leaq 0xb0(%rsp), %rdi
callq 0x1a3f8
leaq 0x900(%rsp), %rdi
callq 0x1a41a
movq %rbx, %rdi
callq 0x8680