// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/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_) && (pba->fluid_equation_of_state != EDE)) {

      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");

  }
  if(pba->has_scf == _TRUE_){
    ppt->has_scf = _TRUE_;
  }else{
    ppt->has_scf = _FALSE_;
  }
  if(pba->scf_has_perturbations == _TRUE_){
    ppt->scf_has_perturbations = _TRUE_;
  }else{
    ppt->scf_has_perturbations = _FALSE_;
  }


  ppt->has_idm_fld = _FALSE_;
  ppt->has_idm_scf = _FALSE_;
  if(pba->has_idm == _TRUE_ && ppt->DMDE_interaction != 0){
    //we incorporate IDM-DE interactions
    if(pba->has_fld == _TRUE_){
      //we consider IDM_fld interactions
      ppt->has_idm_fld = _TRUE_;
    }
    if(pba->has_scf == _TRUE_){
     //we consider IDM_scf interactions
      ppt->has_idm_scf = _TRUE_;
    }
  }

  if(pba->has_scf == _TRUE_ && pba->scf_potential == axion && ppt->perturbations_verbose > 0 &&  ppr->evolver == ndf15){
    fprintf(stdout," -> [WARNING:] You are running with axions, we recommend using the rk evolver,  it has been found to be more stable for this model.\n");
    fprintf(stdout," -> [WARNING:] If the code crashes with a step-size error, try to set 'evolver=0' in your ini file.\n");

  }

  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();
  if(pba->scf_evolve_as_fluid == _TRUE_ && pba->scf_evolve_like_axionCAMB == _FALSE_){
    if (ppt->perturbations_verbose > 0)
      printf(" You are running axion with a switch from scf to fluid approximation; this currently leads to a crash if several cores are used. please make sure to use only one core. To be debugged.\n");
    // number_of_threads = 1;
  }
  /** - 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:
subq $0xe9d8, %rsp           # imm = 0xE9D8
movq %rdi, 0xe9c8(%rsp)
movq %rsi, 0xe9c0(%rsp)
movq %rdx, 0xe9b8(%rsp)
movq %rcx, 0xe9b0(%rsp)
movq 0xe9b0(%rsp), %rax
movswl (%rax), %eax
cmpl $0x0, %eax
jne 0xca7f9
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x0, %eax
jle 0xca7e9
leaq 0x12ca1b(%rip), %rdi    # 0x1f71fd
movb $0x0, %al
callq 0x8030
movl $0x0, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x0, %eax
jle 0xca81b
leaq 0x12ca1d(%rip), %rdi    # 0x1f7231
movb $0x0, %al
callq 0x8030
jmp 0xca81d
movq 0xe9b0(%rsp), %rax
cmpl $0x1, 0x83c(%rax)
jne 0xca8c2
movq 0xe9c0(%rsp), %rax
movswl 0x4b4(%rax), %eax
cmpl $0x0, %eax
jne 0xca8c2
leaq 0xe180(%rsp), %rdi
leaq 0x12c9ef(%rip), %rsi    # 0x1f7244
movb $0x0, %al
callq 0x5b9c0
leaq 0xd980(%rsp), %rdi
leaq 0xe180(%rsp), %rcx
leaq 0x10780f(%rip), %rsi    # 0x1d2082
leaq 0x12ca9b(%rip), %rdx    # 0x1f7315
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0xd980(%rsp), %r8
leaq 0x107795(%rip), %rsi    # 0x1d2034
leaq 0x12caa8(%rip), %rdx    # 0x1f734e
movl $0x2e2, %ecx            # imm = 0x2E2
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9c8(%rsp), %rax
cmpl $0x0, 0x5a0(%rax)
jl 0xca8e8
movq 0xe9c8(%rsp), %rax
cmpl $0x5, 0x5a0(%rax)
jle 0xca972
leaq 0xd180(%rsp), %rdi
movq 0xe9c8(%rsp), %rax
movl 0x5a0(%rax), %edx
leaq 0x12ca5c(%rip), %rsi    # 0x1f7361
movb $0x0, %al
callq 0x5b9c0
leaq 0xc980(%rsp), %rdi
leaq 0xd180(%rsp), %rcx
leaq 0x10775f(%rip), %rsi    # 0x1d2082
leaq 0x12ca8f(%rip), %rdx    # 0x1f73b9
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0xc980(%rsp), %r8
leaq 0x1076e5(%rip), %rsi    # 0x1d2034
leaq 0x12c9f8(%rip), %rdx    # 0x1f734e
movl $0x2e7, %ecx            # imm = 0x2E7
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9c8(%rsp), %rax
cmpl $0x0, 0x620(%rax)
jl 0xca998
movq 0xe9c8(%rsp), %rax
cmpl $0x3, 0x620(%rax)
jle 0xcaa22
leaq 0xc180(%rsp), %rdi
movq 0xe9c8(%rsp), %rax
movl 0x620(%rax), %edx
leaq 0x12ca73(%rip), %rsi    # 0x1f7428
movb $0x0, %al
callq 0x5b9c0
leaq 0xb980(%rsp), %rdi
leaq 0xc180(%rsp), %rcx
leaq 0x1076af(%rip), %rsi    # 0x1d2082
leaq 0x12caab(%rip), %rdx    # 0x1f7485
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0xb980(%rsp), %r8
leaq 0x107635(%rip), %rsi    # 0x1d2034
leaq 0x12c948(%rip), %rdx    # 0x1f734e
movl $0x2ec, %ecx            # imm = 0x2EC
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9c0(%rsp), %rax
movswl 0x4c6(%rax), %eax
cmpl $0x1, %eax
jne 0xcaaec
movq 0xe9c8(%rsp), %rax
cmpl $0x0, 0x638(%rax)
jl 0xcaa60
movq 0xe9c8(%rsp), %rax
cmpl $0x1, 0x638(%rax)
jle 0xcaaea
leaq 0xb180(%rsp), %rdi
movq 0xe9c8(%rsp), %rax
movl 0x638(%rax), %edx
leaq 0x12ca73(%rip), %rsi    # 0x1f74f0
movb $0x0, %al
callq 0x5b9c0
leaq 0xa980(%rsp), %rdi
leaq 0xb180(%rsp), %rcx
leaq 0x1075e7(%rip), %rsi    # 0x1d2082
leaq 0x12caaf(%rip), %rdx    # 0x1f7551
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0xa980(%rsp), %r8
leaq 0x10756d(%rip), %rsi    # 0x1d2034
leaq 0x12c880(%rip), %rdx    # 0x1f734e
movl $0x2f2, %ecx            # imm = 0x2F2
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
jmp 0xcaaec
movq 0xe9c0(%rsp), %rax
movswl 0x4c4(%rax), %eax
cmpl $0x1, %eax
jne 0xcabb6
movq 0xe9c8(%rsp), %rax
cmpl $0x0, 0x650(%rax)
jl 0xcab2a
movq 0xe9c8(%rsp), %rax
cmpl $0x3, 0x650(%rax)
jle 0xcabb4
leaq 0xa180(%rsp), %rdi
movq 0xe9c8(%rsp), %rax
movl 0x650(%rax), %edx
leaq 0x12ca6f(%rip), %rsi    # 0x1f75b6
movb $0x0, %al
callq 0x5b9c0
leaq 0x9980(%rsp), %rdi
leaq 0xa180(%rsp), %rcx
leaq 0x10751d(%rip), %rsi    # 0x1d2082
leaq 0x12ca9c(%rip), %rdx    # 0x1f7608
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x9980(%rsp), %r8
leaq 0x1074a3(%rip), %rsi    # 0x1d2034
leaq 0x12c7b6(%rip), %rdx    # 0x1f734e
movl $0x2fa, %ecx            # imm = 0x2FA
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
jmp 0xcabb6
movq 0xe9c0(%rsp), %rax
movswl 0x4be(%rax), %eax
cmpl $0x1, %eax
jne 0xcacbf
movq 0xe9c8(%rsp), %rax
cmpl $0x0, 0x660(%rax)
jl 0xcabf4
movq 0xe9c8(%rsp), %rax
cmpl $0x3, 0x660(%rax)
jle 0xcac7e
leaq 0x9180(%rsp), %rdi
movq 0xe9c8(%rsp), %rax
movl 0x660(%rax), %edx
leaq 0x12ca4a(%rip), %rsi    # 0x1f765b
movb $0x0, %al
callq 0x5b9c0
leaq 0x8980(%rsp), %rdi
leaq 0x9180(%rsp), %rcx
leaq 0x107453(%rip), %rsi    # 0x1d2082
leaq 0x12ca79(%rip), %rdx    # 0x1f76af
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x8980(%rsp), %r8
leaq 0x1073d9(%rip), %rsi    # 0x1d2034
leaq 0x12c6ec(%rip), %rdx    # 0x1f734e
movl $0x302, %ecx            # imm = 0x302
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9b0(%rsp), %rax
movswl 0x3e(%rax), %eax
cmpl $0x1, %eax
jne 0xcacbd
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x0, %eax
jle 0xcacbb
movq 0x1792e6(%rip), %rax    # 0x243f90
movq (%rax), %rdi
leaq 0x12ca58(%rip), %rsi    # 0x1f770c
movb $0x0, %al
callq 0x84e0
jmp 0xcacbd
jmp 0xcacbf
movq 0xe9c0(%rsp), %rax
movswl 0x4c2(%rax), %eax
cmpl $0x1, %eax
jne 0xcaf9a
movq 0xe9c0(%rsp), %rdi
xorps %xmm0, %xmm0
leaq 0xe998(%rsp), %rsi
leaq 0xe988(%rsp), %rdx
leaq 0xe980(%rsp), %rcx
callq 0xa1970
cmpl $0x1, %eax
jne 0xcad71
leaq 0x8180(%rsp), %rdi
movq 0xe9c0(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x1076b6(%rip), %rsi    # 0x1d23d8
leaq 0x12cb9c(%rip), %rdx    # 0x1f78c5
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x8180(%rsp), %r8
leaq 0x1072e6(%rip), %rsi    # 0x1d2034
leaq 0x12c5f9(%rip), %rdx    # 0x1f734e
movl $0x30f, %ecx            # imm = 0x30F
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9c0(%rsp), %rdi
movsd 0x1074c7(%rip), %xmm0   # 0x1d2248
leaq 0xe990(%rsp), %rsi
leaq 0xe988(%rsp), %rdx
leaq 0xe980(%rsp), %rcx
callq 0xa1970
cmpl $0x1, %eax
jne 0xcae10
leaq 0x7980(%rsp), %rdi
movq 0xe9c0(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x107617(%rip), %rsi    # 0x1d23d8
leaq 0x12cb43(%rip), %rdx    # 0x1f790b
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x7980(%rsp), %r8
leaq 0x107247(%rip), %rsi    # 0x1d2034
leaq 0x12c55a(%rip), %rdx    # 0x1f734e
movl $0x310, %ecx            # imm = 0x310
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9c0(%rsp), %rax
movswl 0x2d8(%rax), %eax
cmpl $0x0, %eax
jne 0xcaf98
movq 0xe9c0(%rsp), %rax
cmpl $0x1, 0x40(%rax)
je 0xcaf98
movsd 0x107406(%rip), %xmm1   # 0x1d2248
addsd 0xe998(%rsp), %xmm1
movsd 0x1073f5(%rip), %xmm0   # 0x1d2248
addsd 0xe990(%rsp), %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0xcaee5
leaq 0x7180(%rsp), %rdi
leaq 0x12cad7(%rip), %rsi    # 0x1f794f
movb $0x0, %al
callq 0x5b9c0
leaq 0x6980(%rsp), %rdi
leaq 0x7180(%rsp), %rcx
leaq 0x1071ec(%rip), %rsi    # 0x1d2082
leaq 0x12cb64(%rip), %rdx    # 0x1f7a01
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x6980(%rsp), %r8
leaq 0x107172(%rip), %rsi    # 0x1d2034
leaq 0x12c485(%rip), %rdx    # 0x1f734e
movl $0x31a, %ecx            # imm = 0x31A
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movsd 0xe990(%rsp), %xmm0
movsd 0x1078da(%rip), %xmm1   # 0x1d27d0
ucomisd %xmm1, %xmm0
jne 0xcaf96
jp 0xcaf96
movsd 0xe988(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcaf96
jp 0xcaf96
leaq 0x6180(%rsp), %rdi
leaq 0x12cafe(%rip), %rsi    # 0x1f7a27
movb $0x0, %al
callq 0x5b9c0
leaq 0x5980(%rsp), %rdi
leaq 0x6180(%rsp), %rcx
leaq 0x10713b(%rip), %rsi    # 0x1d2082
leaq 0x12cba8(%rip), %rdx    # 0x1f7af6
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x5980(%rsp), %r8
leaq 0x1070c1(%rip), %rsi    # 0x1d2034
leaq 0x12c3d4(%rip), %rdx    # 0x1f734e
movl $0x31f, %ecx            # imm = 0x31F
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
jmp 0xcaf98
jmp 0xcaf9a
movq 0xe9c0(%rsp), %rax
movswl 0x4b8(%rax), %eax
cmpl $0x1, %eax
jne 0xcb074
movq 0xe9b0(%rsp), %rax
movswl 0x18(%rax), %eax
cmpl $0x1, %eax
je 0xcaff6
movq 0xe9b0(%rsp), %rax
movswl 0x16(%rax), %eax
cmpl $0x1, %eax
je 0xcaff6
movq 0xe9b0(%rsp), %rax
movswl 0x1a(%rax), %eax
cmpl $0x1, %eax
je 0xcaff6
movq 0xe9b0(%rsp), %rax
movswl 0x1c(%rax), %eax
cmpl $0x1, %eax
jne 0xcb072
leaq 0x5180(%rsp), %rdi
leaq 0x12cb1c(%rip), %rsi    # 0x1f7b21
movb $0x0, %al
callq 0x5b9c0
leaq 0x4980(%rsp), %rdi
leaq 0x5180(%rsp), %rcx
leaq 0x10705f(%rip), %rsi    # 0x1d2082
leaq 0x12cb46(%rip), %rdx    # 0x1f7b70
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x4980(%rsp), %r8
leaq 0x106fe5(%rip), %rsi    # 0x1d2034
leaq 0x12c2f8(%rip), %rdx    # 0x1f734e
movl $0x329, %ecx            # imm = 0x329
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
jmp 0xcb074
movq 0xe9c0(%rsp), %rax
movswl 0x4bc(%rax), %eax
cmpl $0x1, %eax
jne 0xcb098
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x8(%rax)
jmp 0xcb0a6
movq 0xe9b0(%rsp), %rax
movw $0x0, 0x8(%rax)
movq 0xe9c0(%rsp), %rax
movswl 0x238(%rax), %eax
cmpl $0x1, %eax
jne 0xcb0ca
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x4(%rax)
jmp 0xcb0d8
movq 0xe9b0(%rsp), %rax
movw $0x0, 0x4(%rax)
movq 0xe9b0(%rsp), %rax
movw $0x0, 0x812(%rax)
movq 0xe9b0(%rsp), %rax
movw $0x0, 0x810(%rax)
movq 0xe9c0(%rsp), %rax
movswl 0x4b6(%rax), %eax
cmpl $0x1, %eax
jne 0xcb177
movq 0xe9b0(%rsp), %rax
movsd 0x7d8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcb12b
jp 0xcb12b
jmp 0xcb177
movq 0xe9c0(%rsp), %rax
movswl 0x4c2(%rax), %eax
cmpl $0x1, %eax
jne 0xcb150
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x812(%rax)
movq 0xe9c0(%rsp), %rax
movswl 0x4bc(%rax), %eax
cmpl $0x1, %eax
jne 0xcb175
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x810(%rax)
jmp 0xcb177
movq 0xe9c0(%rsp), %rax
movswl 0x4bc(%rax), %eax
cmpl $0x1, %eax
jne 0xcb1f1
movq 0xe9c0(%rsp), %rax
cmpl $0x2, 0x160(%rax)
jne 0xcb1f1
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x0, %eax
jle 0xcb1f1
movq 0xe9c8(%rsp), %rax
cmpl $0x1, 0x678(%rax)
jne 0xcb1f1
movq 0x178dc8(%rip), %rax    # 0x243f90
movq (%rax), %rdi
leaq 0x12ca0a(%rip), %rsi    # 0x1f7bdc
movb $0x0, %al
callq 0x84e0
movq 0x178db0(%rip), %rax    # 0x243f90
movq (%rax), %rdi
leaq 0x12ca77(%rip), %rsi    # 0x1f7c61
movb $0x0, %al
callq 0x84e0
movq 0xe9b0(%rsp), %rax
movswl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xcb27e
leaq 0x4180(%rsp), %rdi
leaq 0x12cab5(%rip), %rsi    # 0x1f7cc6
movb $0x0, %al
callq 0x5b9c0
leaq 0x3980(%rsp), %rdi
leaq 0x4180(%rsp), %rcx
leaq 0x106e53(%rip), %rsi    # 0x1d2082
leaq 0x11fd17(%rip), %rdx    # 0x1eaf4d
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x3980(%rsp), %r8
leaq 0x106dd9(%rip), %rsi    # 0x1d2034
leaq 0x12c0ec(%rip), %rdx    # 0x1f734e
movl $0x34e, %ecx            # imm = 0x34E
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9b0(%rsp), %rax
movswl 0x1c(%rax), %eax
cmpl $0x1, %eax
jne 0xcb2b1
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x0, %eax
jle 0xcb2b1
leaq 0x12ca32(%rip), %rdi    # 0x1f7cdc
movb $0x0, %al
callq 0x8030
movq 0xe9b0(%rsp), %rax
movswl 0x12(%rax), %eax
cmpl $0x1, %eax
jne 0xcb392
movq 0xe9b0(%rsp), %rax
movw $0x0, 0x24(%rax)
movq 0xe9b0(%rsp), %rax
movw $0x0, 0x26(%rax)
movq 0xe9b0(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xcb310
jmp 0xcb2f7
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0xcb312
jmp 0xcb302
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0xcb34a
jmp 0xcb390
jmp 0xcb390
movq 0xe9c0(%rsp), %rax
movswl 0x4c4(%rax), %eax
cmpl $0x1, %eax
je 0xcb33a
movq 0xe9c0(%rsp), %rax
movswl 0x4be(%rax), %eax
cmpl $0x1, %eax
jne 0xcb348
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x24(%rax)
jmp 0xcb390
movq 0xe9c0(%rsp), %rax
movswl 0x4c4(%rax), %eax
cmpl $0x1, %eax
jne 0xcb36c
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x24(%rax)
movq 0xe9c0(%rsp), %rax
movswl 0x4be(%rax), %eax
cmpl $0x1, %eax
jne 0xcb38e
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x26(%rax)
jmp 0xcb390
jmp 0xcb392
movq 0xe9c8(%rsp), %rdi
movq 0xe9c0(%rsp), %rsi
movq 0xe9b8(%rsp), %rdx
movq 0xe9b0(%rsp), %rcx
callq 0xcbd90
cmpl $0x1, %eax
jne 0xcb429
leaq 0x3180(%rsp), %rdi
movq 0xe9b0(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0x106ffe(%rip), %rsi    # 0x1d23d8
leaq 0x12c995(%rip), %rdx    # 0x1f7d76
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x3180(%rsp), %r8
leaq 0x106c2e(%rip), %rsi    # 0x1d2034
leaq 0x12bf41(%rip), %rdx    # 0x1f734e
movl $0x383, %ecx            # imm = 0x383
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9b0(%rsp), %rax
movsd 0x818(%rax), %xmm0
movq 0xe9b8(%rsp), %rax
ucomisd 0xf30(%rax), %xmm0
jbe 0xcb5d1
movq 0xe9b0(%rsp), %rax
movswl 0x834(%rax), %eax
cmpl $0x1, %eax
jne 0xcb503
leaq 0x2980(%rsp), %rdi
movq 0xe9b0(%rsp), %rax
movsd 0x818(%rax), %xmm0
movq 0xe9b8(%rsp), %rax
movsd 0xf30(%rax), %xmm1
leaq 0x12c90a(%rip), %rsi    # 0x1f7da0
movb $0x2, %al
callq 0x5b9c0
leaq 0x2180(%rsp), %rdi
leaq 0x2980(%rsp), %rcx
leaq 0x106bce(%rip), %rsi    # 0x1d2082
leaq 0x12c9ca(%rip), %rdx    # 0x1f7e85
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x2180(%rsp), %r8
leaq 0x106b54(%rip), %rsi    # 0x1d2034
leaq 0x12be67(%rip), %rdx    # 0x1f734e
movl $0x38c, %ecx            # imm = 0x38C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9b0(%rsp), %rax
movswl 0x87c(%rax), %eax
cmpl $0x1, %eax
jne 0xcb5cf
movq 0xe9b0(%rsp), %rax
movswl 0x844(%rax), %eax
cmpl $0x0, %eax
jne 0xcb5cf
leaq 0x1980(%rsp), %rdi
movq 0xe9b0(%rsp), %rax
movsd 0x818(%rax), %xmm0
movq 0xe9b8(%rsp), %rax
movsd 0xf30(%rax), %xmm1
leaq 0x12c93a(%rip), %rsi    # 0x1f7e9c
movb $0x2, %al
callq 0x5b9c0
leaq 0x1180(%rsp), %rdi
leaq 0x1980(%rsp), %rcx
leaq 0x106b02(%rip), %rsi    # 0x1d2082
leaq 0x12cbda(%rip), %rdx    # 0x1f8161
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x1180(%rsp), %r8
leaq 0x106a88(%rip), %rsi    # 0x1d2034
leaq 0x12bd9b(%rip), %rdx    # 0x1f734e
movl $0x392, %ecx            # imm = 0x392
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
jmp 0xcb5d1
movq 0xe9c8(%rsp), %rdi
movq 0xe9c0(%rsp), %rsi
movq 0xe9b8(%rsp), %rdx
movq 0xe9b0(%rsp), %rcx
callq 0xce1b0
cmpl $0x1, %eax
jne 0xcb668
leaq 0x980(%rsp), %rdi
movq 0xe9b0(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0x106dbf(%rip), %rsi    # 0x1d23d8
leaq 0x12cb9d(%rip), %rdx    # 0x1f81bd
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x980(%rsp), %r8
leaq 0x1069ef(%rip), %rsi    # 0x1d2034
leaq 0x12bd02(%rip), %rdx    # 0x1f734e
movl $0x3a0, %ecx            # imm = 0x3A0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
movq 0xe9c0(%rsp), %rdi
movq 0xe9b0(%rsp), %rsi
callq 0xd03f0
cmpl $0x1, %eax
jne 0xcb6ef
leaq 0x180(%rsp), %rdi
movq 0xe9b0(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0x106d38(%rip), %rsi    # 0x1d23d8
leaq 0x12cb51(%rip), %rdx    # 0x1f81f8
movb $0x0, %al
callq 0x5b9c0
movq 0xe9b0(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x180(%rsp), %r8
leaq 0x106968(%rip), %rsi    # 0x1d2034
leaq 0x12bc7b(%rip), %rdx    # 0x1f734e
movl $0x3a5, %ecx            # imm = 0x3A5
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xe9d4(%rsp)
jmp 0xcbd66
callq 0x2edc0
movl %eax, %esi
leaq 0x140(%rsp), %rdi
callq 0x2ef50
leaq 0x128(%rsp), %rdi
callq 0x2f070
movq 0xe9c0(%rsp), %rax
movswl 0x130(%rax), %eax
cmpl $0x1, %eax
jne 0xcb779
movq 0xe9c0(%rsp), %rax
movswl 0x236(%rax), %eax
cmpl $0x0, %eax
jne 0xcb779
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x0, %eax
jle 0xcb777
leaq 0x12cacd(%rip), %rdi    # 0x1f8220
xorl %eax, %eax
callq 0x8030
jmp 0xcb75c
jmp 0xcb777
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
jmp 0xcbd4a
jmp 0xcb779
movl $0x0, 0xe9ac(%rsp)
movl 0xe9ac(%rsp), %eax
movq 0xe9b0(%rsp), %rcx
cmpl 0x854(%rcx), %eax
jge 0xcb9cc
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x1, %eax
jle 0xcb7dc
movl 0xe9ac(%rsp), %esi
incl %esi
movq 0xe9b0(%rsp), %rax
movl 0x854(%rax), %edx
leaq 0x12cb08(%rip), %rdi    # 0x1f82d9
xorl %eax, %eax
callq 0x8030
jmp 0xcb7da
jmp 0xcb7dc
movl $0x0, 0xe9a8(%rsp)
movl 0xe9a8(%rsp), %eax
movq 0xe9b0(%rsp), %rcx
movq 0x870(%rcx), %rcx
movslq 0xe9ac(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xcb9b4
movq 0xe9b0(%rsp), %rax
movswl 0x6c88(%rax), %eax
cmpl $0x1, %eax
jle 0xcb881
movl 0xe9a8(%rsp), %esi
incl %esi
movq 0xe9b0(%rsp), %rax
movq 0x870(%rax), %rax
movslq 0xe9ac(%rsp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x12caa2(%rip), %rdi    # 0x1f82ee
xorl %eax, %eax
callq 0x8030
jmp 0xcb855
movq 0xe9b0(%rsp), %rax
movq 0x9c8(%rax), %rax
movslq 0xe9ac(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x12ca8b(%rip), %rdi    # 0x1f8301
xorl %eax, %eax
callq 0x8030
jmp 0xcb87f
jmp 0xcb881
movq 0xe9b0(%rsp), %rax
movq 0x9c8(%rax), %rax
movslq 0xe9ac(%rsp), %rcx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
movl %eax, 0xe9a4(%rsp)
cmpl $0x0, 0xe9a4(%rsp)
jl 0xcb99c
movq 0xe9c8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xe9c0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xe9b8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe9b0(%rsp), %rax
movq %rax, 0xf0(%rsp)
movl 0xe9ac(%rsp), %eax
movl %eax, 0xf8(%rsp)
movl 0xe9a8(%rsp), %eax
movl %eax, 0xfc(%rsp)
movl 0xe9a4(%rsp), %eax
movl %eax, 0x100(%rsp)
leaq 0x108(%rsp), %rdi
leaq 0x140(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
callq 0xd1750
jmp 0xcb93c
leaq 0x128(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x2f080
jmp 0xcb953
leaq 0x108(%rsp), %rdi
callq 0x2f0b0
movl 0xe9a4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xe9a4(%rsp)
jmp 0xcb8a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x2f0b0
jmp 0xcbd4a
jmp 0xcb99e
movl 0xe9a8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe9a8(%rsp)
jmp 0xcb7e7
jmp 0xcb9b6
movl 0xe9ac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe9ac(%rsp)
jmp 0xcb784
leaq 0x128(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x2f0c0
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x2f0f0
movq %rax, 0xc0(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x2f120
testb $0x1, %al
jne 0xcba21
jmp 0xcba7e
leaq 0xc8(%rsp), %rdi
callq 0x2f160
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2f170
movl %eax, 0x8(%rsp)
jmp 0xcba49
movl 0x8(%rsp), %eax
cmpl $0x0, %eax
je 0xcba6d
movl $0x1, 0xe9d4(%rsp)
movl $0x1, 0xb4(%rsp)
jmp 0xcbd2e
jmp 0xcba6f
leaq 0xc8(%rsp), %rdi
callq 0x2f1f0
jmp 0xcba06
leaq 0x128(%rsp), %rdi
callq 0x2f210
movq 0xe9b0(%rsp), %rax
cmpl $0x1, 0xa60(%rax)
jle 0xcbd07
callq 0x2edc0
movl %eax, 0x4(%rsp)
jmp 0xcbaab
movl 0x4(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x2ef50
jmp 0xcbabb
leaq 0x58(%rsp), %rdi
callq 0x2f070
movl $0x0, 0xe9ac(%rsp)
movl 0xe9ac(%rsp), %eax
movq 0xe9b0(%rsp), %rcx
cmpl 0x854(%rcx), %eax
jge 0xcbc30
movl $0x0, 0xe9a8(%rsp)
movl 0xe9a8(%rsp), %eax
movq 0xe9b0(%rsp), %rcx
movq 0x870(%rcx), %rcx
movslq 0xe9ac(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xcbc18
movl $0x0, 0xe9a0(%rsp)
movl 0xe9a0(%rsp), %eax
movq 0xe9b0(%rsp), %rcx
movq 0x998(%rcx), %rcx
movslq 0xe9ac(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xcbc00
movq 0xe9b0(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0xe9ac(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0xe9a8(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0xe9a0(%rsp), %eax
movl %eax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xd1910
jmp 0xcbb93
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2f080
jmp 0xcbba4
leaq 0x48(%rsp), %rdi
callq 0x2f0b0
movl 0xe9a0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe9a0(%rsp)
jmp 0xcbb28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
jmp 0xcbcf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2f0b0
jmp 0xcbcf1
jmp 0xcbc02
movl 0xe9a8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe9a8(%rsp)
jmp 0xcbaf6
jmp 0xcbc1a
movl 0xe9ac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe9ac(%rsp)
jmp 0xcbad0
leaq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2f0c0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2f0f0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2f120
testb $0x1, %al
jne 0xcbc6d
jmp 0xcbcb9
leaq 0x20(%rsp), %rdi
callq 0x2f160
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2f170
movl %eax, (%rsp)
jmp 0xcbc8b
movl (%rsp), %eax
cmpl $0x0, %eax
je 0xcbcab
movl $0x1, 0xe9d4(%rsp)
movl $0x1, 0xb4(%rsp)
jmp 0xcbcce
jmp 0xcbcad
leaq 0x20(%rsp), %rdi
callq 0x2f1f0
jmp 0xcbc58
leaq 0x58(%rsp), %rdi
callq 0x2f210
movl $0x0, 0xb4(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2f230
leaq 0x70(%rsp), %rdi
callq 0x2f290
movl 0xb4(%rsp), %eax
testl %eax, %eax
jne 0xcbd2e
jmp 0xcbcef
jmp 0xcbd07
leaq 0x58(%rsp), %rdi
callq 0x2f230
leaq 0x70(%rsp), %rdi
callq 0x2f290
jmp 0xcbd4a
movq 0xe9b0(%rsp), %rax
movw $0x1, 0x748a(%rax)
movl $0x0, 0xe9d4(%rsp)
movl $0x1, 0xb4(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x2f230
leaq 0x140(%rsp), %rdi
callq 0x2f290
jmp 0xcbd66
leaq 0x128(%rsp), %rdi
callq 0x2f230
leaq 0x140(%rsp), %rdi
callq 0x2f290
jmp 0xcbd75
movl 0xe9d4(%rsp), %eax
addq $0xe9d8, %rsp           # imm = 0xE9D8
retq
movq 0x120(%rsp), %rdi
callq 0x8640
nopw %cs:(%rax,%rax)