// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xf9d8, %rsp           # imm = 0xF9D8
movq %rdi, 0xf9c8(%rsp)
movq %rsi, 0xf9c0(%rsp)
movq %rdx, 0xf9b8(%rsp)
movq %rcx, 0xf9b0(%rsp)
movq 0xf9b0(%rsp), %rax
movswl (%rax), %eax
cmpl $0x0, %eax
jne 0xba249
movq 0xf9b0(%rsp), %rax
movswl 0x6bf0(%rax), %eax
cmpl $0x0, %eax
jle 0xba239
leaq 0x11e3d2(%rip), %rdi    # 0x1d8604
movb $0x0, %al
callq 0x8030
movl $0x0, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9b0(%rsp), %rax
movswl 0x6bf0(%rax), %eax
cmpl $0x0, %eax
jle 0xba26b
leaq 0x11e3d4(%rip), %rdi    # 0x1d8638
movb $0x0, %al
callq 0x8030
jmp 0xba26d
movq 0xf9b0(%rsp), %rax
cmpl $0x1, 0x7f4(%rax)
jne 0xba312
movq 0xf9c0(%rsp), %rax
movswl 0x320(%rax), %eax
cmpl $0x0, %eax
jne 0xba312
leaq 0xf180(%rsp), %rdi
leaq 0x11e3a6(%rip), %rsi    # 0x1d864b
movb $0x0, %al
callq 0x5b9c0
leaq 0xe980(%rsp), %rdi
leaq 0xf180(%rsp), %rcx
leaq 0xfcdbf(%rip), %rsi     # 0x1b7082
leaq 0x11e452(%rip), %rdx    # 0x1d871c
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0xe980(%rsp), %r8
leaq 0xfcd45(%rip), %rsi     # 0x1b7034
leaq 0x11e45f(%rip), %rdx    # 0x1d8755
movl $0x2d8, %ecx            # imm = 0x2D8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9c8(%rsp), %rax
cmpl $0x0, 0x5a0(%rax)
jl 0xba338
movq 0xf9c8(%rsp), %rax
cmpl $0x5, 0x5a0(%rax)
jle 0xba3c2
leaq 0xe180(%rsp), %rdi
movq 0xf9c8(%rsp), %rax
movl 0x5a0(%rax), %edx
leaq 0x11e413(%rip), %rsi    # 0x1d8768
movb $0x0, %al
callq 0x5b9c0
leaq 0xd980(%rsp), %rdi
leaq 0xe180(%rsp), %rcx
leaq 0xfcd0f(%rip), %rsi     # 0x1b7082
leaq 0x11e446(%rip), %rdx    # 0x1d87c0
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0xd980(%rsp), %r8
leaq 0xfcc95(%rip), %rsi     # 0x1b7034
leaq 0x11e3af(%rip), %rdx    # 0x1d8755
movl $0x2dd, %ecx            # imm = 0x2DD
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9c8(%rsp), %rax
cmpl $0x0, 0x620(%rax)
jl 0xba3e8
movq 0xf9c8(%rsp), %rax
cmpl $0x3, 0x620(%rax)
jle 0xba472
leaq 0xd180(%rsp), %rdi
movq 0xf9c8(%rsp), %rax
movl 0x620(%rax), %edx
leaq 0x11e42a(%rip), %rsi    # 0x1d882f
movb $0x0, %al
callq 0x5b9c0
leaq 0xc980(%rsp), %rdi
leaq 0xd180(%rsp), %rcx
leaq 0xfcc5f(%rip), %rsi     # 0x1b7082
leaq 0x11e462(%rip), %rdx    # 0x1d888c
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0xc980(%rsp), %r8
leaq 0xfcbe5(%rip), %rsi     # 0x1b7034
leaq 0x11e2ff(%rip), %rdx    # 0x1d8755
movl $0x2e2, %ecx            # imm = 0x2E2
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9c0(%rsp), %rax
movswl 0x332(%rax), %eax
cmpl $0x1, %eax
jne 0xba53c
movq 0xf9c8(%rsp), %rax
cmpl $0x0, 0x638(%rax)
jl 0xba4b0
movq 0xf9c8(%rsp), %rax
cmpl $0x1, 0x638(%rax)
jle 0xba53a
leaq 0xc180(%rsp), %rdi
movq 0xf9c8(%rsp), %rax
movl 0x638(%rax), %edx
leaq 0x11e42a(%rip), %rsi    # 0x1d88f7
movb $0x0, %al
callq 0x5b9c0
leaq 0xb980(%rsp), %rdi
leaq 0xc180(%rsp), %rcx
leaq 0xfcb97(%rip), %rsi     # 0x1b7082
leaq 0x11e466(%rip), %rdx    # 0x1d8958
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0xb980(%rsp), %r8
leaq 0xfcb1d(%rip), %rsi     # 0x1b7034
leaq 0x11e237(%rip), %rdx    # 0x1d8755
movl $0x2e8, %ecx            # imm = 0x2E8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
jmp 0xba53c
movq 0xf9c0(%rsp), %rax
movswl 0x330(%rax), %eax
cmpl $0x1, %eax
jne 0xba606
movq 0xf9c8(%rsp), %rax
cmpl $0x0, 0x650(%rax)
jl 0xba57a
movq 0xf9c8(%rsp), %rax
cmpl $0x3, 0x650(%rax)
jle 0xba604
leaq 0xb180(%rsp), %rdi
movq 0xf9c8(%rsp), %rax
movl 0x650(%rax), %edx
leaq 0x11e426(%rip), %rsi    # 0x1d89bd
movb $0x0, %al
callq 0x5b9c0
leaq 0xa980(%rsp), %rdi
leaq 0xb180(%rsp), %rcx
leaq 0xfcacd(%rip), %rsi     # 0x1b7082
leaq 0x11e453(%rip), %rdx    # 0x1d8a0f
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0xa980(%rsp), %r8
leaq 0xfca53(%rip), %rsi     # 0x1b7034
leaq 0x11e16d(%rip), %rdx    # 0x1d8755
movl $0x2f0, %ecx            # imm = 0x2F0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
jmp 0xba606
movq 0xf9c0(%rsp), %rax
movswl 0x32a(%rax), %eax
cmpl $0x1, %eax
jne 0xba70f
movq 0xf9c8(%rsp), %rax
cmpl $0x0, 0x660(%rax)
jl 0xba644
movq 0xf9c8(%rsp), %rax
cmpl $0x3, 0x660(%rax)
jle 0xba6ce
leaq 0xa180(%rsp), %rdi
movq 0xf9c8(%rsp), %rax
movl 0x660(%rax), %edx
leaq 0x11e401(%rip), %rsi    # 0x1d8a62
movb $0x0, %al
callq 0x5b9c0
leaq 0x9980(%rsp), %rdi
leaq 0xa180(%rsp), %rcx
leaq 0xfca03(%rip), %rsi     # 0x1b7082
leaq 0x11e430(%rip), %rdx    # 0x1d8ab6
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x9980(%rsp), %r8
leaq 0xfc989(%rip), %rsi     # 0x1b7034
leaq 0x11e0a3(%rip), %rdx    # 0x1d8755
movl $0x2f8, %ecx            # imm = 0x2F8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9b0(%rsp), %rax
movswl 0x36(%rax), %eax
cmpl $0x1, %eax
jne 0xba70d
movq 0xf9b0(%rsp), %rax
movswl 0x6bf0(%rax), %eax
cmpl $0x0, %eax
jle 0xba70b
movq 0x16a896(%rip), %rax    # 0x224f90
movq (%rax), %rdi
leaq 0x11e40f(%rip), %rsi    # 0x1d8b13
movb $0x0, %al
callq 0x84e0
jmp 0xba70d
jmp 0xba70f
movq 0xf9c0(%rsp), %rax
movswl 0x32e(%rax), %eax
cmpl $0x1, %eax
jne 0xbaa73
movq 0xf9c0(%rsp), %rdi
xorps %xmm0, %xmm0
leaq 0xf998(%rsp), %rsi
leaq 0xf988(%rsp), %rdx
leaq 0xf980(%rsp), %rcx
callq 0x95920
cmpl $0x1, %eax
jne 0xba7c1
leaq 0x9180(%rsp), %rdi
movq 0xf9c0(%rsp), %rcx
addq $0xb84, %rcx            # imm = 0xB84
leaq 0xfcc66(%rip), %rsi     # 0x1b73d8
leaq 0x11e553(%rip), %rdx    # 0x1d8ccc
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x9180(%rsp), %r8
leaq 0xfc896(%rip), %rsi     # 0x1b7034
leaq 0x11dfb0(%rip), %rdx    # 0x1d8755
movl $0x305, %ecx            # imm = 0x305
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9c0(%rsp), %rdi
movsd 0xfca77(%rip), %xmm0    # 0x1b7248
leaq 0xf990(%rsp), %rsi
leaq 0xf988(%rsp), %rdx
leaq 0xf980(%rsp), %rcx
callq 0x95920
cmpl $0x1, %eax
jne 0xba860
leaq 0x8980(%rsp), %rdi
movq 0xf9c0(%rsp), %rcx
addq $0xb84, %rcx            # imm = 0xB84
leaq 0xfcbc7(%rip), %rsi     # 0x1b73d8
leaq 0x11e4fa(%rip), %rdx    # 0x1d8d12
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x8980(%rsp), %r8
leaq 0xfc7f7(%rip), %rsi     # 0x1b7034
leaq 0x11df11(%rip), %rdx    # 0x1d8755
movl $0x306, %ecx            # imm = 0x306
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movsd 0xf998(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xba8fb
leaq 0x8180(%rsp), %rdi
movsd 0xf998(%rsp), %xmm0
leaq 0x11e4c8(%rip), %rsi    # 0x1d8d56
movb $0x1, %al
callq 0x5b9c0
leaq 0x7980(%rsp), %rdi
leaq 0x8180(%rsp), %rcx
leaq 0xfc7d6(%rip), %rsi     # 0x1b7082
leaq 0x11e595(%rip), %rdx    # 0x1d8e48
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x7980(%rsp), %r8
leaq 0xfc75c(%rip), %rsi     # 0x1b7034
leaq 0x11de76(%rip), %rdx    # 0x1d8755
movl $0x30a, %ecx            # imm = 0x30A
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9c0(%rsp), %rax
movswl 0x110(%rax), %eax
cmpl $0x0, %eax
jne 0xbaa71
movsd 0xfc92d(%rip), %xmm1    # 0x1b7248
addsd 0xf998(%rsp), %xmm1
movsd 0xfc91c(%rip), %xmm0    # 0x1b7248
addsd 0xf990(%rsp), %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0xba9be
leaq 0x7180(%rsp), %rdi
leaq 0x11e507(%rip), %rsi    # 0x1d8e58
movb $0x0, %al
callq 0x5b9c0
leaq 0x6980(%rsp), %rdi
leaq 0x7180(%rsp), %rcx
leaq 0xfc713(%rip), %rsi     # 0x1b7082
leaq 0x11e594(%rip), %rdx    # 0x1d8f0a
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x6980(%rsp), %r8
leaq 0xfc699(%rip), %rsi     # 0x1b7034
leaq 0x11ddb3(%rip), %rdx    # 0x1d8755
movl $0x310, %ecx            # imm = 0x310
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movsd 0xf990(%rsp), %xmm0
movsd 0xfce01(%rip), %xmm1    # 0x1b77d0
ucomisd %xmm1, %xmm0
jne 0xbaa6f
jp 0xbaa6f
movsd 0xf988(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xbaa6f
jp 0xbaa6f
leaq 0x6180(%rsp), %rdi
leaq 0x11e52e(%rip), %rsi    # 0x1d8f30
movb $0x0, %al
callq 0x5b9c0
leaq 0x5980(%rsp), %rdi
leaq 0x6180(%rsp), %rcx
leaq 0xfc662(%rip), %rsi     # 0x1b7082
leaq 0x11e5d8(%rip), %rdx    # 0x1d8fff
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x5980(%rsp), %r8
leaq 0xfc5e8(%rip), %rsi     # 0x1b7034
leaq 0x11dd02(%rip), %rdx    # 0x1d8755
movl $0x315, %ecx            # imm = 0x315
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
jmp 0xbaa71
jmp 0xbaa73
movq 0xf9c0(%rsp), %rax
movswl 0x324(%rax), %eax
cmpl $0x1, %eax
jne 0xbab4d
movq 0xf9b0(%rsp), %rax
movswl 0xe(%rax), %eax
cmpl $0x1, %eax
je 0xbaacf
movq 0xf9b0(%rsp), %rax
movswl 0xc(%rax), %eax
cmpl $0x1, %eax
je 0xbaacf
movq 0xf9b0(%rsp), %rax
movswl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xbaacf
movq 0xf9b0(%rsp), %rax
movswl 0x12(%rax), %eax
cmpl $0x1, %eax
jne 0xbab4b
leaq 0x5180(%rsp), %rdi
leaq 0x11e54c(%rip), %rsi    # 0x1d902a
movb $0x0, %al
callq 0x5b9c0
leaq 0x4980(%rsp), %rdi
leaq 0x5180(%rsp), %rcx
leaq 0xfc586(%rip), %rsi     # 0x1b7082
leaq 0x11e576(%rip), %rdx    # 0x1d9079
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x4980(%rsp), %r8
leaq 0xfc50c(%rip), %rsi     # 0x1b7034
leaq 0x11dc26(%rip), %rdx    # 0x1d8755
movl $0x31f, %ecx            # imm = 0x31F
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
jmp 0xbab4d
movq 0xf9b0(%rsp), %rax
movswl 0x6(%rax), %eax
cmpl $0x1, %eax
jne 0xbabda
leaq 0x4180(%rsp), %rdi
leaq 0x11e578(%rip), %rsi    # 0x1d90e5
movb $0x0, %al
callq 0x5b9c0
leaq 0x3980(%rsp), %rdi
leaq 0x4180(%rsp), %rcx
leaq 0xfc4f7(%rip), %rsi     # 0x1b7082
leaq 0x111e53(%rip), %rdx    # 0x1cc9e5
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x3980(%rsp), %r8
leaq 0xfc47d(%rip), %rsi     # 0x1b7034
leaq 0x11db97(%rip), %rdx    # 0x1d8755
movl $0x325, %ecx            # imm = 0x325
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9b0(%rsp), %rax
movswl 0x12(%rax), %eax
cmpl $0x1, %eax
jne 0xbac0d
movq 0xf9b0(%rsp), %rax
movswl 0x6bf0(%rax), %eax
cmpl $0x0, %eax
jle 0xbac0d
leaq 0x11e4f5(%rip), %rdi    # 0x1d90fb
movb $0x0, %al
callq 0x8030
movq 0xf9b0(%rsp), %rax
movswl 0x8(%rax), %eax
cmpl $0x1, %eax
jne 0xbacee
movq 0xf9b0(%rsp), %rax
movw $0x0, 0x1c(%rax)
movq 0xf9b0(%rsp), %rax
movw $0x0, 0x1e(%rax)
movq 0xf9b0(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xbac6c
jmp 0xbac53
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0xbac6e
jmp 0xbac5e
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0xbaca6
jmp 0xbacec
jmp 0xbacec
movq 0xf9c0(%rsp), %rax
movswl 0x330(%rax), %eax
cmpl $0x1, %eax
je 0xbac96
movq 0xf9c0(%rsp), %rax
movswl 0x32a(%rax), %eax
cmpl $0x1, %eax
jne 0xbaca4
movq 0xf9b0(%rsp), %rax
movw $0x1, 0x1c(%rax)
jmp 0xbacec
movq 0xf9c0(%rsp), %rax
movswl 0x330(%rax), %eax
cmpl $0x1, %eax
jne 0xbacc8
movq 0xf9b0(%rsp), %rax
movw $0x1, 0x1c(%rax)
movq 0xf9c0(%rsp), %rax
movswl 0x32a(%rax), %eax
cmpl $0x1, %eax
jne 0xbacea
movq 0xf9b0(%rsp), %rax
movw $0x1, 0x1e(%rax)
jmp 0xbacec
jmp 0xbacee
movq 0xf9c8(%rsp), %rdi
movq 0xf9c0(%rsp), %rsi
movq 0xf9b8(%rsp), %rdx
movq 0xf9b0(%rsp), %rcx
callq 0xbb690
cmpl $0x1, %eax
jne 0xbad85
leaq 0x3180(%rsp), %rdi
movq 0xf9b0(%rsp), %rcx
addq $0x6bf2, %rcx           # imm = 0x6BF2
leaq 0xfc6a2(%rip), %rsi     # 0x1b73d8
leaq 0x11e458(%rip), %rdx    # 0x1d9195
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x3180(%rsp), %r8
leaq 0xfc2d2(%rip), %rsi     # 0x1b7034
leaq 0x11d9ec(%rip), %rdx    # 0x1d8755
movl $0x35a, %ecx            # imm = 0x35A
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9b0(%rsp), %rax
movsd 0x7d0(%rax), %xmm0
movq 0xf9b8(%rsp), %rax
ucomisd 0xf30(%rax), %xmm0
jbe 0xbaf2d
movq 0xf9b0(%rsp), %rax
movswl 0x7ec(%rax), %eax
cmpl $0x1, %eax
jne 0xbae5f
leaq 0x2980(%rsp), %rdi
movq 0xf9b0(%rsp), %rax
movsd 0x7d0(%rax), %xmm0
movq 0xf9b8(%rsp), %rax
movsd 0xf30(%rax), %xmm1
leaq 0x11e3cd(%rip), %rsi    # 0x1d91bf
movb $0x2, %al
callq 0x5b9c0
leaq 0x2180(%rsp), %rdi
leaq 0x2980(%rsp), %rcx
leaq 0xfc272(%rip), %rsi     # 0x1b7082
leaq 0x11e48d(%rip), %rdx    # 0x1d92a4
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x2180(%rsp), %r8
leaq 0xfc1f8(%rip), %rsi     # 0x1b7034
leaq 0x11d912(%rip), %rdx    # 0x1d8755
movl $0x363, %ecx            # imm = 0x363
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9b0(%rsp), %rax
movswl 0x834(%rax), %eax
cmpl $0x1, %eax
jne 0xbaf2b
movq 0xf9b0(%rsp), %rax
movswl 0x7f8(%rax), %eax
cmpl $0x0, %eax
jne 0xbaf2b
leaq 0x1980(%rsp), %rdi
movq 0xf9b0(%rsp), %rax
movsd 0x7d0(%rax), %xmm0
movq 0xf9b8(%rsp), %rax
movsd 0xf30(%rax), %xmm1
leaq 0x11e3fd(%rip), %rsi    # 0x1d92bb
movb $0x2, %al
callq 0x5b9c0
leaq 0x1180(%rsp), %rdi
leaq 0x1980(%rsp), %rcx
leaq 0xfc1a6(%rip), %rsi     # 0x1b7082
leaq 0x11e69d(%rip), %rdx    # 0x1d9580
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x1180(%rsp), %r8
leaq 0xfc12c(%rip), %rsi     # 0x1b7034
leaq 0x11d846(%rip), %rdx    # 0x1d8755
movl $0x369, %ecx            # imm = 0x369
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
jmp 0xbaf2d
movq 0xf9c8(%rsp), %rdi
movq 0xf9c0(%rsp), %rsi
movq 0xf9b8(%rsp), %rdx
movq 0xf9b0(%rsp), %rcx
callq 0xbd930
cmpl $0x1, %eax
jne 0xbafc4
leaq 0x980(%rsp), %rdi
movq 0xf9b0(%rsp), %rcx
addq $0x6bf2, %rcx           # imm = 0x6BF2
leaq 0xfc463(%rip), %rsi     # 0x1b73d8
leaq 0x11e660(%rip), %rdx    # 0x1d95dc
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x980(%rsp), %r8
leaq 0xfc093(%rip), %rsi     # 0x1b7034
leaq 0x11d7ad(%rip), %rdx    # 0x1d8755
movl $0x377, %ecx            # imm = 0x377
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
movq 0xf9c0(%rsp), %rdi
movq 0xf9b0(%rsp), %rsi
callq 0xbfb70
cmpl $0x1, %eax
jne 0xbb04b
leaq 0x180(%rsp), %rdi
movq 0xf9b0(%rsp), %rcx
addq $0x6bf2, %rcx           # imm = 0x6BF2
leaq 0xfc3dc(%rip), %rsi     # 0x1b73d8
leaq 0x11e614(%rip), %rdx    # 0x1d9617
movb $0x0, %al
callq 0x5b9c0
movq 0xf9b0(%rsp), %rdi
addq $0x6bf2, %rdi           # imm = 0x6BF2
leaq 0x180(%rsp), %r8
leaq 0xfc00c(%rip), %rsi     # 0x1b7034
leaq 0x11d726(%rip), %rdx    # 0x1d8755
movl $0x37c, %ecx            # imm = 0x37C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xf9d4(%rsp)
jmp 0xbb672
callq 0x2edc0
movl %eax, %esi
leaq 0x140(%rsp), %rdi
callq 0x2ef50
leaq 0x128(%rsp), %rdi
callq 0x2f070
movl $0x0, 0xf9ac(%rsp)
movl 0xf9ac(%rsp), %eax
movq 0xf9b0(%rsp), %rcx
cmpl 0x808(%rcx), %eax
jge 0xbb2d8
movq 0xf9b0(%rsp), %rax
movswl 0x6bf0(%rax), %eax
cmpl $0x1, %eax
jle 0xbb0e8
movl 0xf9ac(%rsp), %esi
incl %esi
movq 0xf9b0(%rsp), %rax
movl 0x808(%rax), %edx
leaq 0x11e57b(%rip), %rdi    # 0x1d963f
xorl %eax, %eax
callq 0x8030
jmp 0xbb0cd
jmp 0xbb0e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
jmp 0xbb656
movl $0x0, 0xf9a8(%rsp)
movl 0xf9a8(%rsp), %eax
movq 0xf9b0(%rsp), %rcx
movq 0x828(%rcx), %rcx
movslq 0xf9ac(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xbb2c0
movq 0xf9b0(%rsp), %rax
movswl 0x6bf0(%rax), %eax
cmpl $0x1, %eax
jle 0xbb18d
movl 0xf9a8(%rsp), %esi
incl %esi
movq 0xf9b0(%rsp), %rax
movq 0x828(%rax), %rax
movslq 0xf9ac(%rsp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x11e4fc(%rip), %rdi    # 0x1d9654
xorl %eax, %eax
callq 0x8030
jmp 0xbb161
movq 0xf9b0(%rsp), %rax
movq 0x950(%rax), %rax
movslq 0xf9ac(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x11e4e5(%rip), %rdi    # 0x1d9667
xorl %eax, %eax
callq 0x8030
jmp 0xbb18b
jmp 0xbb18d
movq 0xf9b0(%rsp), %rax
movq 0x950(%rax), %rax
movslq 0xf9ac(%rsp), %rcx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
movl %eax, 0xf9a4(%rsp)
cmpl $0x0, 0xf9a4(%rsp)
jl 0xbb2a8
movq 0xf9c8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xf9c0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xf9b8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xf9b0(%rsp), %rax
movq %rax, 0xf0(%rsp)
movl 0xf9ac(%rsp), %eax
movl %eax, 0xf8(%rsp)
movl 0xf9a8(%rsp), %eax
movl %eax, 0xfc(%rsp)
movl 0xf9a4(%rsp), %eax
movl %eax, 0x100(%rsp)
leaq 0x108(%rsp), %rdi
leaq 0x140(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
callq 0xc0a40
jmp 0xbb248
leaq 0x128(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x2f080
jmp 0xbb25f
leaq 0x108(%rsp), %rdi
callq 0x2f0b0
movl 0xf9a4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xf9a4(%rsp)
jmp 0xbb1b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x2f0b0
jmp 0xbb656
jmp 0xbb2aa
movl 0xf9a8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf9a8(%rsp)
jmp 0xbb0f3
jmp 0xbb2c2
movl 0xf9ac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf9ac(%rsp)
jmp 0xbb077
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 0xbb32d
jmp 0xbb38a
leaq 0xc8(%rsp), %rdi
callq 0x2f160
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2f170
movl %eax, 0x8(%rsp)
jmp 0xbb355
movl 0x8(%rsp), %eax
cmpl $0x0, %eax
je 0xbb379
movl $0x1, 0xf9d4(%rsp)
movl $0x1, 0xb4(%rsp)
jmp 0xbb63a
jmp 0xbb37b
leaq 0xc8(%rsp), %rdi
callq 0x2f1f0
jmp 0xbb312
leaq 0x128(%rsp), %rdi
callq 0x2f210
movq 0xf9b0(%rsp), %rax
cmpl $0x1, 0x9c8(%rax)
jle 0xbb613
callq 0x2edc0
movl %eax, 0x4(%rsp)
jmp 0xbb3b7
movl 0x4(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x2ef50
jmp 0xbb3c7
leaq 0x58(%rsp), %rdi
callq 0x2f070
movl $0x0, 0xf9ac(%rsp)
movl 0xf9ac(%rsp), %eax
movq 0xf9b0(%rsp), %rcx
cmpl 0x808(%rcx), %eax
jge 0xbb53c
movl $0x0, 0xf9a8(%rsp)
movl 0xf9a8(%rsp), %eax
movq 0xf9b0(%rsp), %rcx
movq 0x828(%rcx), %rcx
movslq 0xf9ac(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xbb524
movl $0x0, 0xf9a0(%rsp)
movl 0xf9a0(%rsp), %eax
movq 0xf9b0(%rsp), %rcx
movq 0x930(%rcx), %rcx
movslq 0xf9ac(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xbb50c
movq 0xf9b0(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0xf9ac(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0xf9a8(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0xf9a0(%rsp), %eax
movl %eax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xc0c00
jmp 0xbb49f
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2f080
jmp 0xbb4b0
leaq 0x48(%rsp), %rdi
callq 0x2f0b0
movl 0xf9a0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf9a0(%rsp)
jmp 0xbb434
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
jmp 0xbb5fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2f0b0
jmp 0xbb5fd
jmp 0xbb50e
movl 0xf9a8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf9a8(%rsp)
jmp 0xbb402
jmp 0xbb526
movl 0xf9ac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf9ac(%rsp)
jmp 0xbb3dc
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 0xbb579
jmp 0xbb5c5
leaq 0x20(%rsp), %rdi
callq 0x2f160
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2f170
movl %eax, (%rsp)
jmp 0xbb597
movl (%rsp), %eax
cmpl $0x0, %eax
je 0xbb5b7
movl $0x1, 0xf9d4(%rsp)
movl $0x1, 0xb4(%rsp)
jmp 0xbb5da
jmp 0xbb5b9
leaq 0x20(%rsp), %rdi
callq 0x2f1f0
jmp 0xbb564
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 0xbb63a
jmp 0xbb5fb
jmp 0xbb613
leaq 0x58(%rsp), %rdi
callq 0x2f230
leaq 0x70(%rsp), %rdi
callq 0x2f290
jmp 0xbb656
movq 0xf9b0(%rsp), %rax
movw $0x1, 0x73f2(%rax)
movl $0x0, 0xf9d4(%rsp)
movl $0x1, 0xb4(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x2f230
leaq 0x140(%rsp), %rdi
callq 0x2f290
jmp 0xbb672
leaq 0x128(%rsp), %rdi
callq 0x2f230
leaq 0x140(%rsp), %rdi
callq 0x2f290
jmp 0xbb681
movl 0xf9d4(%rsp), %eax
addq $0xf9d8, %rsp           # imm = 0xF9D8
retq
movq 0x120(%rsp), %rdi
callq 0x8640
nop