// File: /workspace/github_c_makefile_star2_O3/lesgourg[P]class_public/build/../source/perturbations.c
// Function: perturbations_init
int perturbations_init(
                       struct precision * ppr,
                       struct background * pba,
                       struct thermodynamics * pth,
                       struct perturbations * ppt
                       ) {

  /** Summary: */

  /** - define local variables */

  /* running index for modes */
  int index_md;
  /* running index for initial conditions */
  int index_ic;
  /* running index for wavenumbers */
  int index_k;
  /* running index for type of perturbation */
  int index_tp;
  /* background quantities */
  double w_fld_ini, w_fld_0,dw_over_da_fld,integral_fld;

  /** - perform preliminary checks */

  if (ppt->has_perturbations == _FALSE_) {
    if (ppt->perturbations_verbose > 0)
      printf("No sources requested. Perturbation module skipped.\n");
    return _SUCCESS_;
  }
  else {
    if (ppt->perturbations_verbose > 0)
      printf("Computing sources\n");
  }

  class_test((ppt->gauge == synchronous) && (pba->has_cdm == _FALSE_),
             ppt->error_message,
             "In the synchronous gauge, it is not self-consistent to assume no CDM: the later is used to define the initial timelike hypersurface. You can either add a negligible amount of CDM, or switch to newtonian gauge");

  class_test ((ppr->tight_coupling_approximation < first_order_MB) ||
              (ppr->tight_coupling_approximation > compromise_CLASS),
              ppt->error_message,
              "your tight_coupling_approximation is set to %d, out of range defined in perturbations.h",ppr->tight_coupling_approximation);

  class_test ((ppr->radiation_streaming_approximation < rsa_null) ||
              (ppr->radiation_streaming_approximation > rsa_none),
              ppt->error_message,
              "your radiation_streaming_approximation is set to %d, out of range defined in perturbations.h",ppr->radiation_streaming_approximation);

  if (pba->has_idr == _TRUE_){
    class_test ((ppr->idr_streaming_approximation < rsa_idr_none) ||
                (ppr->idr_streaming_approximation > rsa_idr_MD),
                ppt->error_message,
                "your idr_radiation_streaming_approximation is set to %d, out of range defined in perturbations.h",ppr->idr_streaming_approximation);
  }

  if (pba->has_ur == _TRUE_) {

    class_test ((ppr->ur_fluid_approximation < ufa_mb) ||
                (ppr->ur_fluid_approximation > ufa_none),
                ppt->error_message,
                "your ur_fluid_approximation is set to %d, out of range defined in perturbations.h",ppr->ur_fluid_approximation);
  }

  if (pba->has_ncdm == _TRUE_) {

    class_test ((ppr->ncdm_fluid_approximation < ncdmfa_mb) ||
                (ppr->ncdm_fluid_approximation > ncdmfa_none),
                ppt->error_message,
                "your ncdm_fluid_approximation is set to %d, out of range defined in perturbations.h",ppr->ncdm_fluid_approximation);

    if (ppt->has_nc_density == _TRUE_) {
      if (ppt->perturbations_verbose > 0) {
        fprintf(stdout," -> [WARNING:] You request the number count Cl's in presence of non-cold dark matter.\n    Like in all previous CLASS and CLASSgal versions, this will be inferred from the total matter density,\n    but it could make much more sense physically to compute it from the CDM+baryon density only.\n    To get the latter behavior you would just need to change one line in transfer.c:\n    search there for a comment starting with 'use here delta_cb'\n");
      }
    }

  }

  if (pba->has_fld == _TRUE_) {

    /* check values of w_fld at initial time and today. Since 'a' in the code stands for 'a/a_0', its current value is 1 by definition */
    class_call(background_w_fld(pba, 0., &w_fld_ini, &dw_over_da_fld, &integral_fld), pba->error_message, ppt->error_message);
    class_call(background_w_fld(pba, 1.,   &w_fld_0, &dw_over_da_fld, &integral_fld), pba->error_message, ppt->error_message);

    class_test(w_fld_ini >= 0.,
               ppt->error_message,
               "The fluid is meant to be negligible at early time, and unimportant for defining the initial conditions of other species. You are using parameters for which this assumption may break down, since at early times you have w_fld(a--->0) = %e >= 0",w_fld_ini);

    if (pba->use_ppf == _FALSE_) {

      class_test((w_fld_ini +1.0)*(w_fld_0+1.0) <= 0.0,
                 ppt->error_message,
                 "w crosses -1 between the infinite past and today, and this would lead to divergent perturbation equations for the fluid perturbations. Try to switch to PPF scheme: use_ppf = yes");

      /* the next check is meaningful at least for w(a) = w0 + wa*(1-a/a0); for general formulas and with use_ppf=no, you may prefer to comment it out... */
      class_test((w_fld_0 == -1.) && (dw_over_da_fld == 0.),
                 ppt->error_message,
                 "Your choice of a fluid with (w0,wa)=(-1,0) is not valid due to instabilities in the unphysical perturbations of such a fluid. Try instead with a plain cosmological constant or with PPF scheme: use_ppf = yes");

    }

  }

  if (pba->has_dcdm == _TRUE_) {

    class_test((ppt->has_cdi == _TRUE_) || (ppt->has_bi == _TRUE_) || (ppt->has_nid == _TRUE_) || (ppt->has_niv == _TRUE_),
               ppt->error_message,
               "Non-adiabatic initial conditions not coded in presence of decaying dark matter");

  }

  class_test(ppt->has_vectors == _TRUE_,
             ppt->error_message,
             "Vectors not coded yet");

  if ((ppt->has_niv == _TRUE_) && (ppt->perturbations_verbose > 0)) {
    printf("Warning: the niv initial conditions in CLASS (and also in CAMB) should still be double-checked: if you want to do it and send feedback, you are welcome!\n");
  }

  if (ppt->has_tensors == _TRUE_) {

    ppt->evolve_tensor_ur = _FALSE_;
    ppt->evolve_tensor_ncdm = _FALSE_;

    switch (ppt->tensor_method) {

    case (tm_photons_only):
      break;

    case (tm_massless_approximation):
      if ((pba->has_ur == _TRUE_) || (pba->has_ncdm == _TRUE_))
        ppt->evolve_tensor_ur = _TRUE_;
      break;

    case (tm_exact):
      if (pba->has_ur == _TRUE_)
        ppt->evolve_tensor_ur = _TRUE_;
      if (pba->has_ncdm == _TRUE_)
        ppt->evolve_tensor_ncdm = _TRUE_;
      break;
    }
  }

  /*
    class_test((pba->h > _h_BIG_) || (pba->h < _h_SMALL_),
    ppt->error_message,
    "Your value of pba->h=%e is out of the bounds [%e , %e] and could cause a crash of the perturbation ODE integration. If you want to force this barrier, you may comment it out in perturbation.c",
    pba->h,
    _h_SMALL_,
    _h_BIG_);

    class_test((pba->Omega0_b*pba->h*pba->h < _omegab_SMALL_) || (pba->Omega0_b*pba->h*pba->h > _omegab_BIG_),
    ppt->error_message,
    "Your value of omega_b=%e is out of the bounds [%e , %e] and could cause a crash of the perturbation ODE integration. If you want to force this barrier, you may comment it out in perturbation.c",
    pba->Omega0_b*pba->h*pba->h,
    _omegab_SMALL_,
    _omegab_BIG_);
  */

  /** - initialize all indices and lists in perturbations structure using perturbations_indices() */

  class_call(perturbations_indices(ppr,
                                   pba,
                                   pth,
                                   ppt),
             ppt->error_message,
             ppt->error_message);


  if (ppt->z_max_pk > pth->z_rec) {

    class_test(ppt->has_cmb == _TRUE_,
               ppt->error_message,
               "You requested a very high z_pk=%e, higher than z_rec=%e. This works very well when you don't ask for a calculation of the CMB source function(s). Remove any CMB from your output and try e.g. with 'output=mTk' or 'output=mTk,vTk'",
               ppt->z_max_pk,
               pth->z_rec);

    class_test((ppt->has_source_delta_m == _TRUE_) && (ppt->has_matter_source_in_current_gauge == _FALSE_),
               ppt->error_message,
               "You requested a very high z_pk=%e, higher than z_rec=%e. This works very well when you ask only transfer functions, e.g. with 'output=mTk' or 'output=mTk,vTk'. But if you need the total matter (e.g. with 'mPk', 'dCl', etc.) there is an issue with the calculation of delta_m (or delta_cb) at very early times. By default, delta_m and delta_cb are expressed by the code as gauge-invariant variables (the density fluctuation in comoving gauge). This quantity is hard to get accurately at very early times. The solution is to define delta_m and delta_cb as density fluctuations in the current gauge, e.g. synchronous or newtonian. This is done by setting the input flag 'matter_source_in_current_gauge' to 'yes'.",
               ppt->z_max_pk,
               pth->z_rec);

  }



  /** - define the common time sampling for all sources using
      perturbations_timesampling_for_sources() */

  class_call(perturbations_timesampling_for_sources(ppr,
                                                    pba,
                                                    pth,
                                                    ppt),
             ppt->error_message,
             ppt->error_message);

  /** - if we want to store perturbations for given k values, write titles and allocate storage */
  class_call(perturbations_prepare_k_output(pba,ppt),
             ppt->error_message,
             ppt->error_message);

  /* Setup task system */
  class_setup_parallel();
  /** - loop over modes (scalar, tensors, etc). For each mode: */
  for (index_md = 0; index_md < ppt->md_size; index_md++) {

    if (ppt->perturbations_verbose > 1)
      printf("Evolving mode %d/%d\n",index_md+1,ppt->md_size);

    /** - --> loop over initial conditions and wavenumbers; for each of them, evolve perturbations and compute source functions with perturbations_solve() */

    for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {

      if (ppt->perturbations_verbose > 1) {
        printf("Evolving ic %d/%d\n",index_ic+1,ppt->ic_size[index_md]);
        printf("evolving %d wavenumbers\n",ppt->k_size[index_md]);
      }

      /* integrating backwards is slightly more optimal for parallel runs */
      //for (index_k = 0; index_k < ppt->k_size; index_k++) {
      for (index_k = ppt->k_size[index_md]-1; index_k >=0; index_k--) {

        class_run_parallel(with_arguments(ppr,pba,pth,ppt,index_md,index_ic,index_k),

          if (ppt->perturbations_verbose > 2) {
            printf("evolving mode k=%e /Mpc  (%d/%d)",ppt->k[index_md][index_k],index_k+1,ppt->k_size[index_md]);
            if (pba->sgnK != 0)
              printf(" (for scalar modes, corresponds to nu=%e)",sqrt(ppt->k[index_md][index_k]*ppt->k[index_md][index_k]+pba->K)/sqrt(pba->sgnK*pba->K));
            printf("\n");
          }

          struct perturbations_workspace pw;
          class_call(perturbations_workspace_init(ppr,
                                                  pba,
                                                  pth,
                                                  ppt,
                                                  index_md,
                                                  &pw),
                     ppt->error_message,
                     ppt->error_message);

          class_call(perturbations_solve(ppr,
                                         pba,
                                         pth,
                                         ppt,
                                         index_md,
                                         index_ic,
                                         index_k,
                                         &pw),
                     ppt->error_message,
                     ppt->error_message);

          class_call(perturbations_workspace_free(ppt,index_md,&pw),
                     ppt->error_message,
                     ppt->error_message);
          return _SUCCESS_;

        );

      } /* end of loop over wavenumbers */

    } /* end of loop over initial conditions */

  } /* end loop over modes */

  class_finish_parallel();


  /** - spline the source array with respect to the time variable */

  if (ppt->ln_tau_size > 1) {

    class_setup_parallel();

    for (index_md = 0; index_md < ppt->md_size; index_md++) {

      for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {

        for (index_tp = 0; index_tp < ppt->tp_size[index_md]; index_tp++) {

          class_run_parallel(with_arguments(ppt, index_md, index_ic, index_tp),
            class_call(array_spline_table_lines(ppt->ln_tau,
                                                ppt->ln_tau_size,
                                                ppt->late_sources[index_md][index_ic * ppt->tp_size[index_md] + index_tp],
                                                ppt->k_size[index_md],
                                                ppt->ddlate_sources[index_md][index_ic*ppt->tp_size[index_md] + index_tp],
                                                _SPLINE_EST_DERIV_,
                                                ppt->error_message),
                       ppt->error_message,
                       ppt->error_message);
            return _SUCCESS_;
          );

        } /* end of loop over type of source function*/

      } /* end of loop over initial condition */

    } /* end of loop over mode */

    class_finish_parallel();
  }

  ppt->is_allocated = _TRUE_;

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10d8, %rsp           # imm = 0x10D8
cmpw $0x0, (%rcx)
movzwl 0x6bf0(%rcx), %eax
je 0x69308
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r8
movq %rdi, %rsi
testw %ax, %ax
jle 0x69285
leaq 0x9c179(%rip), %rdi     # 0x1053e7
movq %rbx, %r14
movq %r8, %rbx
movq %rsi, %r15
callq 0x8510
movq %r15, %rsi
movq %rbx, %r8
movq %r14, %rbx
cmpl $0x1, 0x7f4(%r12)
jne 0x6929f
cmpw $0x0, 0x320(%r8)
je 0x69406
movl 0x5a0(%rsi), %edx
cmpl $0x6, %edx
jb 0x69324
leaq 0x97529(%rip), %rsi     # 0x1007da
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x75db8(%rip), %rsi     # 0xdf082
leaq 0x97561(%rip), %rdx     # 0x100832
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75d40(%rip), %rsi     # 0xdf034
leaq 0x974cc(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x2dd, %ecx            # imm = 0x2DD
jmp 0x6945f
xorl %ebx, %ebx
testw %ax, %ax
jle 0x6946e
leaq 0x9c178(%rip), %rdi     # 0x105492
callq 0x8510
jmp 0x6946e
movl 0x620(%rsi), %edx
cmpl $0x4, %edx
jb 0x6938d
leaq 0x9756b(%rip), %rsi     # 0x1008a1
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x75d33(%rip), %rsi     # 0xdf082
leaq 0x975a8(%rip), %rdx     # 0x1008fe
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75cbb(%rip), %rsi     # 0xdf034
leaq 0x97447(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x2e2, %ecx            # imm = 0x2E2
jmp 0x6945f
cmpw $0x1, 0x332(%r8)
jne 0x69482
movl 0x638(%rsi), %edx
cmpl $0x2, %edx
jb 0x69482
leaq 0x975b7(%rip), %rsi     # 0x100969
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x75cb7(%rip), %rsi     # 0xdf082
leaq 0x975f8(%rip), %rdx     # 0x1009ca
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75c3f(%rip), %rsi     # 0xdf034
leaq 0x973cb(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x2e8, %ecx            # imm = 0x2E8
jmp 0x6945f
leaq 0x972b0(%rip), %rsi     # 0x1006bd
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x75c5c(%rip), %rsi     # 0xdf082
leaq 0x97361(%rip), %rdx     # 0x10078e
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75be4(%rip), %rsi     # 0xdf034
leaq 0x97370(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x2d8, %ecx            # imm = 0x2D8
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
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, 0x330(%r8)
jne 0x694f6
movl 0x650(%rsi), %edx
cmpl $0x4, %edx
jb 0x694f6
leaq 0x97590(%rip), %rsi     # 0x100a2f
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x75bca(%rip), %rsi     # 0xdf082
leaq 0x975c2(%rip), %rdx     # 0x100a81
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75b52(%rip), %rsi     # 0xdf034
leaq 0x972de(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x2f0, %ecx            # imm = 0x2F0
jmp 0x6945f
cmpw $0x1, 0x32a(%r8)
jne 0x695b5
movl 0x660(%rsi), %edx
cmpl $0x4, %edx
jb 0x6956e
leaq 0x975bd(%rip), %rsi     # 0x100ad4
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x75b52(%rip), %rsi     # 0xdf082
leaq 0x975f1(%rip), %rdx     # 0x100b28
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75ada(%rip), %rsi     # 0xdf034
leaq 0x97266(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x2f8, %ecx            # imm = 0x2F8
jmp 0x6945f
cmpw $0x1, 0x36(%r12)
jne 0x695b5
cmpw $0x0, 0x6bf0(%r12)
jle 0x695b5
movq 0xca9e6(%rip), %rax     # 0x133f70
movq (%rax), %rcx
leaq 0x975f1(%rip), %rdi     # 0x100b85
movq %rsi, %r15
movl $0x1b8, %esi            # imm = 0x1B8
movl $0x1, %edx
movq %rbx, %r14
movq %r8, %rbx
callq 0x86d0
movq %r15, %rsi
movq %rbx, %r8
movq %r14, %rbx
cmpw $0x1, 0x32e(%r8)
jne 0x696e4
movq %rsi, %r15
leaq 0xc8(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0xb8(%rsp), %rcx
xorpd %xmm0, %xmm0
movq %r8, %rdi
movq %r8, %r14
callq 0x56265
cmpl $0x1, %eax
jne 0x6963f
addq $0xb84, %r14            # imm = 0xB84
leaq 0x75def(%rip), %rsi     # 0xdf3f0
leaq 0x97736(%rip), %rdx     # 0x100d3e
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75a09(%rip), %rsi     # 0xdf034
leaq 0x97195(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x305, %ecx            # imm = 0x305
jmp 0x69b1a
movsd 0x75c19(%rip), %xmm0    # 0xdf260
leaq 0xc0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0xb8(%rsp), %rcx
movq %r14, %rdi
callq 0x56265
cmpl $0x1, %eax
jne 0x696b8
addq $0xb84, %r14            # imm = 0xB84
leaq 0x75d76(%rip), %rsi     # 0xdf3f0
leaq 0x97703(%rip), %rdx     # 0x100d84
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75990(%rip), %rsi     # 0xdf034
leaq 0x9711c(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x306, %ecx            # imm = 0x306
jmp 0x69b1a
movsd 0xc8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x69863
movq %r14, %r8
cmpw $0x0, 0x110(%r14)
movq %r15, %rsi
je 0x699e5
cmpw $0x1, 0x324(%r8)
jne 0x69775
cmpw $0x1, 0xe(%r12)
je 0x69717
cmpw $0x1, 0xc(%r12)
je 0x69717
cmpw $0x1, 0x10(%r12)
je 0x69717
cmpw $0x1, 0x12(%r12)
jne 0x69775
leaq 0x9797e(%rip), %rsi     # 0x10109c
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x7594b(%rip), %rsi     # 0xdf082
leaq 0x979ad(%rip), %rdx     # 0x1010eb
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x758d3(%rip), %rsi     # 0xdf034
leaq 0x9705f(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x31f, %ecx            # imm = 0x31F
jmp 0x6945f
cmpw $0x1, 0x6(%r12)
jne 0x697dc
leaq 0x979d2(%rip), %rsi     # 0x101157
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x758e4(%rip), %rsi     # 0xdf082
leaq 0x8b2e9(%rip), %rdx     # 0xf4a8e
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x7586c(%rip), %rsi     # 0xdf034
leaq 0x96ff8(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x325, %ecx            # imm = 0x325
jmp 0x6945f
cmpw $0x1, 0x12(%r12)
jne 0x6980f
cmpw $0x0, 0x6bf0(%r12)
jle 0x6980f
leaq 0x9bc01(%rip), %rdi     # 0x1053f9
movq %rbx, %r14
movq %r8, %rbx
movq %rsi, %r15
callq 0x8510
movq %r15, %rsi
movq %rbx, %r8
movq %r14, %rbx
cmpw $0x1, 0x8(%r12)
jne 0x698e7
movl $0x0, 0x1c(%r12)
movl 0x18(%r12), %eax
cmpl $0x2, %eax
je 0x698c1
cmpl $0x1, %eax
jne 0x698e7
cmpw $0x1, 0x330(%r8)
je 0x69856
cmpw $0x1, 0x32a(%r8)
jne 0x698e7
movw $0x1, 0x1c(%r12)
jmp 0x698e7
leaq 0x9755e(%rip), %rsi     # 0x100dc8
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x757ff(%rip), %rsi     # 0xdf082
leaq 0x97630(%rip), %rdx     # 0x100eba
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75787(%rip), %rsi     # 0xdf034
leaq 0x96f13(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x30a, %ecx            # imm = 0x30A
jmp 0x6945f
cmpw $0x1, 0x330(%r8)
jne 0x698d4
movw $0x1, 0x1c(%r12)
cmpw $0x1, 0x32a(%r8)
jne 0x698e7
movw $0x1, 0x1e(%r12)
movq %rsi, %rdi
movq %rsi, %r15
movq %r8, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %rbx, %r14
movq %r8, %rbx
callq 0x6a476
testl %eax, %eax
je 0x6994a
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75add(%rip), %rsi     # 0xdf3f0
leaq 0x97853(%rip), %rdx     # 0x10116d
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x756fe(%rip), %rsi     # 0xdf034
leaq 0x96e8a(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x35a, %ecx            # imm = 0x35A
jmp 0x69b1a
movq %r15, 0x80(%rsp)
movsd 0x7d0(%r12), %xmm0
movq %r14, 0x88(%rsp)
movsd 0xf30(%r14), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x69abb
cmpw $0x1, 0x7ec(%r12)
jne 0x69a9f
leaq 0x97809(%rip), %rsi     # 0x101197
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x756db(%rip), %rsi     # 0xdf082
leaq 0x978ce(%rip), %rdx     # 0x10127c
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75663(%rip), %rsi     # 0xdf034
leaq 0x96def(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x363, %ecx            # imm = 0x363
jmp 0x6945f
movsd 0x75873(%rip), %xmm2    # 0xdf260
addsd %xmm2, %xmm0
movsd 0xc0(%rsp), %xmm1
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jae 0x6a25b
ucomisd 0x75dd0(%rip), %xmm1    # 0xdf7e8
jne 0x696e4
jp 0x696e4
movsd 0x90(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x696e4
jp 0x696e4
leaq 0x9755a(%rip), %rsi     # 0x100fa2
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x75621(%rip), %rsi     # 0xdf082
leaq 0x97609(%rip), %rdx     # 0x101071
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x755a9(%rip), %rsi     # 0xdf034
leaq 0x96d35(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x315, %ecx            # imm = 0x315
jmp 0x6945f
cmpw $0x1, 0x834(%r12)
jne 0x69abb
cmpw $0x0, 0x7f8(%r12)
je 0x6a2b9
movq 0x80(%rsp), %rdi
movq %rbx, %rsi
movq 0x88(%rsp), %rdx
movq %r12, %rcx
callq 0x6b26d
testl %eax, %eax
je 0x69b22
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x75908(%rip), %rsi     # 0xdf3f0
leaq 0x97ac5(%rip), %rdx     # 0x1015b4
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x75529(%rip), %rsi     # 0xdf034
leaq 0x96cb5(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x377, %ecx            # imm = 0x377
movq %rbx, %r8
jmp 0x69462
movq %rbx, 0xb0(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6c616
callq 0x1c686
leaq 0x8d0(%rsp), %rdi
movl %eax, %esi
callq 0x1c736
xorpd %xmm0, %xmm0
movapd %xmm0, 0x60(%rsp)
movq $0x0, 0x70(%rsp)
movl 0x808(%r12), %edx
testl %edx, %edx
movq %r12, 0x48(%rsp)
jle 0x69f02
movabsq $0x100000001, %r14      # imm = 0x100000001
leaq 0xc870e(%rip), %rax     # 0x132290
addq $0x10, %rax
movq %rax, 0xa8(%rsp)
movq $0x0, (%rsp)
cmpw $0x2, 0x6bf0(%r12)
jl 0x69bb7
movq (%rsp), %rax
leal 0x1(%rax), %esi
leaq 0x97a3f(%rip), %rdi     # 0x1015ef
xorl %eax, %eax
callq 0x8030
movq 0x828(%r12), %rax
movq (%rsp), %rcx
movl (%rax,%rcx,4), %edx
testl %edx, %edx
jle 0x69e90
movq $0x0, 0x18(%rsp)
cmpw $0x2, 0x6bf0(%r12)
jl 0x69c16
movq 0x18(%rsp), %rax
leal 0x1(%rax), %esi
leaq 0x97a12(%rip), %rdi     # 0x101604
xorl %eax, %eax
callq 0x8030
movq 0x950(%r12), %rax
movq (%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x97a08(%rip), %rdi     # 0x101617
xorl %eax, %eax
callq 0x8030
movq 0x950(%r12), %rax
movq (%rsp), %rcx
movl (%rax,%rcx,4), %r15d
testl %r15d, %r15d
jle 0x69e6d
movl $0x20, %edi
callq 0x83b0
movq %rax, %r12
movq %r14, 0x8(%rax)
movq 0xa8(%rsp), %rax
movq %rax, (%r12)
movl $0x68, %edi
callq 0x83b0
movq %rax, %rbx
movq %r14, 0x8(%rax)
leaq 0xc8cdc(%rip), %rax     # 0x132940
movq %rax, (%rbx)
movq %rbx, %r14
addq $0x10, %r14
movq %r14, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1d4aa
movq %r15, 0x40(%rsp)
leal -0x1(%r15), %ebp
movq %r12, %r15
addq $0x10, %r15
leaq 0xc8cfb(%rip), %rax     # 0x132990
movq %rax, 0x10(%rbx)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rbx)
movq 0xb0(%rsp), %rax
movq %rax, 0x40(%rbx)
movq 0x88(%rsp), %rax
movq %rax, 0x48(%rbx)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rbx)
movq (%rsp), %rax
movl %eax, 0x58(%rbx)
movq 0x18(%rsp), %rax
movl %eax, 0x5c(%rbx)
movl %ebp, 0x60(%rbx)
movq %r14, 0x10(%r12)
movq %rbx, 0x18(%r12)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1d3e8
movq %r15, 0x20(%rsp)
movq %r12, 0x28(%rsp)
movq 0xca2b8(%rip), %rax     # 0x133fb8
cmpb $0x0, (%rax)
je 0x69d0c
incl 0x8(%r12)
jmp 0x69d12
lock
incl 0x8(%r12)
movl $0x1, %ebx
lock
xaddl %ebx, 0x8f0(%rsp)
movl 0x8d0(%rsp), %ecx
testl %ecx, %ecx
je 0x69d88
xorl %r15d, %r15d
leal (%rbx,%r15), %eax
xorl %edx, %edx
divl %ecx
movq 0x8f8(%rsp), %r14
imulq $0xb0, %rdx, %r13
leaq (%r14,%r13), %rdi
addq $0x58, %rdi
movq %rdi, 0xd0(%rsp)
callq 0x8080
testl %eax, %eax
sete 0xd8(%rsp)
je 0x69df2
leaq 0xd0(%rsp), %rdi
callq 0x1d204
incl %r15d
movl 0x8d0(%rsp), %ecx
cmpl %ecx, %r15d
jb 0x69d2e
jmp 0x69d8a
xorl %ecx, %ecx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movq 0x8f8(%rsp), %rbx
imulq $0xb0, %rdx, %r14
leaq (%rbx,%r14), %rax
addq $0x58, %rax
movq %rax, 0xd0(%rsp)
movb $0x0, 0xd8(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x1d294
addq %r14, %rbx
movb $0x1, 0xd8(%rsp)
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
callq 0x84bee
leaq 0xd0(%rsp), %rdi
callq 0x1d204
subq $-0x80, %rbx
movq %rbx, %rdi
jmp 0x69e16
addq %r13, %r14
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x84bee
leaq 0xd0(%rsp), %rdi
callq 0x1d204
subq $-0x80, %r14
movq %r14, %rdi
callq 0x81c0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x69e2a
callq 0x1d330
movq %r12, %rdi
callq 0x1d330
leaq 0x60(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1dd2e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x69e50
callq 0x1d330
cmpl $0x1, 0x40(%rsp)
movl %ebp, %r15d
movq 0x48(%rsp), %r12
movabsq $0x100000001, %r14      # imm = 0x100000001
jg 0x69c2f
movq 0x18(%rsp), %rsi
incl %esi
movq 0x828(%r12), %rax
movq (%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq %rsi, 0x18(%rsp)
cmpl %edx, %esi
jl 0x69bd7
movq (%rsp), %rcx
incq %rcx
movslq 0x808(%r12), %rdx
movq %rcx, (%rsp)
cmpq %rdx, %rcx
jl 0x69b96
movq 0x60(%rsp), %r14
movq 0x68(%rsp), %rbx
cmpq %rbx, %r14
je 0x69ede
movq %r14, %rdi
callq 0x1c7ba
testl %eax, %eax
jne 0x6a32e
addq $0x10, %r14
cmpq %rbx, %r14
jne 0x69ebb
movq 0x60(%rsp), %r14
movq 0x68(%rsp), %rbx
cmpq %r14, %rbx
je 0x69f02
movq %r14, %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x69ef4
callq 0x1d330
addq $0x10, %r15
cmpq %rbx, %r15
jne 0x69ee6
movq %r14, 0x68(%rsp)
cmpl $0x2, 0x9c8(%r12)
jl 0x6a249
callq 0x1c686
leaq 0xd0(%rsp), %rdi
movl %eax, %esi
callq 0x1c736
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl 0x808(%r12), %ecx
testl %ecx, %ecx
jle 0x6a232
movq 0x828(%r12), %rax
xorl %r15d, %r15d
leaq 0xc8336(%rip), %rdx     # 0x132290
addq $0x10, %rdx
movq %rdx, 0x18(%rsp)
cmpl $0x0, (%rax,%r15,4)
jle 0x6a1cd
movq 0x930(%r12), %rcx
movl $0x0, (%rsp)
cmpl $0x0, (%rcx,%r15,4)
jle 0x6a1b3
movl $0x0, 0x40(%rsp)
movl $0x20, %edi
callq 0x83b0
movq %rax, %r13
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r14, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%r13)
movl $0x50, %edi
callq 0x83b0
movq %rax, %rbx
movq %r14, 0x8(%rax)
leaq 0xc8a54(%rip), %rax     # 0x132a20
movq %rax, (%rbx)
movq %rbx, %r12
addq $0x10, %r12
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1d4aa
movq %r13, %rbp
addq $0x10, %rbp
leaq 0xc8a7f(%rip), %rax     # 0x132a70
movq %rax, 0x10(%rbx)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rbx)
movl %r15d, 0x40(%rbx)
movl (%rsp), %eax
movl %eax, 0x44(%rbx)
movl 0x40(%rsp), %eax
movl %eax, 0x48(%rbx)
movq %r12, 0x10(%r13)
movq %rbx, 0x18(%r13)
leaq 0x98(%rsp), %rdi
movq %rbp, %rsi
callq 0x1d3e8
movq %rbp, 0x50(%rsp)
movq %r13, 0x58(%rsp)
movq 0xc9f80(%rip), %rax     # 0x133fb8
cmpb $0x0, (%rax)
je 0x6a043
incl 0x8(%r13)
jmp 0x6a048
lock
incl 0x8(%r13)
movl $0x1, %ebx
lock
xaddl %ebx, 0xf0(%rsp)
movl 0xd0(%rsp), %ecx
testl %ecx, %ecx
je 0x6a0b1
xorl %ebp, %ebp
leal (%rbx,%rbp), %eax
xorl %edx, %edx
divl %ecx
movq 0xf8(%rsp), %r12
imulq $0xb0, %rdx, %r14
leaq (%r12,%r14), %rdi
addq $0x58, %rdi
movq %rdi, 0x8(%rsp)
callq 0x8080
testl %eax, %eax
sete 0x10(%rsp)
je 0x6a16d
leaq 0x8(%rsp), %rdi
callq 0x1d204
incl %ebp
movl 0xd0(%rsp), %ecx
cmpl %ecx, %ebp
jb 0x6a063
jmp 0x6a0b3
xorl %ecx, %ecx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movq 0xf8(%rsp), %rbx
imulq $0xb0, %rdx, %r14
leaq (%rbx,%r14), %rax
addq $0x58, %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1d294
movq 0x48(%rsp), %r12
addq %r14, %rbx
movb $0x1, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x50(%rsp), %rsi
callq 0x8535c
leaq 0x8(%rsp), %rdi
callq 0x1d204
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x81c0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x6a123
callq 0x1d330
movq %r13, %rdi
callq 0x1d330
leaq 0x20(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1dd2e
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x6a14f
callq 0x1d330
movl 0x40(%rsp), %eax
incl %eax
movq 0x930(%r12), %rcx
movl %eax, 0x40(%rsp)
cmpl (%rcx,%r15,4), %eax
jl 0x69f90
jmp 0x6a1ab
addq %r14, %r12
movq %r12, %rdi
leaq 0x50(%rsp), %rsi
callq 0x8535c
leaq 0x8(%rsp), %rdi
callq 0x1d204
subq $-0x80, %r12
movq %r12, %rdi
callq 0x81c0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
movq 0x48(%rsp), %r12
jne 0x6a11e
jmp 0x6a123
movq 0x828(%r12), %rax
movl (%rsp), %edx
incl %edx
movl %edx, (%rsp)
cmpl (%rax,%r15,4), %edx
jl 0x69f7d
movl 0x808(%r12), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0x69f63
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rbx
cmpq %rbx, %r14
je 0x6a20e
movq %r14, %rdi
callq 0x1c7ba
testl %eax, %eax
jne 0x6a317
addq $0x10, %r14
cmpq %rbx, %r14
jne 0x6a1eb
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rbx
cmpq %r14, %rbx
je 0x6a232
movq %r14, %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x6a224
callq 0x1d330
addq $0x10, %r15
cmpq %rbx, %r15
jne 0x6a216
movq %r14, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1c806
leaq 0xd0(%rsp), %rdi
callq 0x1c84c
movw $0x1, 0x73f2(%r12)
xorl %ebx, %ebx
jmp 0x6a333
leaq 0x96c68(%rip), %rsi     # 0x100eca
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x74e07(%rip), %rsi     # 0xdf082
leaq 0x96cfa(%rip), %rdx     # 0x100f7c
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x74d8f(%rip), %rsi     # 0xdf034
leaq 0x9651b(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x310, %ecx            # imm = 0x310
jmp 0x6945f
leaq 0x96fd3(%rip), %rsi     # 0x101293
leaq 0x8d0(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x74da9(%rip), %rsi     # 0xdf082
leaq 0x97278(%rip), %rdx     # 0x101558
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6bf2, %r12           # imm = 0x6BF2
leaq 0x74d31(%rip), %rsi     # 0xdf034
leaq 0x964bd(%rip), %rdx     # 0x1007c7
movq %r12, %rdi
movl $0x369, %ecx            # imm = 0x369
jmp 0x6945f
leaq 0x20(%rsp), %rdi
callq 0x1c806
leaq 0xd0(%rsp), %rdi
callq 0x1c84c
movl $0x1, %ebx
leaq 0x60(%rsp), %rdi
callq 0x1c806
leaq 0x8d0(%rsp), %rdi
callq 0x1c84c
jmp 0x6946e
jmp 0x6a42d
jmp 0x6a3a6
jmp 0x6a42d
jmp 0x6a362
movq %rax, %r14
jmp 0x6a36f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1d204
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x6a37e
callq 0x1d330
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x6a3c8
callq 0x1d330
jmp 0x6a3c8
jmp 0x6a3ee
movq %rax, %r14
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
jne 0x6a3cb
jmp 0x6a3d0
movq %rax, %r14
jmp 0x6a3d0
movq %rax, %r14
jmp 0x6a3bb
movq %rax, %r14
movq %rbx, %rdi
callq 0x8380
movq %r13, %rdi
callq 0x8380
jmp 0x6a3d0
movq %rax, %r14
movq %r13, %rdi
callq 0x1d330
leaq 0x20(%rsp), %rdi
callq 0x1c806
leaq 0xd0(%rsp), %rdi
callq 0x1c84c
jmp 0x6a457
movq %rax, %r14
jmp 0x6a3fe
movq %rax, %r14
leaq 0xd0(%rsp), %rdi
callq 0x1d204
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x6a40d
callq 0x1d330
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6a44f
callq 0x1d330
jmp 0x6a44f
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0x6a452
jmp 0x6a457
movq %rax, %r14
jmp 0x6a457
movq %rax, %r14
jmp 0x6a442
movq %rax, %r14
movq %rbx, %rdi
callq 0x8380
movq %r12, %rdi
callq 0x8380
jmp 0x6a457
movq %rax, %r14
movq %r12, %rdi
callq 0x1d330
leaq 0x60(%rsp), %rdi
callq 0x1c806
leaq 0x8d0(%rsp), %rdi
callq 0x1c84c
movq %r14, %rdi
callq 0x8650