// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1108, %rsp           # imm = 0x1108
cmpw $0x0, (%rcx)
movzwl 0x6c88(%rcx), %eax
je 0x6eec1
movq %rcx, %r15
movq %rdx, %r8
movq %rsi, %r14
testw %ax, %ax
jle 0x6ee34
movq %rdi, %r12
leaq 0xa0347(%rip), %rdi     # 0x10f16d
movq %r8, %rbx
callq 0x8540
movq %r12, %rdi
movq %rbx, %r8
cmpl $0x1, 0x83c(%r15)
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
jne 0x6ee54
cmpw $0x0, 0x4b4(%r14)
je 0x6efc5
movl 0x5a0(%rdi), %edx
cmpl $0x6, %edx
jb 0x6eee3
leaq 0x9b52d(%rip), %rsi     # 0x10a397
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x761ff(%rip), %rsi     # 0xe5082
leaq 0x9b565(%rip), %rdx     # 0x10a3ef
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x76187(%rip), %rsi     # 0xe5034
leaq 0x9b4d0(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x2e7, %ecx            # imm = 0x2E7
jmp 0x6f01e
movl $0x0, 0x10(%rsp)
testw %ax, %ax
jle 0x6f028
leaq 0xa03f7(%rip), %rdi     # 0x10f2d0
callq 0x8540
jmp 0x6f028
movl 0x620(%rdi), %edx
cmpl $0x4, %edx
jb 0x6ef4c
leaq 0x9b569(%rip), %rsi     # 0x10a45e
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x76174(%rip), %rsi     # 0xe5082
leaq 0x9b5a6(%rip), %rdx     # 0x10a4bb
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x760fc(%rip), %rsi     # 0xe5034
leaq 0x9b445(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x2ec, %ecx            # imm = 0x2EC
jmp 0x6f01e
cmpw $0x1, 0x4c6(%r14)
jne 0x6f03e
movl 0x638(%rdi), %edx
cmpl $0x2, %edx
jb 0x6f03e
leaq 0x9b5b5(%rip), %rsi     # 0x10a526
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x760f8(%rip), %rsi     # 0xe5082
leaq 0x9b5f6(%rip), %rdx     # 0x10a587
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x76080(%rip), %rsi     # 0xe5034
leaq 0x9b3c9(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x2f2, %ecx            # imm = 0x2F2
jmp 0x6f01e
leaq 0x9b2ae(%rip), %rsi     # 0x10a27a
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x7609d(%rip), %rsi     # 0xe5082
leaq 0x9b35f(%rip), %rdx     # 0x10a34b
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x76025(%rip), %rsi     # 0xe5034
leaq 0x9b36e(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x2e2, %ecx            # imm = 0x2E2
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, 0x4c4(%r14)
jne 0x6f0b2
movl 0x650(%rdi), %edx
cmpl $0x4, %edx
jb 0x6f0b2
leaq 0x9b591(%rip), %rsi     # 0x10a5ec
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x7600e(%rip), %rsi     # 0xe5082
leaq 0x9b5c3(%rip), %rdx     # 0x10a63e
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75f96(%rip), %rsi     # 0xe5034
leaq 0x9b2df(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x2fa, %ecx            # imm = 0x2FA
jmp 0x6f01e
cmpw $0x1, 0x4be(%r14)
jne 0x6f167
movl 0x660(%rdi), %edx
cmpl $0x4, %edx
jb 0x6f12a
leaq 0x9b5be(%rip), %rsi     # 0x10a691
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x75f96(%rip), %rsi     # 0xe5082
leaq 0x9b5f2(%rip), %rdx     # 0x10a6e5
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75f1e(%rip), %rsi     # 0xe5034
leaq 0x9b267(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x302, %ecx            # imm = 0x302
jmp 0x6f01e
cmpw $0x1, 0x3e(%r15)
jne 0x6f167
cmpw $0x0, 0x6c88(%r15)
jle 0x6f167
movq 0xd3e0c(%rip), %rax     # 0x142f50
movq (%rax), %rcx
movq %rdi, %r12
leaq 0x9b5f1(%rip), %rdi     # 0x10a742
pushq $0x1
popq %rdx
movl $0x1b8, %esi            # imm = 0x1B8
movq %r8, %rbx
callq 0x8700
movq %r12, %rdi
movq %rbx, %r8
cmpw $0x1, 0x4c2(%r14)
jne 0x6f286
movq %rdi, %r12
movq %r8, %rbx
leaq 0xf8(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
leaq 0xe8(%rsp), %rcx
xorpd %xmm0, %xmm0
movq %r14, %rdi
callq 0x5a0e7
cmpl $0x1, %eax
jne 0x6f1f1
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x7623d(%rip), %rsi     # 0xe53f0
leaq 0x9b741(%rip), %rdx     # 0x10a8fb
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75e57(%rip), %rsi     # 0xe5034
leaq 0x9b1a0(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x30f, %ecx            # imm = 0x30F
jmp 0x6f6f8
movsd 0x76067(%rip), %xmm0    # 0xe5260
leaq 0xf0(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
leaq 0xe8(%rsp), %rcx
movq %r14, %rdi
callq 0x5a0e7
cmpl $0x1, %eax
jne 0x6f26a
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x761c4(%rip), %rsi     # 0xe53f0
leaq 0x9b70e(%rip), %rdx     # 0x10a941
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75dde(%rip), %rsi     # 0xe5034
leaq 0x9b127(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x310, %ecx            # imm = 0x310
jmp 0x6f6f8
cmpw $0x0, 0x2d8(%r14)
movq %rbx, %r8
movq %r12, %rdi
jne 0x6f286
cmpl $0x1, 0x40(%r14)
jne 0x6f5ca
cmpw $0x1, 0x4b8(%r14)
jne 0x6f30f
cmpw $0x1, 0x18(%r15)
je 0x6f2b1
cmpw $0x1, 0x16(%r15)
je 0x6f2b1
cmpw $0x1, 0x1a(%r15)
je 0x6f2b1
cmpw $0x1, 0x1c(%r15)
jne 0x6f30f
leaq 0x9b89f(%rip), %rsi     # 0x10ab57
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x75db1(%rip), %rsi     # 0xe5082
leaq 0x9b8ce(%rip), %rdx     # 0x10aba6
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75d39(%rip), %rsi     # 0xe5034
leaq 0x9b082(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x329, %ecx            # imm = 0x329
jmp 0x6f01e
movzwl 0x4bc(%r14), %eax
xorl %ecx, %ecx
cmpw $0x1, %ax
sete %cl
movw %cx, 0x8(%r15)
xorl %ecx, %ecx
cmpw $0x1, 0x238(%r14)
sete %cl
movw %cx, 0x4(%r15)
andl $0x0, 0x810(%r15)
cmpw $0x1, 0x4b6(%r14)
jne 0x6f387
movsd 0x7d8(%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6f360
jnp 0x6f387
cmpw $0x1, 0x4c2(%r14)
jne 0x6f375
movw $0x1, 0x812(%r15)
cmpw $0x1, %ax
jne 0x6f3f3
movw $0x1, 0x810(%r15)
jmp 0x6f38d
cmpw $0x1, %ax
jne 0x6f3f3
cmpl $0x2, 0x160(%r14)
jne 0x6f3f3
cmpw $0x0, 0x6c88(%r15)
jle 0x6f3f3
cmpl $0x1, 0x678(%rdi)
jne 0x6f3f3
movq %r14, %r12
movq 0xd3b9b(%rip), %r14     # 0x142f50
movq (%r14), %rcx
movq %rdi, %rbp
leaq 0x9b850(%rip), %rdi     # 0x10ac12
pushq $0x1
popq %rbx
movl $0x84, %esi
movq %rbx, %rdx
movq %r8, %r13
callq 0x8700
movq (%r14), %rcx
movq %r12, %r14
leaq 0x9b8b5(%rip), %rdi     # 0x10ac97
pushq $0x64
popq %rsi
movq %rbx, %rdx
callq 0x8700
movq %rbp, %rdi
movq %r13, %r8
cmpw $0x1, 0x10(%r15)
jne 0x6f459
leaq 0x9b8fa(%rip), %rsi     # 0x10acfc
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x75c67(%rip), %rsi     # 0xe5082
leaq 0x8e8d7(%rip), %rdx     # 0xfdcf9
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75bef(%rip), %rsi     # 0xe5034
leaq 0x9af38(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x34e, %ecx            # imm = 0x34E
jmp 0x6f01e
cmpw $0x1, 0x1c(%r15)
jne 0x6f484
cmpw $0x0, 0x6c88(%r15)
jle 0x6f484
movq %rdi, %r12
leaq 0x9fd09(%rip), %rdi     # 0x10f17f
movq %r8, %rbx
callq 0x8540
movq %r12, %rdi
movq %rbx, %r8
cmpw $0x1, 0x12(%r15)
jne 0x6f4e2
andl $0x0, 0x24(%r15)
movl 0x20(%r15), %eax
cmpl $0x2, %eax
je 0x6f4be
cmpl $0x1, %eax
jne 0x6f4e2
cmpw $0x1, 0x4c4(%r14)
je 0x6f4b5
cmpw $0x1, 0x4be(%r14)
jne 0x6f4e2
movw $0x1, 0x24(%r15)
jmp 0x6f4e2
cmpw $0x1, 0x4c4(%r14)
jne 0x6f4d0
movw $0x1, 0x24(%r15)
cmpw $0x1, 0x4be(%r14)
jne 0x6f4e2
movw $0x1, 0x26(%r15)
movq %rdi, %r12
movq %r14, %rsi
movq %r8, %rdx
movq %r15, %rcx
movq %r8, %rbx
callq 0x70009
testl %eax, %eax
je 0x6f53f
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75ee8(%rip), %rsi     # 0xe53f0
leaq 0x9b803(%rip), %rdx     # 0x10ad12
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x75b09(%rip), %rsi     # 0xe5034
leaq 0x9ae52(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x383, %ecx            # imm = 0x383
jmp 0x6f6f8
movsd 0x818(%r15), %xmm0
movsd 0xf30(%rbx), %xmm1
ucomisd %xmm1, %xmm0
movq %rbx, %rdx
jbe 0x6f6a3
cmpw $0x1, 0x834(%r15)
jne 0x6f689
leaq 0x9b7c9(%rip), %rsi     # 0x10ad3c
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x75af6(%rip), %rsi     # 0xe5082
leaq 0x9b88e(%rip), %rdx     # 0x10ae21
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75a7e(%rip), %rsi     # 0xe5034
leaq 0x9adc7(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x38c, %ecx            # imm = 0x38C
jmp 0x6f01e
movsd 0xf8(%rsp), %xmm1
movsd 0x75c85(%rip), %xmm2    # 0xe5260
addsd %xmm2, %xmm1
movsd 0xf0(%rsp), %xmm0
addsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x6fadd
ucomisd 0x761e2(%rip), %xmm0    # 0xe57e8
jne 0x6f286
jp 0x6f286
movsd 0xa8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x6f286
jp 0x6f286
leaq 0x9b42b(%rip), %rsi     # 0x10aa5d
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x75a37(%rip), %rsi     # 0xe5082
leaq 0x9b4da(%rip), %rdx     # 0x10ab2c
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x759bf(%rip), %rsi     # 0xe5034
leaq 0x9ad08(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x31f, %ecx            # imm = 0x31F
jmp 0x6f01e
cmpw $0x1, 0x87c(%r15)
jne 0x6f6a3
cmpw $0x0, 0x844(%r15)
je 0x6fe3a
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
movq %rdx, %rbx
callq 0x70e40
testl %eax, %eax
je 0x6f700
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x75d2a(%rip), %rsi     # 0xe53f0
leaq 0x9ba8c(%rip), %rdx     # 0x10b159
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x7594b(%rip), %rsi     # 0xe5034
leaq 0x9ac94(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x3a0, %ecx            # imm = 0x3A0
movq %rbx, %r8
jmp 0x6f021
movq %r12, 0xd0(%rsp)
movq %rbx, 0xd8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x721dc
callq 0x1a2a0
leaq 0x900(%rsp), %rdi
movl %eax, %esi
callq 0x1a33e
andq $0x0, 0xc0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xb0(%rsp)
cmpw $0x1, 0x130(%r14)
jne 0x6f772
cmpw $0x0, 0x236(%r14)
jne 0x6f772
cmpw $0x0, 0x6c88(%r15)
jle 0x6f772
leaq 0x9faab(%rip), %rdi     # 0x10f218
callq 0x8540
movq %r14, 0xe0(%rsp)
leaq 0xe(%rsp), %r13
leaq 0xd1a9a(%rip), %rax     # 0x141220
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 0x854(%r15), %rdx
cmpq %rdx, %rbx
jge 0x6fab3
cmpw $0x2, 0x6c88(%r15)
jl 0x6f7d4
leal 0x1(%rbx), %esi
leaq 0x9b9c7(%rip), %rdi     # 0x10b194
xorl %eax, %eax
callq 0x8030
xorl %r12d, %r12d
movq %rbx, 0x38(%rsp)
movq 0x870(%r15), %rax
movl (%rax,%rbx,4), %edx
cmpl %edx, %r12d
jge 0x6faab
cmpw $0x2, 0x6c88(%r15)
jl 0x6f825
leal 0x1(%r12), %esi
leaq 0x9b9a3(%rip), %rdi     # 0x10b1a9
xorl %eax, %eax
callq 0x8030
movq 0x9c8(%r15), %rax
movl (%rax,%rbx,4), %esi
leaq 0x9b99e(%rip), %rdi     # 0x10b1bc
xorl %eax, %eax
callq 0x8030
movq %r12, 0x40(%rsp)
movq 0x9c8(%r15), %rax
movl (%rax,%rbx,4), %r12d
testl %r12d, %r12d
jle 0x6fa94
andq $0x0, 0x18(%rsp)
movq %r13, %rdi
pushq $0x1
popq %rsi
callq 0x1b0f6
movq %rax, %r15
movq %r13, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movabsq $0x100000001, %r13      # imm = 0x100000001
movq %r13, 0x8(%rax)
movq 0x90(%rsp), %rax
movq %rax, (%r15)
pushq $0x68
popq %rdi
callq 0x83d0
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %rbx, 0x108(%rsp)
movq %r13, 0x8(%rbx)
leaq 0xd207d(%rip), %rax     # 0x141920
movq %rax, (%rbx)
movq %rbx, %r13
addq $0x10, %r13
movq %r13, %rdi
leaq 0x98(%rsp), %rsi
callq 0x1b18a
decl %r12d
movq %r15, %rbp
addq $0x10, %rbp
leaq 0xd20a2(%rip), %rax     # 0x141970
movq %rax, 0x10(%rbx)
movq 0xd0(%rsp), %rax
movq %rax, 0x38(%rbx)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rbx)
movq 0xd8(%rsp), %rax
movq %rax, 0x48(%rbx)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rbx)
movq 0x38(%rsp), %rax
movl %eax, 0x58(%rbx)
movq 0x40(%rsp), %rax
movl %eax, 0x5c(%rbx)
movl %r12d, 0x60(%rbx)
andq $0x0, 0x108(%rsp)
movq %r14, %rdi
callq 0x8e9f4
movq %r13, 0x10(%r15)
andq $0x0, 0x58(%rsp)
movq %rbx, 0x18(%r15)
andq $0x0, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1afb0
andq $0x0, 0x30(%rsp)
movq %r15, 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, %r15d
lock
xaddl %r15d, 0x920(%rsp)
xorl %r13d, %r13d
movl 0x900(%rsp), %ecx
cmpl %ecx, %r13d
jae 0x6f9db
leal (%r15,%r13), %eax
xorl %edx, %edx
divl %ecx
movq 0x928(%rsp), %rbx
imulq $0xb0, %rdx, %rbp
leaq (%rbx,%rbp), %rdi
addq $0x58, %rdi
movq %rdi, 0x100(%rsp)
callq 0x1add8
movb %al, 0x108(%rsp)
testb %al, %al
jne 0x6fa36
movq %r14, %rdi
callq 0x1adc2
incl %r13d
jmp 0x6f98b
movl %r15d, %eax
xorl %edx, %edx
divl %ecx
movq 0x928(%rsp), %rbx
imulq $0xb0, %rdx, %r15
leaq (%rbx,%r15), %rsi
addq $0x58, %rsi
movq %r14, %rdi
callq 0x1ae48
leaq 0xe(%rsp), %r13
addq %r15, %rbx
movq %rbx, %rdi
leaq 0x50(%rsp), %rsi
callq 0x8eff2
movq %r14, %rdi
callq 0x1adc2
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x81e0
leaq 0x58(%rsp), %rdi
callq 0x1afb0
jmp 0x6fa69
addq %rbp, %rbx
movq %rbx, %rdi
leaq 0x50(%rsp), %rsi
callq 0x8eff2
movq %r14, %rdi
callq 0x1adc2
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x81e0
leaq 0x58(%rsp), %rdi
callq 0x1afb0
leaq 0xe(%rsp), %r13
leaq 0x20(%rsp), %rdi
callq 0x1afb0
leaq 0xb0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1bb4a
leaq 0x78(%rsp), %rdi
callq 0x1afb0
jmp 0x6f835
movq 0x40(%rsp), %r12
incl %r12d
movq 0x48(%rsp), %r15
movq 0x38(%rsp), %rbx
jmp 0x6f7dc
incq %rbx
jmp 0x6f7a8
movq 0xb0(%rsp), %rbx
movq 0xb8(%rsp), %r14
cmpq %r14, %rbx
je 0x6fb3b
movq %rbx, %rdi
callq 0x1a3be
addq $0x10, %rbx
testl %eax, %eax
je 0x6fac3
jmp 0x6fecc
leaq 0x9aea1(%rip), %rsi     # 0x10a985
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x75585(%rip), %rsi     # 0xe5082
leaq 0x9af33(%rip), %rdx     # 0x10aa37
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7550d(%rip), %rsi     # 0xe5034
leaq 0x9a856(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x31a, %ecx            # imm = 0x31A
jmp 0x6f01e
leaq 0xb0(%rsp), %rdi
callq 0x1a3f0
cmpl $0x2, 0xa60(%r15)
jl 0x6feba
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 %r12d, %r12d
leaq 0xf(%rsp), %rbx
leaq 0x28(%rsp), %r13
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
movslq 0x854(%r15), %rax
cmpq %rax, %r12
jge 0x6fdfb
xorl %ecx, %ecx
movq 0x870(%r15), %rax
cmpl (%rax,%r12,4), %ecx
jge 0x6fdf3
movl %ecx, 0x38(%rsp)
xorl %ecx, %ecx
movq 0x48(%rsp), %rax
movq 0x998(%rax), %rax
cmpl (%rax,%r12,4), %ecx
jge 0x6fde3
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 0xe(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r15, 0x8(%rbx)
leaq 0xd1dce(%rip), %rax     # 0x141a00
movq %rax, (%rbx)
movq %rbx, %rbp
addq $0x10, %rbp
movq %rbp, %rdi
leaq 0x17(%rsp), %rsi
callq 0x1b18a
movq %r14, %r15
addq $0x10, %r15
leaq 0xd1df9(%rip), %rax     # 0x141a50
movq %rax, 0x10(%rbx)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rbx)
movl %r12d, 0x40(%rbx)
movl 0x38(%rsp), %eax
movl %eax, 0x44(%rbx)
movl 0x40(%rsp), %eax
movl %eax, 0x48(%rbx)
andq $0x0, 0x30(%rsp)
movq %r13, %rdi
callq 0x8f1a0
movq %rbp, 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 %r15, 0x80(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1b0e8
leaq 0x98(%rsp), %rdi
movq %r15, %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 %r15d, %r15d
movl 0x100(%rsp), %ecx
cmpl %ecx, %r15d
jae 0x6fd41
leal (%r14,%r15), %eax
xorl %edx, %edx
divl %ecx
movq 0x128(%rsp), %rbx
imulq $0xb0, %rdx, %rbp
leaq (%rbx,%rbp), %rdi
addq $0x58, %rdi
movq %rdi, 0x28(%rsp)
callq 0x1add8
movb %al, 0x30(%rsp)
testb %al, %al
jne 0x6fd79
movq %r13, %rdi
callq 0x1adc2
incl %r15d
jmp 0x6fcf7
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movq 0x128(%rsp), %rbx
imulq $0xb0, %rdx, %r14
leaq (%rbx,%r14), %rsi
addq $0x58, %rsi
movq %r13, %rdi
callq 0x1ae48
addq %r14, %rbx
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq 0x8f672
jmp 0x6fd89
addq %rbp, %rbx
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq 0x8f672
movq %r13, %rdi
callq 0x1adc2
subq $-0x80, %rbx
movq %rbx, %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 0xf(%rsp), %rbx
leaq 0xa0(%rsp), %rdi
callq 0x1afb0
movl 0x40(%rsp), %ecx
incl %ecx
jmp 0x6fbb9
movl 0x38(%rsp), %ecx
incl %ecx
movq 0x48(%rsp), %r15
jmp 0x6fba2
incq %r12
jmp 0x6fb90
movq 0x50(%rsp), %rbx
movq 0x58(%rsp), %r14
cmpq %r14, %rbx
je 0x6fe98
movq %rbx, %rdi
callq 0x1a3be
addq $0x10, %rbx
testl %eax, %eax
je 0x6fe05
leaq 0x50(%rsp), %rdi
callq 0x1a3f8
leaq 0x100(%rsp), %rdi
callq 0x1a41a
jmp 0x6fecc
leaq 0x9aff7(%rip), %rsi     # 0x10ae38
leaq 0x900(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x75228(%rip), %rsi     # 0xe5082
leaq 0x9b29c(%rip), %rdx     # 0x10b0fd
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x751b0(%rip), %rsi     # 0xe5034
leaq 0x9a4f9(%rip), %rdx     # 0x10a384
movq %r15, %rdi
movl $0x392, %ecx            # imm = 0x392
jmp 0x6f01e
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a3f0
movq %rbx, %rdi
callq 0x1a3f8
leaq 0x100(%rsp), %rdi
callq 0x1a41a
movw $0x1, 0x748a(%r15)
movl $0x0, 0x10(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x1a3f8
leaq 0x900(%rsp), %rdi
callq 0x1a41a
jmp 0x6f028
jmp 0x6ffaf
jmp 0x6ff61
jmp 0x6ffaf
jmp 0x6fef9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1adc2
jmp 0x6ff0b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1afb0
leaq 0xa0(%rsp), %rdi
callq 0x1afb0
jmp 0x6ff34
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
jmp 0x6ff3c
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x1afb0
jmp 0x6ff64
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8f1a0
jmp 0x6ff55
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1b0e8
jmp 0x6ff64
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1a3f8
leaq 0x100(%rsp), %rdi
callq 0x1a41a
jmp 0x6ffe7
jmp 0x6ff7f
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x1adc2
jmp 0x6ff94
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1afb0
leaq 0x78(%rsp), %rdi
callq 0x1afb0
jmp 0x6ffb7
movq %rax, %rbx
jmp 0x6ffce
movq %rax, %rbx
jmp 0x6ffe7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x6ffe2
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x8e9f4
leaq 0x28(%rsp), %rdi
callq 0x1b0e8
jmp 0x6ffe7
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