// File: /workspace/github_c_makefile_star2_O1/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 $0x10d8, %rsp           # imm = 0x10D8
movq %rsi, (%rsp)
cmpw $0x0, (%rcx)
movzwl 0x6c88(%rcx), %eax
je 0x76001
movq %rcx, %r15
movq %rdx, %rbp
movq %rdi, %rbx
testw %ax, %ax
jle 0x75f7c
leaq 0xa5316(%rip), %rdi     # 0x11b28d
callq 0x8510
cmpl $0x1, 0x83c(%r15)
movq (%rsp), %rdi
jne 0x75f98
cmpw $0x0, 0x4b4(%rdi)
je 0x760fe
movl 0x5a0(%rbx), %edx
cmpl $0x6, %edx
jb 0x7601d
leaq 0xa050d(%rip), %rsi     # 0x1164b7
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7b0bf(%rip), %rsi     # 0xf1082
leaq 0xa0545(%rip), %rdx     # 0x11650f
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7b047(%rip), %rsi     # 0xf1034
leaq 0xa04b0(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x2e7, %ecx            # imm = 0x2E7
jmp 0x76157
xorl %ebx, %ebx
testw %ax, %ax
jle 0x76166
leaq 0xa53dd(%rip), %rdi     # 0x11b3f0
callq 0x8510
jmp 0x76166
movl 0x620(%rbx), %edx
cmpl $0x4, %edx
jb 0x76086
leaq 0xa054f(%rip), %rsi     # 0x11657e
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7b03a(%rip), %rsi     # 0xf1082
leaq 0xa058c(%rip), %rdx     # 0x1165db
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7afc2(%rip), %rsi     # 0xf1034
leaq 0xa042b(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x2ec, %ecx            # imm = 0x2EC
jmp 0x76157
cmpw $0x1, 0x4c6(%rdi)
jne 0x7617a
movl 0x638(%rbx), %edx
cmpl $0x2, %edx
jb 0x7617a
leaq 0xa059c(%rip), %rsi     # 0x116646
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7afbf(%rip), %rsi     # 0xf1082
leaq 0xa05dd(%rip), %rdx     # 0x1166a7
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7af47(%rip), %rsi     # 0xf1034
leaq 0xa03b0(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x2f2, %ecx            # imm = 0x2F2
jmp 0x76157
leaq 0xa0295(%rip), %rsi     # 0x11639a
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7af64(%rip), %rsi     # 0xf1082
leaq 0xa0346(%rip), %rdx     # 0x11646b
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7aeec(%rip), %rsi     # 0xf1034
leaq 0xa0355(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x2e2, %ecx            # imm = 0x2E2
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebx
movl %ebx, %eax
addq $0x10d8, %rsp           # imm = 0x10D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpw $0x1, 0x4c4(%rdi)
jne 0x761ed
movl 0x650(%rbx), %edx
cmpl $0x4, %edx
jb 0x761ed
leaq 0xa0576(%rip), %rsi     # 0x11670c
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7aed3(%rip), %rsi     # 0xf1082
leaq 0xa05a8(%rip), %rdx     # 0x11675e
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7ae5b(%rip), %rsi     # 0xf1034
leaq 0xa02c4(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x2fa, %ecx            # imm = 0x2FA
jmp 0x76157
cmpw $0x1, 0x4be(%rdi)
jne 0x7629b
movl 0x660(%rbx), %edx
cmpl $0x4, %edx
jb 0x76264
leaq 0xa05a4(%rip), %rsi     # 0x1167b1
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7ae5c(%rip), %rsi     # 0xf1082
leaq 0xa05d8(%rip), %rdx     # 0x116805
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7ade4(%rip), %rsi     # 0xf1034
leaq 0xa024d(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x302, %ecx            # imm = 0x302
jmp 0x76157
cmpw $0x1, 0x3e(%r15)
jne 0x7629b
cmpw $0x0, 0x6c88(%r15)
jle 0x7629b
movq 0xd5cc2(%rip), %rax     # 0x14bf40
movq (%rax), %rcx
leaq 0xa05da(%rip), %rdi     # 0x116862
movl $0x1b8, %esi            # imm = 0x1B8
movl $0x1, %edx
callq 0x86d0
movq (%rsp), %rdi
cmpw $0x1, 0x4c2(%rdi)
jne 0x763af
leaq 0xc8(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0xb8(%rsp), %rcx
xorpd %xmm0, %xmm0
movq %rdi, %r14
callq 0x6074e
cmpl $0x1, %eax
jne 0x7631e
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x7b110(%rip), %rsi     # 0xf13f0
leaq 0xa0734(%rip), %rdx     # 0x116a1b
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7ad2a(%rip), %rsi     # 0xf1034
leaq 0xa0193(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x30f, %ecx            # imm = 0x30F
jmp 0x7681e
movsd 0x7af3a(%rip), %xmm0    # 0xf1260
leaq 0xc0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0xb8(%rsp), %rcx
movq %r14, %rdi
callq 0x6074e
cmpl $0x1, %eax
jne 0x76397
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0x7b097(%rip), %rsi     # 0xf13f0
leaq 0xa0701(%rip), %rdx     # 0x116a61
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7acb1(%rip), %rsi     # 0xf1034
leaq 0xa011a(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x310, %ecx            # imm = 0x310
jmp 0x7681e
cmpw $0x0, 0x2d8(%r14)
movq %r14, %rdi
jne 0x763af
cmpl $0x1, 0x40(%rdi)
jne 0x766f0
cmpw $0x1, 0x4b8(%rdi)
jne 0x76437
cmpw $0x1, 0x18(%r15)
je 0x763d9
cmpw $0x1, 0x16(%r15)
je 0x763d9
cmpw $0x1, 0x1a(%r15)
je 0x763d9
cmpw $0x1, 0x1c(%r15)
jne 0x76437
leaq 0xa0897(%rip), %rsi     # 0x116c77
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7ac89(%rip), %rsi     # 0xf1082
leaq 0xa08c6(%rip), %rdx     # 0x116cc6
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7ac11(%rip), %rsi     # 0xf1034
leaq 0xa007a(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x329, %ecx            # imm = 0x329
jmp 0x76157
movzwl 0x4bc(%rdi), %eax
xorl %ecx, %ecx
cmpw $0x1, %ax
sete %cl
movw %cx, 0x8(%r15)
xorl %ecx, %ecx
cmpw $0x1, 0x238(%rdi)
sete %cl
movw %cx, 0x4(%r15)
movl $0x0, 0x810(%r15)
cmpw $0x1, 0x4b6(%rdi)
jne 0x764b0
movsd 0x7d8(%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x76488
jnp 0x764b0
movq (%rsp), %rcx
cmpw $0x1, 0x4c2(%rcx)
jne 0x764a0
movw $0x1, 0x812(%r15)
cmpw $0x1, %ax
jne 0x76516
movw $0x1, 0x810(%r15)
cmpw $0x1, %ax
jne 0x76516
movq (%rsp), %rax
cmpl $0x2, 0x160(%rax)
jne 0x76516
cmpw $0x0, 0x6c88(%r15)
jle 0x76516
cmpl $0x1, 0x678(%rbx)
jne 0x76516
movq %rbx, %r14
movq 0xd5a5f(%rip), %rbx     # 0x14bf40
movq (%rbx), %rcx
leaq 0xa0847(%rip), %rdi     # 0x116d32
movl $0x84, %esi
movl $0x1, %edx
callq 0x86d0
movq (%rbx), %rcx
movq %r14, %rbx
leaq 0xa08b0(%rip), %rdi     # 0x116db7
movl $0x64, %esi
movl $0x1, %edx
callq 0x86d0
cmpw $0x1, 0x10(%r15)
jne 0x7657c
leaq 0xa08f7(%rip), %rsi     # 0x116e1c
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7ab44(%rip), %rsi     # 0xf1082
leaq 0x938c4(%rip), %rdx     # 0x109e09
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7aacc(%rip), %rsi     # 0xf1034
leaq 0x9ff35(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x34e, %ecx            # imm = 0x34E
jmp 0x76157
cmpw $0x1, 0x1c(%r15)
jne 0x7659b
cmpw $0x0, 0x6c88(%r15)
jle 0x7659b
leaq 0xa4d09(%rip), %rdi     # 0x11b29f
callq 0x8510
cmpw $0x1, 0x12(%r15)
jne 0x76604
movl $0x0, 0x24(%r15)
movl 0x20(%r15), %eax
cmpl $0x2, %eax
je 0x765de
cmpl $0x1, %eax
jne 0x76604
movq (%rsp), %rax
cmpw $0x1, 0x4c4(%rax)
je 0x765d5
movq (%rsp), %rax
cmpw $0x1, 0x4be(%rax)
jne 0x76604
movw $0x1, 0x24(%r15)
jmp 0x76604
movq (%rsp), %rax
cmpw $0x1, 0x4c4(%rax)
jne 0x765f3
movw $0x1, 0x24(%r15)
cmpw $0x1, 0x4be(%rax)
jne 0x76604
movw $0x1, 0x26(%r15)
movq %rbx, %rdi
movq %rbx, %r14
movq (%rsp), %rbx
movq %rbx, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x7722e
testl %eax, %eax
je 0x76665
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7adc2(%rip), %rsi     # 0xf13f0
leaq 0xa07fd(%rip), %rdx     # 0x116e32
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x7a9e3(%rip), %rsi     # 0xf1034
leaq 0x9fe4c(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x383, %ecx            # imm = 0x383
jmp 0x7681e
movsd 0x818(%r15), %xmm0
movsd 0xf30(%rbp), %xmm1
ucomisd %xmm1, %xmm0
movq %r14, %rdi
jbe 0x767c9
cmpw $0x1, 0x834(%r15)
jne 0x767af
leaq 0xa07c3(%rip), %rsi     # 0x116e5c
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x30c2c
leaq 0x7a9d0(%rip), %rsi     # 0xf1082
leaq 0xa0888(%rip), %rdx     # 0x116f41
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7a958(%rip), %rsi     # 0xf1034
leaq 0x9fdc1(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x38c, %ecx            # imm = 0x38C
jmp 0x76157
movsd 0xc8(%rsp), %xmm1
movsd 0x7ab5f(%rip), %xmm2    # 0xf1260
addsd %xmm2, %xmm1
movsd 0xc0(%rsp), %xmm0
addsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x76c43
ucomisd 0x7b0bc(%rip), %xmm0    # 0xf17e8
jne 0x763af
jp 0x763af
movsd 0x90(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x763af
jp 0x763af
leaq 0xa0425(%rip), %rsi     # 0x116b7d
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7a911(%rip), %rsi     # 0xf1082
leaq 0xa04d4(%rip), %rdx     # 0x116c4c
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7a899(%rip), %rsi     # 0xf1034
leaq 0x9fd02(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x31f, %ecx            # imm = 0x31F
jmp 0x76157
cmpw $0x1, 0x87c(%r15)
jne 0x767c9
cmpw $0x0, 0x844(%r15)
je 0x7704b
movq %rbx, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %rdi, %r14
callq 0x7805e
testl %eax, %eax
je 0x76826
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7ac04(%rip), %rsi     # 0xf13f0
leaq 0xa0a86(%rip), %rdx     # 0x117279
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x7a825(%rip), %rsi     # 0xf1034
leaq 0x9fc8e(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x3a0, %ecx            # imm = 0x3A0
movq %rbx, %r8
jmp 0x7615a
movq %r14, 0xb0(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79425
callq 0x1c5f0
leaq 0x8d0(%rsp), %rdi
movl %eax, %esi
callq 0x1c6a0
xorpd %xmm0, %xmm0
movapd %xmm0, 0x70(%rsp)
movq $0x0, 0x80(%rsp)
cmpw $0x1, 0x130(%rbx)
jne 0x7688e
cmpw $0x0, 0x236(%rbx)
jne 0x7688e
cmpw $0x0, 0x6c88(%r15)
jle 0x7688e
leaq 0xa4aaf(%rip), %rdi     # 0x11b338
callq 0x8510
movl 0x854(%r15), %edx
testl %edx, %edx
movq %r15, 0x28(%rsp)
jle 0x76c1e
movabsq $0x100000001, %r12      # imm = 0x100000001
leaq 0xd393d(%rip), %rax     # 0x14a1f0
addq $0x10, %rax
movq %rax, 0xa8(%rsp)
movq $0x0, 0x8(%rsp)
movq %rbp, 0x88(%rsp)
cmpw $0x2, 0x6c88(%r15)
jl 0x768f1
movq 0x8(%rsp), %rax
leal 0x1(%rax), %esi
leaq 0xa09ca(%rip), %rdi     # 0x1172b4
xorl %eax, %eax
callq 0x8030
movq 0x870(%r15), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
testl %edx, %edx
jle 0x76c01
movq $0x0, 0x58(%rsp)
cmpw $0x2, 0x6c88(%r15)
jl 0x7694f
movq 0x58(%rsp), %rax
leal 0x1(%rax), %esi
leaq 0xa099e(%rip), %rdi     # 0x1172c9
xorl %eax, %eax
callq 0x8030
movq 0x9c8(%r15), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xa0994(%rip), %rdi     # 0x1172dc
xorl %eax, %eax
callq 0x8030
movq 0x9c8(%r15), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0x20(%rsp)
testl %eax, %eax
jle 0x76bde
movl $0x20, %edi
callq 0x83b0
movq %rax, %r14
movq %r12, 0x8(%rax)
movq 0xa8(%rsp), %rax
movq %rax, (%r14)
movl $0x68, %edi
callq 0x83b0
movq %rax, %rbx
movq %r12, 0x8(%rax)
leaq 0xd3f71(%rip), %rax     # 0x14a910
movq %rax, (%rbx)
movq %rbx, %r12
addq $0x10, %r12
movq %r12, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1d42e
movq 0x20(%rsp), %rax
leal -0x1(%rax), %ecx
movq %r14, %r13
addq $0x10, %r13
leaq 0xd3f91(%rip), %rax     # 0x14a960
movq %rax, 0x10(%rbx)
movq 0xb0(%rsp), %rax
movq %rax, 0x38(%rbx)
movq (%rsp), %rax
movq %rax, 0x40(%rbx)
movq %rbp, 0x48(%rbx)
movq %r15, 0x50(%rbx)
movq 0x8(%rsp), %rax
movl %eax, 0x58(%rbx)
movq 0x58(%rsp), %rax
movl %eax, 0x5c(%rbx)
movl %ecx, 0x50(%rsp)
movl %ecx, 0x60(%rbx)
movq %r12, 0x10(%r14)
movq %rbx, 0x18(%r14)
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x1d35e
movq %r13, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movq 0xd5584(%rip), %rax     # 0x14bfb0
cmpb $0x0, (%rax)
je 0x76a37
incl 0x8(%r14)
jmp 0x76a3c
lock
incl 0x8(%r14)
movl $0x1, %ebx
lock
xaddl %ebx, 0x8f0(%rsp)
movl 0x8d0(%rsp), %ecx
testl %ecx, %ecx
je 0x76aee
xorl %r15d, %r15d
leal (%rbx,%r15), %eax
xorl %edx, %edx
divl %ecx
movq 0x8f8(%rsp), %r13
imulq $0xb0, %rdx, %rbp
leaq 0x58(,%rbp), %rdi
addq %r13, %rdi
movq %rdi, 0xd0(%rsp)
callq 0x8080
movl %eax, %r12d
testl %eax, %eax
sete 0xd8(%rsp)
je 0x76aa9
leaq 0xd0(%rsp), %rdi
callq 0x1d17a
jmp 0x76ad2
addq %rbp, %r13
movq %r13, %rdi
leaq 0x30(%rsp), %rsi
callq 0x9668e
leaq 0xd0(%rsp), %rdi
callq 0x1d17a
subq $-0x80, %r13
movq %r13, %rdi
callq 0x81c0
testl %r12d, %r12d
je 0x76b7e
incl %r15d
movl 0x8d0(%rsp), %ecx
cmpl %ecx, %r15d
jb 0x76a5c
movl %ebx, %eax
xorl %edx, %edx
divl 0x8d0(%rsp)
movq 0x8f8(%rsp), %rbx
imulq $0xb0, %rdx, %r15
leaq (%rbx,%r15), %rax
addq $0x58, %rax
movq %rax, 0xd0(%rsp)
movb $0x0, 0xd8(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x1d20a
movabsq $0x100000001, %r12      # imm = 0x100000001
addq %r15, %rbx
movb $0x1, 0xd8(%rsp)
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
callq 0x9668e
leaq 0xd0(%rsp), %rdi
callq 0x1d17a
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x81c0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
movq 0x28(%rsp), %r15
je 0x76b9c
callq 0x1d2a6
jmp 0x76b9c
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
movabsq $0x100000001, %r12      # imm = 0x100000001
je 0x76b97
callq 0x1d2a6
movq 0x28(%rsp), %r15
movq 0x88(%rsp), %rbp
movq %r14, %rdi
callq 0x1d2a6
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1dcb8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x76bca
callq 0x1d2a6
cmpl $0x1, 0x20(%rsp)
movl 0x50(%rsp), %eax
movq %rax, 0x20(%rsp)
jg 0x7696b
movq 0x58(%rsp), %rsi
incl %esi
movq 0x870(%r15), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq %rsi, 0x58(%rsp)
cmpl %edx, %esi
jl 0x76911
movq 0x8(%rsp), %rcx
incq %rcx
movslq 0x854(%r15), %rdx
movq %rcx, 0x8(%rsp)
cmpq %rdx, %rcx
jl 0x768d0
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r14
cmpq %r14, %rbx
je 0x76ca1
movq %rbx, %rdi
callq 0x1c724
testl %eax, %eax
jne 0x770c0
addq $0x10, %rbx
jmp 0x76c28
leaq 0x9fe5b(%rip), %rsi     # 0x116aa5
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x7a41f(%rip), %rsi     # 0xf1082
leaq 0x9feed(%rip), %rdx     # 0x116b57
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x7a3a7(%rip), %rsi     # 0xf1034
leaq 0x9f810(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x31a, %ecx            # imm = 0x31A
jmp 0x76157
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r14
cmpq %rbx, %r14
je 0x76cd4
movq %rbx, %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x76cc1
callq 0x1d2a6
addq $0x10, %r15
cmpq %r14, %r15
jne 0x76cb3
movq %rbx, 0x78(%rsp)
movq 0x28(%rsp), %r15
cmpl $0x2, 0xa60(%r15)
jl 0x7703d
callq 0x1c5f0
leaq 0xd0(%rsp), %rdi
movl %eax, %esi
callq 0x1c6a0
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
cmpl $0x0, 0x854(%r15)
jle 0x76fce
xorl %r12d, %r12d
movabsq $0x100000001, %r13      # imm = 0x100000001
leaq 0xd34c5(%rip), %rax     # 0x14a1f0
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x870(%r15), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0x76fbb
movl $0x0, (%rsp)
movq %r12, 0x50(%rsp)
movq 0x998(%r15), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0x76fa2
movl $0x0, 0x20(%rsp)
movl $0x20, %edi
callq 0x83b0
movq %rax, %r14
movq %r13, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movl $0x50, %edi
callq 0x83b0
movq %rax, %rbx
movq %r13, 0x8(%rax)
leaq 0xd3c53(%rip), %rax     # 0x14a9f0
movq %rax, (%rbx)
movq %rbx, %r12
addq $0x10, %r12
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d42e
movq %r14, %rbp
addq $0x10, %rbp
leaq 0xd3c7e(%rip), %rax     # 0x14aa40
movq %rax, 0x10(%rbx)
movq %r15, 0x38(%rbx)
movq 0x50(%rsp), %rax
movl %eax, 0x40(%rbx)
movl (%rsp), %eax
movl %eax, 0x44(%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x48(%rbx)
movq %r12, 0x10(%r14)
movq %rbx, 0x18(%r14)
leaq 0x98(%rsp), %rdi
movq %rbp, %rsi
callq 0x1d35e
movq %rbp, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq 0xd51a8(%rip), %rax     # 0x14bfb0
cmpb $0x0, (%rax)
je 0x76e13
incl 0x8(%r14)
jmp 0x76e18
lock
incl 0x8(%r14)
movl $0x1, %ebx
lock
xaddl %ebx, 0xf0(%rsp)
movl 0xd0(%rsp), %ecx
testl %ecx, %ecx
je 0x76eb5
xorl %r15d, %r15d
leal (%rbx,%r15), %eax
xorl %edx, %edx
divl %ecx
movq 0xf8(%rsp), %r12
imulq $0xb0, %rdx, %r13
leaq (%r12,%r13), %rdi
addq $0x58, %rdi
movq %rdi, 0x10(%rsp)
callq 0x8080
movl %eax, %ebp
testl %eax, %eax
sete 0x18(%rsp)
je 0x76e78
leaq 0x10(%rsp), %rdi
callq 0x1d17a
jmp 0x76e9e
addq %r13, %r12
movq %r12, %rdi
leaq 0x60(%rsp), %rsi
callq 0x96df6
leaq 0x10(%rsp), %rdi
callq 0x1d17a
subq $-0x80, %r12
movq %r12, %rdi
callq 0x81c0
testl %ebp, %ebp
je 0x76f82
incl %r15d
movl 0xd0(%rsp), %ecx
cmpl %ecx, %r15d
jb 0x76e38
movl %ebx, %eax
xorl %edx, %edx
divl 0xd0(%rsp)
movq 0xf8(%rsp), %rbx
imulq $0xb0, %rdx, %r15
leaq (%rbx,%r15), %rax
addq $0x58, %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1d20a
movq 0x50(%rsp), %r12
movabsq $0x100000001, %r13      # imm = 0x100000001
addq %r15, %rbx
movb $0x1, 0x18(%rsp)
movq %rbx, %rdi
leaq 0x60(%rsp), %rsi
callq 0x96df6
leaq 0x10(%rsp), %rdi
callq 0x1d17a
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x81c0
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
movq 0x28(%rsp), %r15
je 0x76f39
callq 0x1d2a6
movq %r14, %rdi
callq 0x1d2a6
leaq 0x30(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1dcb8
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x76f65
callq 0x1d2a6
movl 0x20(%rsp), %ecx
incl %ecx
movq 0x998(%r15), %rax
movl %ecx, 0x20(%rsp)
cmpl (%rax,%r12,4), %ecx
jl 0x76d6c
jmp 0x76fa2
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
movq 0x28(%rsp), %r15
movq 0x50(%rsp), %r12
movabsq $0x100000001, %r13      # imm = 0x100000001
jne 0x76f34
jmp 0x76f39
movl (%rsp), %ecx
incl %ecx
movq 0x870(%r15), %rax
movl %ecx, (%rsp)
cmpl (%rax,%r12,4), %ecx
jl 0x76d52
incq %r12
movslq 0x854(%r15), %rax
cmpq %rax, %r12
jl 0x76d34
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r14
cmpq %r14, %rbx
je 0x76ff3
movq %rbx, %rdi
callq 0x1c724
testl %eax, %eax
jne 0x770a9
addq $0x10, %rbx
jmp 0x76fd8
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r14
cmpq %rbx, %r14
je 0x77026
movq %rbx, %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x77013
callq 0x1d2a6
addq $0x10, %r15
cmpq %r14, %r15
jne 0x77005
movq %rbx, 0x38(%rsp)
movq 0x28(%rsp), %r15
leaq 0x30(%rsp), %rdi
callq 0x1c770
leaq 0xd0(%rsp), %rdi
callq 0x1c7b0
movw $0x1, 0x748a(%r15)
xorl %ebx, %ebx
jmp 0x770c5
leaq 0x9ff06(%rip), %rsi     # 0x116f58
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x30c2c
leaq 0x7a017(%rip), %rsi     # 0xf1082
leaq 0xa01ab(%rip), %rdx     # 0x11721d
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %r15           # imm = 0x6C8A
leaq 0x79f9f(%rip), %rsi     # 0xf1034
leaq 0x9f408(%rip), %rdx     # 0x1164a4
movq %r15, %rdi
movl $0x392, %ecx            # imm = 0x392
jmp 0x76157
leaq 0x30(%rsp), %rdi
callq 0x1c770
leaq 0xd0(%rsp), %rdi
callq 0x1c7b0
movl $0x1, %ebx
leaq 0x70(%rsp), %rdi
callq 0x1c770
leaq 0x8d0(%rsp), %rdi
callq 0x1c7b0
jmp 0x76166
jmp 0x77154
jmp 0x77101
jmp 0x77154
movq %rax, %r15
jmp 0x77197
jmp 0x7718a
movq %rax, %r15
jmp 0x77114
movq %rax, %r15
jmp 0x771b8
movq %rax, %r15
jmp 0x771c0
movq %rax, %r15
movq %rbx, %rdi
callq 0x8380
movq %r14, %rdi
callq 0x8380
jmp 0x771c0
movq %rax, %r15
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
jne 0x771bb
jmp 0x771c0
movq %rax, %r15
jmp 0x771e9
jmp 0x771d9
movq %rax, %r15
jmp 0x77167
movq %rax, %r15
jmp 0x77207
movq %rax, %r15
jmp 0x7720f
movq %rax, %r15
movq %rbx, %rdi
callq 0x8380
movq %r14, %rdi
callq 0x8380
jmp 0x7720f
movq %rax, %r15
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
jne 0x7720a
jmp 0x7720f
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x1d17a
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x771a6
callq 0x1d2a6
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x771b8
callq 0x1d2a6
movq %r14, %rdi
callq 0x1d2a6
leaq 0x30(%rsp), %rdi
callq 0x1c770
leaq 0xd0(%rsp), %rdi
callq 0x1c7b0
jmp 0x7720f
movq %rax, %r15
leaq 0xd0(%rsp), %rdi
callq 0x1d17a
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x771f8
callq 0x1d2a6
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x77207
callq 0x1d2a6
movq %r14, %rdi
callq 0x1d2a6
leaq 0x70(%rsp), %rdi
callq 0x1c770
leaq 0x8d0(%rsp), %rdi
callq 0x1c7b0
movq %r15, %rdi
callq 0x8650