// File: /workspace/github_c_makefile_star2_O3/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 $0x10c8, %rsp           # imm = 0x10C8
movq %rsi, (%rsp)
cmpw $0x0, (%rcx)
movzwl 0x6c88(%rcx), %eax
je 0x7352d
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r8
testw %ax, %ax
jle 0x734a6
leaq 0xa4e32(%rip), %rdi     # 0x1182cd
movq %r8, %r14
callq 0x8510
movq %r14, %r8
cmpl $0x1, 0x83c(%r12)
movq (%rsp), %rdi
jne 0x734c3
cmpw $0x0, 0x4b4(%rdi)
je 0x7362c
movl 0x5a0(%r8), %edx
cmpl $0x6, %edx
jb 0x73549
leaq 0xa0021(%rip), %rsi     # 0x1134f7
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7ab93(%rip), %rsi     # 0xee082
leaq 0xa0059(%rip), %rdx     # 0x11354f
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7ab1b(%rip), %rsi     # 0xee034
leaq 0x9ffc4(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x2e7, %ecx            # imm = 0x2E7
jmp 0x73685
xorl %ebx, %ebx
testw %ax, %ax
jle 0x73694
leaq 0xa4ef1(%rip), %rdi     # 0x118430
callq 0x8510
jmp 0x73694
movl 0x620(%r8), %edx
cmpl $0x4, %edx
jb 0x735b3
leaq 0xa0062(%rip), %rsi     # 0x1135be
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7ab0d(%rip), %rsi     # 0xee082
leaq 0xa009f(%rip), %rdx     # 0x11361b
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7aa95(%rip), %rsi     # 0xee034
leaq 0x9ff3e(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x2ec, %ecx            # imm = 0x2EC
jmp 0x73685
cmpw $0x1, 0x4c6(%rdi)
jne 0x736a8
movl 0x638(%r8), %edx
cmpl $0x2, %edx
jb 0x736a8
leaq 0xa00ae(%rip), %rsi     # 0x113686
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7aa91(%rip), %rsi     # 0xee082
leaq 0xa00ef(%rip), %rdx     # 0x1136e7
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7aa19(%rip), %rsi     # 0xee034
leaq 0x9fec2(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x2f2, %ecx            # imm = 0x2F2
jmp 0x73685
leaq 0x9fda7(%rip), %rsi     # 0x1133da
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7aa36(%rip), %rsi     # 0xee082
leaq 0x9fe58(%rip), %rdx     # 0x1134ab
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a9be(%rip), %rsi     # 0xee034
leaq 0x9fe67(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x2e2, %ecx            # imm = 0x2E2
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %ebx
movl %ebx, %eax
addq $0x10c8, %rsp           # imm = 0x10C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpw $0x1, 0x4c4(%rdi)
jne 0x7371c
movl 0x650(%r8), %edx
cmpl $0x4, %edx
jb 0x7371c
leaq 0xa0087(%rip), %rsi     # 0x11374c
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7a9a4(%rip), %rsi     # 0xee082
leaq 0xa00b9(%rip), %rdx     # 0x11379e
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a92c(%rip), %rsi     # 0xee034
leaq 0x9fdd5(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x2fa, %ecx            # imm = 0x2FA
jmp 0x73685
cmpw $0x1, 0x4be(%rdi)
jne 0x737d3
movl 0x660(%r8), %edx
cmpl $0x4, %edx
jb 0x73794
leaq 0xa00b4(%rip), %rsi     # 0x1137f1
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7a92c(%rip), %rsi     # 0xee082
leaq 0xa00e8(%rip), %rdx     # 0x113845
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a8b4(%rip), %rsi     # 0xee034
leaq 0x9fd5d(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x302, %ecx            # imm = 0x302
jmp 0x73685
cmpw $0x1, 0x3e(%r12)
jne 0x737d3
cmpw $0x0, 0x6c88(%r12)
jle 0x737d3
movq 0xd57b0(%rip), %rax     # 0x148f60
movq (%rax), %rcx
leaq 0xa00e8(%rip), %rdi     # 0x1138a2
movl $0x1b8, %esi            # imm = 0x1B8
movl $0x1, %edx
movq %r8, %r14
callq 0x86d0
movq %r14, %r8
movq (%rsp), %rdi
cmpw $0x1, 0x4c2(%rdi)
jne 0x738ed
movq %r8, %r15
leaq 0xb8(%rsp), %rsi
leaq 0x80(%rsp), %rdx
leaq 0xa8(%rsp), %rcx
xorpd %xmm0, %xmm0
movq %rdi, %r14
callq 0x5e095
cmpl $0x1, %eax
jne 0x73859
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x7abd5(%rip), %rsi     # 0xee3f0
leaq 0xa0239(%rip), %rdx     # 0x113a5b
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a7ef(%rip), %rsi     # 0xee034
leaq 0x9fc98(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x30f, %ecx            # imm = 0x30F
jmp 0x73d96
movsd 0x7a9ff(%rip), %xmm0    # 0xee260
leaq 0xb0(%rsp), %rsi
leaq 0x80(%rsp), %rdx
leaq 0xa8(%rsp), %rcx
movq %r14, %rdi
callq 0x5e095
cmpl $0x1, %eax
jne 0x738d2
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x7ab5c(%rip), %rsi     # 0xee3f0
leaq 0xa0206(%rip), %rdx     # 0x113aa1
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a776(%rip), %rsi     # 0xee034
leaq 0x9fc1f(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x310, %ecx            # imm = 0x310
jmp 0x73d96
cmpw $0x0, 0x2d8(%r14)
movq %r14, %rdi
movq %r15, %r8
jne 0x738ed
cmpl $0x1, 0x40(%rdi)
jne 0x73c64
cmpw $0x1, 0x4b8(%rdi)
jne 0x7397d
cmpw $0x1, 0x18(%r12)
je 0x7391f
cmpw $0x1, 0x16(%r12)
je 0x7391f
cmpw $0x1, 0x1a(%r12)
je 0x7391f
cmpw $0x1, 0x1c(%r12)
jne 0x7397d
leaq 0xa0391(%rip), %rsi     # 0x113cb7
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7a743(%rip), %rsi     # 0xee082
leaq 0xa03c0(%rip), %rdx     # 0x113d06
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a6cb(%rip), %rsi     # 0xee034
leaq 0x9fb74(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x329, %ecx            # imm = 0x329
jmp 0x73685
movzwl 0x4bc(%rdi), %eax
xorl %ecx, %ecx
cmpw $0x1, %ax
sete %cl
movw %cx, 0x8(%r12)
xorl %ecx, %ecx
cmpw $0x1, 0x238(%rdi)
sete %cl
movw %cx, 0x4(%r12)
movl $0x0, 0x810(%r12)
cmpw $0x1, 0x4b6(%rdi)
jne 0x73a02
movsd 0x7d8(%r12), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x739d2
jnp 0x73a02
movq (%rsp), %rcx
cmpw $0x1, 0x4c2(%rcx)
jne 0x739eb
movw $0x1, 0x812(%r12)
cmpw $0x1, %ax
movq (%rsp), %rsi
jne 0x73a74
movw $0x1, 0x810(%r12)
jmp 0x73a0c
cmpw $0x1, %ax
movq (%rsp), %rsi
jne 0x73a74
cmpl $0x2, 0x160(%rsi)
jne 0x73a74
cmpw $0x0, 0x6c88(%r12)
jle 0x73a74
cmpl $0x1, 0x678(%r8)
jne 0x73a74
movq %rbx, %r14
movq 0xd552b(%rip), %rbx     # 0x148f60
movq (%rbx), %rcx
leaq 0xa0333(%rip), %rdi     # 0x113d72
movl $0x84, %esi
movl $0x1, %edx
movq %r8, %r15
callq 0x86d0
movq (%rbx), %rcx
movq %r14, %rbx
leaq 0xa0399(%rip), %rdi     # 0x113df7
movl $0x64, %esi
movl $0x1, %edx
callq 0x86d0
movq %r15, %r8
movq (%rsp), %rsi
cmpw $0x1, 0x10(%r12)
jne 0x73adb
leaq 0xa03d8(%rip), %rsi     # 0x113e5c
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7a5e5(%rip), %rsi     # 0xee082
leaq 0x9338d(%rip), %rdx     # 0x106e31
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a56d(%rip), %rsi     # 0xee034
leaq 0x9fa16(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x34e, %ecx            # imm = 0x34E
jmp 0x73685
cmpw $0x1, 0x1c(%r12)
jne 0x73b06
cmpw $0x0, 0x6c88(%r12)
jle 0x73b06
leaq 0xa47e8(%rip), %rdi     # 0x1182df
movq %r8, %r14
callq 0x8510
movq %r14, %r8
movq (%rsp), %rsi
cmpw $0x1, 0x12(%r12)
jne 0x73b71
movl $0x0, 0x24(%r12)
movl 0x20(%r12), %eax
cmpl $0x2, %eax
je 0x73b49
cmpl $0x1, %eax
movq (%rsp), %rsi
jne 0x73b71
cmpw $0x1, 0x4c4(%rsi)
je 0x73b3f
cmpw $0x1, 0x4be(%rsi)
jne 0x73b71
movw $0x1, 0x24(%r12)
jmp 0x73b71
movq (%rsp), %rsi
cmpw $0x1, 0x4c4(%rsi)
jne 0x73b5f
movw $0x1, 0x24(%r12)
cmpw $0x1, 0x4be(%rsi)
jne 0x73b71
movw $0x1, 0x26(%r12)
movq %r8, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movq %rbx, %r14
movq %rsi, %rbx
movq %r8, %r15
callq 0x74720
testl %eax, %eax
je 0x73bd1
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a856(%rip), %rsi     # 0xee3f0
leaq 0xa02d1(%rip), %rdx     # 0x113e72
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x7a477(%rip), %rsi     # 0xee034
leaq 0x9f920(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x383, %ecx            # imm = 0x383
jmp 0x73d96
movsd 0x818(%r12), %xmm0
movq %r14, 0x78(%rsp)
movsd 0xf30(%r14), %xmm1
ucomisd %xmm1, %xmm0
movq %r15, %rdi
jbe 0x73d3f
cmpw $0x1, 0x834(%r12)
jne 0x73d23
leaq 0xa028f(%rip), %rsi     # 0x113e9c
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x7a45c(%rip), %rsi     # 0xee082
leaq 0xa0354(%rip), %rdx     # 0x113f81
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a3e4(%rip), %rsi     # 0xee034
leaq 0x9f88d(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x38c, %ecx            # imm = 0x38C
jmp 0x73685
movsd 0xb8(%rsp), %xmm1
movsd 0x7a5eb(%rip), %xmm2    # 0xee260
addsd %xmm2, %xmm1
movsd 0xb0(%rsp), %xmm0
addsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x74505
ucomisd 0x7ab48(%rip), %xmm0    # 0xee7e8
jne 0x738ed
jp 0x738ed
movsd 0x80(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x738ed
jp 0x738ed
leaq 0x9fef1(%rip), %rsi     # 0x113bbd
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7a39d(%rip), %rsi     # 0xee082
leaq 0x9ffa0(%rip), %rdx     # 0x113c8c
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a325(%rip), %rsi     # 0xee034
leaq 0x9f7ce(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x31f, %ecx            # imm = 0x31F
jmp 0x73685
cmpw $0x1, 0x87c(%r12)
jne 0x73d3f
cmpw $0x0, 0x844(%r12)
je 0x74563
movq %rbx, %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rcx
movq %rdi, %r14
callq 0x75562
testl %eax, %eax
je 0x73d9e
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x7a68c(%rip), %rsi     # 0xee3f0
leaq 0xa054e(%rip), %rdx     # 0x1142b9
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x7a2ad(%rip), %rsi     # 0xee034
leaq 0x9f756(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x3a0, %ecx            # imm = 0x3A0
movq %rbx, %r8
jmp 0x73688
movq %r14, 0xa0(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7690b
callq 0x1c686
leaq 0x8c0(%rsp), %rdi
movl %eax, %esi
callq 0x1c736
xorpd %xmm0, %xmm0
movapd %xmm0, 0x60(%rsp)
movq $0x0, 0x70(%rsp)
cmpw $0x1, 0x130(%rbx)
jne 0x73e04
cmpw $0x0, 0x236(%rbx)
jne 0x73e04
cmpw $0x0, 0x6c88(%r12)
jle 0x73e04
leaq 0xa4579(%rip), %rdi     # 0x118378
callq 0x8510
movl 0x854(%r12), %edx
testl %edx, %edx
movq %r12, 0x40(%rsp)
jle 0x74156
movabsq $0x100000001, %r14      # imm = 0x100000001
leaq 0xd3416(%rip), %rax     # 0x147240
addq $0x10, %rax
movq %rax, 0x98(%rsp)
movq $0x0, 0x8(%rsp)
cmpw $0x2, 0x6c88(%r12)
jl 0x73e61
movq 0x8(%rsp), %rax
leal 0x1(%rax), %esi
leaq 0xa049a(%rip), %rdi     # 0x1142f4
xorl %eax, %eax
callq 0x8030
movq 0x870(%r12), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
testl %edx, %edx
jle 0x74138
movq $0x0, 0x48(%rsp)
cmpw $0x2, 0x6c88(%r12)
jl 0x73ec2
movq 0x48(%rsp), %rax
leal 0x1(%rax), %esi
leaq 0xa046c(%rip), %rdi     # 0x114309
xorl %eax, %eax
callq 0x8030
movq 0x9c8(%r12), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xa0461(%rip), %rdi     # 0x11431c
xorl %eax, %eax
callq 0x8030
movq 0x9c8(%r12), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %r15d
testl %r15d, %r15d
jle 0x74114
movl $0x20, %edi
callq 0x83b0
movq %rax, %r12
movq %r14, 0x8(%rax)
movq 0x98(%rsp), %rax
movq %rax, (%r12)
movl $0x68, %edi
callq 0x83b0
movq %rax, %rbx
movq %r14, 0x8(%rax)
leaq 0xd3a1f(%rip), %rax     # 0x147930
movq %rax, (%rbx)
movq %rbx, %r14
addq $0x10, %r14
movq %r14, %rdi
leaq 0xc0(%rsp), %rsi
callq 0x1d4aa
movq %r15, 0x38(%rsp)
leal -0x1(%r15), %ebp
movq %r12, %r15
addq $0x10, %r15
leaq 0xd3a3e(%rip), %rax     # 0x147980
movq %rax, 0x10(%rbx)
movq 0xa0(%rsp), %rax
movq %rax, 0x38(%rbx)
movq (%rsp), %rax
movq %rax, 0x40(%rbx)
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rbx)
movq 0x8(%rsp), %rax
movl %eax, 0x58(%rbx)
movq 0x48(%rsp), %rax
movl %eax, 0x5c(%rbx)
movl %ebp, 0x60(%rbx)
movq %r14, 0x10(%r12)
movq %rbx, 0x18(%r12)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1d3e8
movq %r15, 0x20(%rsp)
movq %r12, 0x28(%rsp)
movq 0xd5009(%rip), %rax     # 0x148fb0
cmpb $0x0, (%rax)
je 0x73fb3
incl 0x8(%r12)
jmp 0x73fb9
lock
incl 0x8(%r12)
movl $0x1, %ebx
lock
xaddl %ebx, 0x8e0(%rsp)
movl 0x8c0(%rsp), %ecx
testl %ecx, %ecx
je 0x7402f
xorl %r15d, %r15d
leal (%rbx,%r15), %eax
xorl %edx, %edx
divl %ecx
movq 0x8e8(%rsp), %r14
imulq $0xb0, %rdx, %r13
leaq (%r14,%r13), %rdi
addq $0x58, %rdi
movq %rdi, 0xc0(%rsp)
callq 0x8080
testl %eax, %eax
sete 0xc8(%rsp)
je 0x74099
leaq 0xc0(%rsp), %rdi
callq 0x1d204
incl %r15d
movl 0x8c0(%rsp), %ecx
cmpl %ecx, %r15d
jb 0x73fd5
jmp 0x74031
xorl %ecx, %ecx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movq 0x8e8(%rsp), %rbx
imulq $0xb0, %rdx, %r14
leaq (%rbx,%r14), %rax
addq $0x58, %rax
movq %rax, 0xc0(%rsp)
movb $0x0, 0xc8(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1d294
addq %r14, %rbx
movb $0x1, 0xc8(%rsp)
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
callq 0x93a0c
leaq 0xc0(%rsp), %rdi
callq 0x1d204
subq $-0x80, %rbx
movq %rbx, %rdi
jmp 0x740bd
addq %r13, %r14
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x93a0c
leaq 0xc0(%rsp), %rdi
callq 0x1d204
subq $-0x80, %r14
movq %r14, %rdi
callq 0x81c0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x740d1
callq 0x1d330
movq %r12, %rdi
callq 0x1d330
leaq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1dd2e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x740f7
callq 0x1d330
cmpl $0x1, 0x38(%rsp)
movl %ebp, %r15d
movq 0x40(%rsp), %r12
movabsq $0x100000001, %r14      # imm = 0x100000001
jg 0x73edc
movq 0x48(%rsp), %rsi
incl %esi
movq 0x870(%r12), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq %rsi, 0x48(%rsp)
cmpl %edx, %esi
jl 0x73e82
movq 0x8(%rsp), %rcx
incq %rcx
movslq 0x854(%r12), %rdx
movq %rcx, 0x8(%rsp)
cmpq %rdx, %rcx
jl 0x73e3f
movq 0x60(%rsp), %rbx
movq 0x68(%rsp), %r14
cmpq %r14, %rbx
je 0x741ac
movq %rbx, %rdi
callq 0x1c7ba
testl %eax, %eax
jne 0x745d8
addq $0x10, %rbx
cmpq %r14, %rbx
jne 0x74165
movq 0x60(%rsp), %rbx
movq 0x68(%rsp), %r14
cmpq %rbx, %r14
je 0x741ac
movq %rbx, %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x7419e
callq 0x1d330
addq $0x10, %r15
cmpq %r14, %r15
jne 0x74190
movq %rbx, 0x68(%rsp)
cmpl $0x2, 0xa60(%r12)
jl 0x744f3
callq 0x1c686
leaq 0xc0(%rsp), %rdi
movl %eax, %esi
callq 0x1c736
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl 0x854(%r12), %ecx
testl %ecx, %ecx
jle 0x744dc
movq 0x870(%r12), %rax
xorl %r15d, %r15d
leaq 0xd303c(%rip), %rdx     # 0x147240
addq $0x10, %rdx
movq %rdx, 0x8(%rsp)
cmpl $0x0, (%rax,%r15,4)
jle 0x74477
movq 0x998(%r12), %rcx
movl $0x0, (%rsp)
cmpl $0x0, (%rcx,%r15,4)
jle 0x7445d
movl $0x0, 0x38(%rsp)
movl $0x20, %edi
callq 0x83b0
movq %rax, %r13
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r14, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%r13)
movl $0x50, %edi
callq 0x83b0
movq %rax, %rbx
movq %r14, 0x8(%rax)
leaq 0xd379a(%rip), %rax     # 0x147a10
movq %rax, (%rbx)
movq %rbx, %r12
addq $0x10, %r12
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d4aa
movq %r13, %rbp
addq $0x10, %rbp
leaq 0xd37c5(%rip), %rax     # 0x147a60
movq %rax, 0x10(%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rbx)
movl %r15d, 0x40(%rbx)
movl (%rsp), %eax
movl %eax, 0x44(%rbx)
movl 0x38(%rsp), %eax
movl %eax, 0x48(%rbx)
movq %r12, 0x10(%r13)
movq %rbx, 0x18(%r13)
leaq 0x88(%rsp), %rdi
movq %rbp, %rsi
callq 0x1d3e8
movq %rbp, 0x50(%rsp)
movq %r13, 0x58(%rsp)
movq 0xd4cce(%rip), %rax     # 0x148fb0
cmpb $0x0, (%rax)
je 0x742ed
incl 0x8(%r13)
jmp 0x742f2
lock
incl 0x8(%r13)
movl $0x1, %ebx
lock
xaddl %ebx, 0xe0(%rsp)
movl 0xc0(%rsp), %ecx
testl %ecx, %ecx
je 0x7435b
xorl %ebp, %ebp
leal (%rbx,%rbp), %eax
xorl %edx, %edx
divl %ecx
movq 0xe8(%rsp), %r12
imulq $0xb0, %rdx, %r14
leaq (%r12,%r14), %rdi
addq $0x58, %rdi
movq %rdi, 0x10(%rsp)
callq 0x8080
testl %eax, %eax
sete 0x18(%rsp)
je 0x74417
leaq 0x10(%rsp), %rdi
callq 0x1d204
incl %ebp
movl 0xc0(%rsp), %ecx
cmpl %ecx, %ebp
jb 0x7430d
jmp 0x7435d
xorl %ecx, %ecx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movq 0xe8(%rsp), %rbx
imulq $0xb0, %rdx, %r14
leaq (%rbx,%r14), %rax
addq $0x58, %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1d294
movq 0x40(%rsp), %r12
addq %r14, %rbx
movb $0x1, 0x18(%rsp)
movq %rbx, %rdi
leaq 0x50(%rsp), %rsi
callq 0x9417a
leaq 0x10(%rsp), %rdi
callq 0x1d204
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x81c0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x743cd
callq 0x1d330
movq %r13, %rdi
callq 0x1d330
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1dd2e
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x743f9
callq 0x1d330
movl 0x38(%rsp), %eax
incl %eax
movq 0x998(%r12), %rcx
movl %eax, 0x38(%rsp)
cmpl (%rcx,%r15,4), %eax
jl 0x7423a
jmp 0x74455
addq %r14, %r12
movq %r12, %rdi
leaq 0x50(%rsp), %rsi
callq 0x9417a
leaq 0x10(%rsp), %rdi
callq 0x1d204
subq $-0x80, %r12
movq %r12, %rdi
callq 0x81c0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
movq 0x40(%rsp), %r12
jne 0x743c8
jmp 0x743cd
movq 0x870(%r12), %rax
movl (%rsp), %edx
incl %edx
movl %edx, (%rsp)
cmpl (%rax,%r15,4), %edx
jl 0x74227
movl 0x854(%r12), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0x7420d
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rbx
cmpq %rbx, %r14
je 0x744b8
movq %r14, %rdi
callq 0x1c7ba
testl %eax, %eax
jne 0x745c1
addq $0x10, %r14
cmpq %rbx, %r14
jne 0x74495
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rbx
cmpq %r14, %rbx
je 0x744dc
movq %r14, %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x744ce
callq 0x1d330
addq $0x10, %r15
cmpq %rbx, %r15
jne 0x744c0
movq %r14, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1c806
leaq 0xc0(%rsp), %rdi
callq 0x1c84c
movw $0x1, 0x748a(%r12)
xorl %ebx, %ebx
jmp 0x745dd
leaq 0x9f5d9(%rip), %rsi     # 0x113ae5
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x79b5d(%rip), %rsi     # 0xee082
leaq 0x9f66b(%rip), %rdx     # 0x113b97
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x79ae5(%rip), %rsi     # 0xee034
leaq 0x9ef8e(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x31a, %ecx            # imm = 0x31A
jmp 0x73685
leaq 0x9fa2e(%rip), %rsi     # 0x113f98
leaq 0x8c0(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x79aff(%rip), %rsi     # 0xee082
leaq 0x9fcd3(%rip), %rdx     # 0x11425d
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %r12           # imm = 0x6C8A
leaq 0x79a87(%rip), %rsi     # 0xee034
leaq 0x9ef30(%rip), %rdx     # 0x1134e4
movq %r12, %rdi
movl $0x392, %ecx            # imm = 0x392
jmp 0x73685
leaq 0x20(%rsp), %rdi
callq 0x1c806
leaq 0xc0(%rsp), %rdi
callq 0x1c84c
movl $0x1, %ebx
leaq 0x60(%rsp), %rdi
callq 0x1c806
leaq 0x8c0(%rsp), %rdi
callq 0x1c84c
jmp 0x73694
jmp 0x746d7
jmp 0x74650
jmp 0x746d7
jmp 0x7460c
movq %rax, %r14
jmp 0x74619
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1d204
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x74628
callq 0x1d330
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x74672
callq 0x1d330
jmp 0x74672
jmp 0x74698
movq %rax, %r14
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
jne 0x74675
jmp 0x7467a
movq %rax, %r14
jmp 0x7467a
movq %rax, %r14
jmp 0x74665
movq %rax, %r14
movq %rbx, %rdi
callq 0x8380
movq %r13, %rdi
callq 0x8380
jmp 0x7467a
movq %rax, %r14
movq %r13, %rdi
callq 0x1d330
leaq 0x20(%rsp), %rdi
callq 0x1c806
leaq 0xc0(%rsp), %rdi
callq 0x1c84c
jmp 0x74701
movq %rax, %r14
jmp 0x746a8
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
callq 0x1d204
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x746b7
callq 0x1d330
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x746f9
callq 0x1d330
jmp 0x746f9
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
jne 0x746fc
jmp 0x74701
movq %rax, %r14
jmp 0x74701
movq %rax, %r14
jmp 0x746ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x8380
movq %r12, %rdi
callq 0x8380
jmp 0x74701
movq %rax, %r14
movq %r12, %rdi
callq 0x1d330
leaq 0x60(%rsp), %rdi
callq 0x1c806
leaq 0x8c0(%rsp), %rdi
callq 0x1c84c
movq %r14, %rdi
callq 0x8650