// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_solve
int background_solve(
                     struct precision *ppr,
                     struct background *pba
                     ) {

  /** Summary: */

  /** - define local variables */

  /* parameters and workspace for the background_derivs function */
  struct background_parameters_and_workspace bpaw;
  /* vector of quantities to be integrated */
  double * pvecback_integration;
  /* vector of all background quantities */
  double * pvecback;
  /* comoving radius coordinate in Mpc (equal to conformal distance in flat case) */
  double comoving_radius=0.;

  /* VP: scalar field critical reshift and fractional energy density at z_c */
  double z_c_new, f_ede_new, phi_c_new, counter_scf = 0;
  /* parameters to find peak of pheno_axion/pheno_ADE EDE fluid */
  double z_peak_new;
 /* VP: some additional parameters in AxiCLASS */
  double integration_stepsize;
  double ac, n, anow, Tosc;
  short is_axion_converged = _FALSE_;
  double Omega0_axion_used=0;

  /* conformal distance in Mpc (equal to comoving radius in flat case) */
  double conformal_distance;

  /* evolvers */
  extern int evolver_rk(EVOLVER_PROTOTYPE);
  extern int evolver_ndf15(EVOLVER_PROTOTYPE);
  int (*generic_evolver)(EVOLVER_PROTOTYPE) = evolver_ndf15;

  /* initial and final loga values */
  double loga_ini, loga_final;
  /* growth factor today */
  double D_today;
  /* indices for the different arrays */
  int index_loga, index_scf;
  /* what parameters are used in the output? */
  int * used_in_output;

  /* index of ncdm species */
  int n_ncdm;

  /** - setup background workspace */
  bpaw.pba = pba;
  class_alloc(pvecback,pba->bg_size*sizeof(double),pba->error_message);
  bpaw.pvecback = pvecback;



  /** - Determine output vector */
  loga_final = 0.; // with our conventions, loga is in fact log(a/a_0); we integrate until today, when log(a/a_0) = 0
  pba->bt_size = ppr->background_Nloga;

  /** - allocate background tables */
  class_alloc(pba->tau_table,pba->bt_size * sizeof(double),pba->error_message);
  class_alloc(pba->z_table,pba->bt_size * sizeof(double),pba->error_message);

  class_alloc(pba->d2tau_dz2_table,pba->bt_size * sizeof(double),pba->error_message);
  class_alloc(pba->d2z_dtau2_table,pba->bt_size * sizeof(double),pba->error_message);

  class_alloc(pba->background_table,pba->bt_size * pba->bg_size * sizeof(double),pba->error_message);
  class_alloc(pba->d2background_dloga2_table,pba->bt_size * pba->bg_size * sizeof(double),pba->error_message);


  /** - define values of loga at which results will be stored */


  /** - choose the right evolver */
  switch (ppr->background_evolver) {

  case rk:
    generic_evolver = evolver_rk;
    if (pba->background_verbose > 1) {
      printf("%s\n", "Chose rk as generic_evolver");
    }
    break;

  case ndf15:
    generic_evolver = evolver_ndf15;
    if (pba->background_verbose > 1) {
      printf("%s\n", "Chose ndf15 as generic_evolver");
    }
    break;
  }
if(pba->Omega0_scf!=0){
  Omega0_axion_used = pba->Omega0_scf;
}
while(is_axion_converged == _FALSE_){
//VP: new to axiclass: To correctly incorporate the axion contribution to Omega_Lambda in the case where it is not known.
/** - allocate vector of quantities to be integrated */
class_alloc(pvecback_integration,pba->bi_size*sizeof(double),pba->error_message);

/** - impose initial conditions with background_initial_conditions() */
class_call(background_initial_conditions(ppr,pba,pvecback,pvecback_integration,&(loga_ini)),
           pba->error_message,
           pba->error_message);

 class_alloc(pba->loga_table,pba->bt_size * sizeof(double),pba->error_message);
 class_alloc(used_in_output, pba->bt_size*sizeof(int), pba->error_message);


   for (index_loga=0; index_loga<pba->bt_size; index_loga++) {
     pba->loga_table[index_loga] = loga_ini + index_loga*(loga_final-loga_ini)/(pba->bt_size-1);
     used_in_output[index_loga] = 1;
   }

  // is_axion_converged = _TRUE_;
  /** - perform the integration */
  class_call(generic_evolver(background_derivs,
                             loga_ini,
                             loga_final,
                             pvecback_integration,
                             used_in_output,
                             pba->bi_size,
                             &bpaw,
                             ppr->tol_background_integration,
                             ppr->smallest_allowed_variation,
                             background_timescale, //'evaluate_timescale', required by evolver_rk but not by ndf15
                             ppr->background_integration_stepsize,
                             pba->loga_table,
                             pba->bt_size,
                             background_sources,
                             NULL, //'print_variables' in evolver_rk could be set, but, not required
                             pba->error_message),
             pba->error_message,
             pba->error_message);


             /* VP: loop over background to ensure the closure relation, to be updated*/
     //
     if(pba->loop_over_background_for_closure_relation == _TRUE_){
       if(pba->scf_potential == axion || pba->scf_potential == axionquad){
         if(pba->Omega0_scf>0){
           //already included Omega_sf in the contribution
           is_axion_converged = _TRUE_;
         }else{
           class_test(pba->has_scf == _FALSE_,pba->error_message,"it's weird, you have loop_over_background_for_closure_relation = yes and  scf_potential = axion or axionquad but no scf, there must be a problem in your ini file!");
           pba->Omega0_axion = pvecback_integration[pba->index_bi_rho_scf]/pba->H0/pba->H0;
           // printf("pba->Omega0_axion %e Omega0_axion_used %e pba->precision_loop_over_background %e\n", pba->Omega0_axion,Omega0_axion_used,pba->precision_loop_over_background);
           if(pba->has_lambda == _TRUE_){
             // printf(" original Omega_Lambda %e \n",pba->Omega0_lambda);
             pba->Omega0_lambda-=pba->Omega0_axion;//we remove the axion contribution that we had "forgotten"
             pba->Omega0_lambda+=Omega0_axion_used;//initially, this is 0. As the code shoots it will be updated
             if(pba->background_verbose>0)printf(" adjusted Omega_Lambda to incorporate the axion contribution; new Omega_Lambda = %e  \n",pba->Omega0_lambda);
             if(pba->background_verbose>=10)printf("how far? new %e old %e rel. diff. %e \n",pba->Omega0_axion, Omega0_axion_used,(pba->Omega0_axion-Omega0_axion_used)/pba->Omega0_axion);

           }else if(pba->has_fld==_TRUE_){
             //if pba->has_lambda == _FALSE_ and pba->has_fld==_TRUE_ it means we are using pba->Omega0_fld to enforce the closure equation.
             pba->Omega0_fld -=pba->Omega0_axion;
             pba->Omega0_fld +=Omega0_axion_used;
             if(pba->background_verbose>0)printf(" adjusted Omega0_fld to incorporate the axion contribution; new Omega0_fld = %e  \n",pba->Omega0_fld);

           }
           //VP: test that the budget equation is satisfied or loop.
           if(fabs(pba->Omega0_axion-Omega0_axion_used)/pba->Omega0_axion<pba->precision_loop_over_background){
             //default is 1e-3
             is_axion_converged = _TRUE_;
           }
           else{
             Omega0_axion_used = pba->Omega0_axion;
             free(pvecback_integration);
             free(pba->loga_table);
             free(used_in_output);
            }
         }
       }else{
         //no axion or no loop required so we ignore the loop.
         is_axion_converged = _TRUE_;
       }
       }else{
         //no axion or no loop required so we ignore the loop.
         is_axion_converged = _TRUE_;
       }
  }
  /** - recover some quantities today */
  /* -> age in Gyears */
  pba->age = pvecback_integration[pba->index_bi_time]/_Gyr_over_Mpc_;
  /* -> conformal age in Mpc */
  pba->conformal_age = pvecback_integration[pba->index_bi_tau];
  /* -> contribution of decaying dark matter and dark radiation to the critical density today: */
  if (pba->has_dcdm == _TRUE_) {
    pba->Omega0_dcdm = pvecback_integration[pba->index_bi_rho_dcdm]/pba->H0/pba->H0;
  }




  if (pba->has_dr == _TRUE_){
    pba->Omega0_dr = pvecback_integration[pba->index_bi_rho_dr]/pba->H0/pba->H0;
  }
  /* -> scale-invariant growth rate today */
  D_today = pvecback_integration[pba->index_bi_D];
  if(pba->has_scf == _TRUE_){
    pba->f_ede = 0.0;
  }
  /** - In a loop over lines, fill rest of background table for
      quantities that depend on numbers like "conformal_age" or
      "D_today" that were calculated just before */
  for (index_loga=0; index_loga < pba->bt_size; index_loga++) {

    pba->background_table[index_loga*pba->bg_size+pba->index_bg_D]*= 1./D_today;

    conformal_distance = pba->conformal_age - pba->tau_table[index_loga];
    pba->background_table[index_loga*pba->bg_size+pba->index_bg_conf_distance] = conformal_distance;

    if (pba->sgnK == 0) { comoving_radius = conformal_distance; }
    else if (pba->sgnK == 1) { comoving_radius = sin(sqrt(pba->K)*conformal_distance)/sqrt(pba->K); }
    else if (pba->sgnK == -1) { comoving_radius = sinh(sqrt(-pba->K)*conformal_distance)/sqrt(-pba->K); }


    if(pba->scf_potential == axion || pba->scf_potential == phi_2n){
     /* Scalar field critical redshift and fractional energy density at z_c calculations */
     z_c_new = pba->z_table[index_loga];
     f_ede_new = pba->background_table[index_loga*pba->bg_size+pba->index_bg_Omega_scf];
     // printf("f_ede_new %e old fede %e z_c_new %e\n", f_ede_new,pba->f_ede,z_c_new);
     if(f_ede_new > pba->f_ede){//there's a small problem when axion behaves like DM
       pba->log10_z_c = log10(z_c_new);
       // pba->axion_ac = 1/z_c_new-1;
       pba->f_ede = f_ede_new;
       pba->phi_scf_c = pba->background_table[index_loga*pba->bg_size+pba->index_bg_phi_scf];
       // printf("z %e pba->f_ede %e\n", pba->z_table[i],pba->f_ede);
     }else{
       if(f_ede_new > pba->f_ede && pba->m_scf*pba->H0/pba->background_table[index_loga*pba->bg_size+pba->index_bg_H] <= pba->threshold_scf_fluid_m_over_H){
         pba->f_ede = f_ede_new;
         pba->phi_scf_c = pba->background_table[index_loga*pba->bg_size+pba->index_bg_phi_scf];
         pba->log10_z_c = log10(z_c_new);

       }
     }


    }

    /* EDE pheno_axion fluid calculations to determine f_ede_peak */
    if( pba->has_fld && pba->fluid_equation_of_state == EDE){
      if(pba->ede_parametrization == pheno_axion || pba->ede_parametrization == pheno_ADE ){
          z_peak_new = pba->z_table[index_loga];
          f_ede_new = pba->background_table[index_loga*pba->bg_size+pba->index_bg_Omega_fld];
          if(f_ede_new > pba->f_ede_peak){
            pba->a_peak = 1./(1+z_peak_new);
            pba->f_ede_peak = f_ede_new;
            if(pba->background_verbose>8) printf("f_ede_peak = %.2e \t>= %.2e = f_ede_now\n", pba->f_ede_peak, f_ede_new);
          }
          if(pba->background_verbose>2)printf(" -> early dark energy parameters z_peak_ede = %e\tf_ede(z_peak) = %.3e \n", 1/pba->a_peak-1,pba->f_ede_peak);
      }
    }


  // if(pba->log10_axion_ac == -30 && pba->has_scf == _TRUE_ && pba->scf_potential == axion){
  //   pba->log10_axion_ac = -1*pba->log10_z_c;
  //   pba->a_c = pow(10,pba->log10_axion_ac);
  //   printf("pba->log10_axion_ac %e w_scf %e\n", pba->log10_axion_ac,pba->w_scf);
  // }

    pba->background_table[index_loga*pba->bg_size+pba->index_bg_ang_distance] = comoving_radius/(1.+pba->z_table[index_loga]);
    pba->background_table[index_loga*pba->bg_size+pba->index_bg_lum_distance] = comoving_radius*(1.+pba->z_table[index_loga]);
  }

  /** - fill tables of second derivatives (in view of spline interpolation) */
  class_call(array_spline_table_lines(pba->z_table,
                                      pba->bt_size,
                                      pba->tau_table,
                                      1,
                                      pba->d2tau_dz2_table,
                                      _SPLINE_EST_DERIV_,
                                      pba->error_message),
             pba->error_message,
             pba->error_message);

  class_call(array_spline_table_lines(pba->tau_table,
                                      pba->bt_size,
                                      pba->z_table,
                                      1,
                                      pba->d2z_dtau2_table,
                                      _SPLINE_EST_DERIV_,
                                      pba->error_message),
             pba->error_message,
             pba->error_message);

  class_call(array_spline_table_lines(pba->loga_table,
                                      pba->bt_size,
                                      pba->background_table,
                                      pba->bg_size,
                                      pba->d2background_dloga2_table,
                                      _SPLINE_EST_DERIV_,
                                      pba->error_message),
             pba->error_message,
             pba->error_message);

  /** - compute remaining "related parameters" */

  /**  - so-called "effective neutrino number", computed at earliest
       time in interpolation table. This should be seen as a
       definition: Neff is the equivalent number of
       instantaneously-decoupled neutrinos accounting for the
       radiation density, beyond photons */

  pba->Neff = (pba->background_table[pba->index_bg_Omega_r]
               *pba->background_table[pba->index_bg_rho_crit]
               -pba->background_table[pba->index_bg_rho_g])
    /(7./8.*pow(4./11.,4./3.)*pba->background_table[pba->index_bg_rho_g]);

  /** - send information to standard output */
  if (pba->background_verbose > 0) {
    printf(" -> age = %f Gyr\n",pba->age);
    printf(" -> conformal age = %f Mpc\n",pba->conformal_age);
    printf(" -> H0 = %f km/s/Mpc\n",pba->H0/(1.e3 / _c_));
    printf(" -> N_eff = %g (summed over all species that are non-relativistic at early times) \n",pba->Neff);
  }

  if (pba->background_verbose > 2) {
    if ((pba->has_dcdm == _TRUE_)&&(pba->has_dr == _TRUE_)) {
      printf("    Decaying Cold Dark Matter details: (DCDM --> DR)\n");
      printf("     -> Omega0_dcdm = %f\n",pba->Omega0_dcdm);
      printf("     -> Omega0_dr = %f\n",pba->Omega0_dr);
      printf("     -> Omega0_dr+Omega0_dcdm = %f, input value = %f\n",
             pba->Omega0_dr+pba->Omega0_dcdm,pba->Omega0_dcdmdr);
      printf("     -> Omega_ini_dcdm/Omega_b = %f\n",pba->Omega_ini_dcdm/pba->Omega0_b);
    }
    if (pba->has_scf == _TRUE_) {
      printf("    Scalar field details:\n");
      printf("     -> Omega_scf = %g, wished %g\n",
      pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_scf]/pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_crit], pba->Omega0_scf);

      if(pba->scf_potential == axionquad){
      printf("Additional scf parameters used: \n");
      // printf("m_a = %g eV\n",(pba->scf_parameters[0]*pba->H0/1.5638e29));
      printf("m_a = %g eV\n",(pba->scf_parameters[0]));
      printf("H_0 = %g eV\n",pba->H0/_eV_over_Mpc_);
      if (pba->has_cdm == _TRUE_) printf("     -> scf fraction of cdm today = %g \n", (pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_scf]) / (pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_scf] + pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_cdm]) );
      // printf("     -> for reference, rho_crit today = %g \n",pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_crit]);

      }
      if(pba->scf_potential == axion){
      printf("Additional scf parameters used: \n");
      printf("n = %e m_a = %e eV, f_a/mpl = %e\n",pba->n_axion,(pba->m_scf*pba->H0/1.5638e29),pba->f_axion);
      if (pba->theta_axion == 0.0)
      {
        pba->theta_axion = pba->phi_ini_scf/pba->f_axion;
      }
      
      printf("     -> theta_ini = %e \t phi_ini = %e \n",pba->theta_axion , pba->phi_ini_scf);
      printf("     -> Exact log10(z_c) = %e \t f_ede = %e log10 f_ede = %e\n", pba->log10_z_c, pba->f_ede, log10(pba->f_ede));
      if(pba->log10_axion_ac > -30)printf("     -> approx log10(z_c) = %e pba->log10_axion_ac %e\n", log10(1/pow(10,pba->log10_axion_ac)-1),pba->log10_axion_ac);
      printf("     -> phi(z_c) = %e \n", pba->phi_scf_c);
      }
      if(pba->scf_potential ==phi_2n){
        printf("     -> approximate log10(z_c) = %e \t f_ede = %e\n", log10(1/pow(10,pba->log10_axion_ac)-1), pow(10,pba->log10_fraction_axion_ac));
        printf("     -> Exact log10(z_c) = %e \t f_ede = %e log10 f_ede = %e\n", pba->log10_z_c, pba->f_ede, log10(pba->f_ede));
        printf("     -> V0 = %e \t phi_i = %e => m_fld = %e pba->H0 %e\n", pba->V0_phi2n, pba->phi_ini_scf,pow(pow(2,pba->n_axion)*pba->V0_phi2n,0.5)/pba->H0,pba->H0);
      }

      if (pba->has_lambda == _TRUE_) {
        printf("     -> Omega_Lambda = %g, wished %g\n",
               pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_lambda]/pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_rho_crit], pba->Omega0_lambda);
      }
      if(pba->scf_potential==pol_times_exp || pba->scf_potential==double_exp )
      {
        printf("     -> parameters: [lambda, alpha, A, B] = \n");
        printf("                    [");
        for (index_scf=0; index_scf<pba->scf_parameters_size-1; index_scf++) {
          printf("%.3f, ",pba->scf_parameters[index_scf]);
        }
        printf("%.3f]\n",pba->scf_parameters[pba->scf_parameters_size-1]);
      }

    }
  }

  /**  - store information in the background structure */
  pba->Omega0_m = pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_Omega_m];
  pba->Omega0_r = pba->background_table[(pba->bt_size-1)*pba->bg_size+pba->index_bg_Omega_r];
  pba->Omega0_de = 1. - (pba->Omega0_m + pba->Omega0_r + pba->Omega0_k);

  /* Compute the density fraction of non-free-streaming matter (in the minimal LambdaCDM model, this would be just Omega_b + Omega_cdm). This definition takes into account interating, decaying and warm dark matter, but it would need to be refined if some part of the matter component was modelled by the fluid (fld) or the scalar field (scf). */
  pba->Omega0_nfsm =  pba->Omega0_b;
  if (pba->has_cdm == _TRUE_)
    pba->Omega0_nfsm += pba->Omega0_cdm;
  if (pba->has_idm == _TRUE_)
    pba->Omega0_nfsm += pba->Omega0_idm;
  if (pba->has_dcdm == _TRUE_)
    pba->Omega0_nfsm += pba->Omega0_dcdm;
  for (n_ncdm=0;n_ncdm<pba->N_ncdm; n_ncdm++) {
    /* here we define non-free-streaming matter as: any non-relatistic species with a dimensionless ratio m/T bigger than a threshold ppr->M_nfsm_threshold; if this threshold is of the order of 10^4, this corresponds to the condition "becoming non-relativistic during radiation domination". Beware: this definition won't work in the case in which the user passes a customised p.s.d. for ncdm, such that M_ncdm is not defined.  */
    if (pba->M_ncdm[n_ncdm] > ppr->M_nfsm_threshold) {
      pba->Omega0_nfsm += pba->Omega0_ncdm[n_ncdm];
    }
  }

  free(pvecback);
  free(pvecback_integration);

  pba->scf_kg_eq = _TRUE_; // COpertchange
  free(used_in_output);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1058, %rsp           # imm = 0x1058
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, 0x40(%rsp)
movslq 0x43c(%rsi), %rbp
movq %rbp, %rdi
shlq $0x3, %rdi
callq 0x8460
testq %rax, %rax
je 0x60322
movq %rax, %r14
movq %rax, 0x48(%rsp)
movslq 0x8(%r15), %r12
movl %r12d, 0x440(%rbx)
movq %r12, %r13
shlq $0x3, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x450(%rbx)
testq %rax, %rax
je 0x60368
movq %r13, %rdi
callq 0x8460
movq %rax, 0x458(%rbx)
testq %rax, %rax
je 0x603af
movq %r13, %rdi
callq 0x8460
movq %rax, 0x468(%rbx)
testq %rax, %rax
je 0x603f6
movq %r13, %rdi
callq 0x8460
movq %rax, 0x470(%rbx)
testq %rax, %rax
je 0x6043d
imull %ebp, %r12d
movslq %r12d, %r13
shlq $0x3, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x460(%rbx)
testq %rax, %rax
je 0x60484
movq %r13, %rdi
callq 0x8460
movq %rax, 0x478(%rbx)
testq %rax, %rax
je 0x604c7
movl 0xc(%r15), %eax
cmpl $0x1, %eax
je 0x6052b
testl %eax, %eax
jne 0x6054f
leaq -0x532d3(%rip), %rax    # 0xd030
movq %rax, 0x10(%rsp)
cmpw $0x1, 0xd1a(%rbx)
jle 0x6055b
leaq 0xabf05(%rip), %rdi     # 0x10c222
jmp 0x60548
leal (,%rbp,8), %ecx
leaq 0x8dcd4(%rip), %rsi     # 0xee004
leaq 0xb4f5b(%rip), %rdx     # 0x115292
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8dce0(%rip), %rsi     # 0xee034
leaq 0xabe3b(%rip), %rdx     # 0x10c196
movq %rbx, %rdi
movl $0x8ee, %ecx            # imm = 0x8EE
jmp 0x60508
leal (,%r12,8), %ecx
leaq 0x8dc8d(%rip), %rsi     # 0xee004
leaq 0xabe29(%rip), %rdx     # 0x10c1a7
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8dc99(%rip), %rsi     # 0xee034
leaq 0xabdf4(%rip), %rdx     # 0x10c196
movq %rbx, %rdi
movl $0x8f8, %ecx            # imm = 0x8F8
jmp 0x60508
leal (,%r12,8), %ecx
leaq 0x8dc46(%rip), %rsi     # 0xee004
leaq 0xabdf1(%rip), %rdx     # 0x10c1b6
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8dc52(%rip), %rsi     # 0xee034
leaq 0xabdad(%rip), %rdx     # 0x10c196
movq %rbx, %rdi
movl $0x8f9, %ecx            # imm = 0x8F9
jmp 0x60508
leal (,%r12,8), %ecx
leaq 0x8dbff(%rip), %rsi     # 0xee004
leaq 0xabdb7(%rip), %rdx     # 0x10c1c3
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8dc0b(%rip), %rsi     # 0xee034
leaq 0xabd66(%rip), %rdx     # 0x10c196
movq %rbx, %rdi
movl $0x8fb, %ecx            # imm = 0x8FB
jmp 0x60508
leal (,%r12,8), %ecx
leaq 0x8dbb8(%rip), %rsi     # 0xee004
leaq 0xabd85(%rip), %rdx     # 0x10c1d8
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8dbc4(%rip), %rsi     # 0xee034
leaq 0xabd1f(%rip), %rdx     # 0x10c196
movq %rbx, %rdi
movl $0x8fc, %ecx            # imm = 0x8FC
jmp 0x60508
shll $0x3, %r12d
leaq 0x8db75(%rip), %rsi     # 0xee004
leaq 0xabd57(%rip), %rdx     # 0x10c1ed
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8db7e(%rip), %rsi     # 0xee034
leaq 0xabcd9(%rip), %rdx     # 0x10c196
movq %rbx, %rdi
movl $0x8fe, %ecx            # imm = 0x8FE
jmp 0x60508
shll $0x3, %r12d
leaq 0x8db32(%rip), %rsi     # 0xee004
leaq 0xabd2a(%rip), %rdx     # 0x10c203
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8db3b(%rip), %rsi     # 0xee034
leaq 0xabc96(%rip), %rdx     # 0x10c196
movq %rbx, %rdi
movl $0x8ff, %ecx            # imm = 0x8FF
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %ebp
movl %ebp, %eax
addq $0x1058, %rsp           # imm = 0x1058
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x52e7a(%rip), %rax    # 0xd6b8
movq %rax, 0x10(%rsp)
cmpw $0x2, 0xd1a(%rbx)
jl 0x6055b
leaq 0xabcf6(%rip), %rdi     # 0x10c23e
callq 0x8510
jmp 0x6055b
leaq -0x52e9e(%rip), %rax    # 0xd6b8
movq %rax, 0x10(%rsp)
movsd 0x128(%rbx), %xmm0
movapd %xmm0, 0x20(%rsp)
leaq 0xd1c(%rbx), %rax
movq %rax, 0x18(%rsp)
movslq 0x4b0(%rbx), %r12
leaq (,%r12,8), %rdi
callq 0x8460
testq %rax, %rax
je 0x6083f
movq %rax, %r13
xorpd %xmm0, %xmm0
movapd 0x20(%rsp), %xmm2
movapd %xmm2, %xmm1
cmpeqsd %xmm0, %xmm1
andnpd %xmm2, %xmm1
movapd %xmm1, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
leaq 0x38(%rsp), %r8
callq 0x63b1b
testl %eax, %eax
jne 0x60d92
movq %r13, 0x20(%rsp)
movslq 0x440(%rbx), %rbp
leaq (,%rbp,8), %rdi
callq 0x8460
movq %rax, 0x448(%rbx)
testq %rax, %rax
je 0x60dd2
movq %rax, %r12
leaq (,%rbp,4), %rdi
callq 0x8460
testq %rax, %rax
je 0x60e11
movq %rax, %r13
movsd 0x38(%rsp), %xmm0
testl %ebp, %ebp
jle 0x6065c
xorpd %xmm1, %xmm1
subsd %xmm0, %xmm1
leal -0x1(%rbp), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
xorl %eax, %eax
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
mulsd %xmm1, %xmm3
divsd %xmm2, %xmm3
addsd %xmm0, %xmm3
movsd %xmm3, (%r12,%rax,8)
movl $0x1, (%r13,%rax,4)
incq %rax
cmpq %rax, %rbp
jne 0x60632
movl 0x4b0(%rbx), %ecx
movsd 0xa28(%r15), %xmm3
movsd 0x10(%r15), %xmm2
movsd 0x18(%r15), %xmm4
subq $0x8, %rsp
xorpd %xmm1, %xmm1
leaq 0x409c(%rip), %rdi      # 0x64722
movq 0x28(%rsp), %rsi
movq %r13, %rdx
leaq 0x48(%rsp), %r8
leaq 0x45af(%rip), %r9       # 0x64c49
pushq 0x20(%rsp)
pushq $0x0
pushq 0xe88ea(%rip)           # 0x148f90
pushq %rbp
pushq %r12
callq *0x40(%rsp)
addq $0x30, %rsp
cmpl $0x1, %eax
je 0x60e52
cmpw $0x1, 0x23a(%rbx)
movq 0x20(%rsp), %r12
jne 0x60883
movl 0x160(%rbx), %eax
cmpl $0x4, %eax
je 0x606e1
cmpl $0x2, %eax
jne 0x60883
movsd 0x128(%rbx), %xmm0
ucomisd 0x8db67(%rip), %xmm0    # 0xee258
ja 0x60883
cmpw $0x0, 0x4bc(%rbx)
je 0x60e92
movslq 0x48c(%rbx), %rax
movsd (%r12,%rax,8), %xmm1
movsd (%rbx), %xmm0
divsd %xmm0, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x1e0(%rbx)
cmpw $0x1, 0x4c0(%rbx)
jne 0x6078e
movsd 0x30(%rbx), %xmm0
subsd %xmm1, %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rbx)
cmpw $0x0, 0xd1a(%rbx)
jle 0x607c3
leaq 0xabd7f(%rip), %rdi     # 0x10c4d3
movb $0x1, %al
callq 0x8030
cmpw $0xa, 0xd1a(%rbx)
jl 0x607c3
movsd 0x1e0(%rbx), %xmm0
movapd %xmm0, %xmm2
movapd (%rsp), %xmm1
subsd %xmm1, %xmm2
divsd %xmm0, %xmm2
leaq 0xabda5(%rip), %rdi     # 0x10c52a
movb $0x3, %al
callq 0x8030
jmp 0x607c3
cmpw $0x1, 0x4c2(%rbx)
jne 0x607c3
movsd 0x38(%rbx), %xmm0
subsd %xmm1, %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
cmpw $0x0, 0xd1a(%rbx)
jle 0x607c3
leaq 0xabd95(%rip), %rdi     # 0x10c551
movb $0x1, %al
callq 0x8030
movsd 0x1e0(%rbx), %xmm2
movsd 0x240(%rbx), %xmm0
movapd %xmm2, %xmm1
subsd (%rsp), %xmm1
andpd 0x8da5c(%rip), %xmm1    # 0xee240
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
ja 0x60883
movq %r12, %rdi
movsd %xmm2, 0x20(%rsp)
callq 0x8410
movq 0x448(%rbx), %rdi
callq 0x8410
movq %r13, %rdi
callq 0x8410
movslq 0x4b0(%rbx), %r12
leaq (,%r12,8), %rdi
callq 0x8460
movq %rax, %r13
movsd 0x20(%rsp), %xmm0
movapd %xmm0, (%rsp)
testq %rax, %rax
jne 0x605b1
shll $0x3, %r12d
leaq 0x8d7ba(%rip), %rsi     # 0xee004
leaq 0xaba0c(%rip), %rdx     # 0x10c25d
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d7ca(%rip), %rsi     # 0xee034
leaq 0xab925(%rip), %rdx     # 0x10c196
movq 0x18(%rsp), %rdi
movl $0x91c, %ecx            # imm = 0x91C
movq %rbx, %r8
jmp 0x6050b
movslq 0x498(%rbx), %rax
movsd (%r12,%rax,8), %xmm0
divsd 0xaa218(%rip), %xmm0    # 0x10aab0
movsd %xmm0, 0x308(%rbx)
movslq 0x4a0(%rbx), %rax
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, 0x310(%rbx)
cmpw $0x1, 0x4b8(%rbx)
jne 0x608e0
movslq 0x480(%rbx), %rax
movsd (%r12,%rax,8), %xmm0
movsd (%rbx), %xmm1
divsd %xmm1, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x330(%rbx)
cmpw $0x1, 0x4ba(%rbx)
jne 0x6090b
movslq 0x484(%rbx), %rax
movsd (%r12,%rax,8), %xmm0
movsd (%rbx), %xmm1
divsd %xmm1, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x338(%rbx)
cmpw $0x1, 0x4bc(%rbx)
jne 0x60920
movq $0x0, 0x200(%rbx)
movl 0x440(%rbx), %esi
testl %esi, %esi
jle 0x60c9b
movslq 0x4a4(%rbx), %rax
movsd 0x8d923(%rip), %xmm0    # 0xee260
divsd (%r12,%rax,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x460(%rbx), %rax
movl 0x43c(%rbx), %ecx
xorl %r12d, %r12d
leaq 0xabc44(%rip), %rbp     # 0x10c5a4
xorpd %xmm3, %xmm3
movl %r12d, %edx
imull %ecx, %edx
movslq 0x424(%rbx), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x310(%rbx), %xmm2
movq 0x450(%rbx), %rcx
subsd (%rcx,%r12,8), %xmm2
movslq 0x410(%rbx), %rcx
addq %rdx, %rcx
movsd %xmm2, (%rax,%rcx,8)
movl 0x320(%rbx), %eax
cmpl $-0x1, %eax
je 0x609e7
testl %eax, %eax
je 0x609de
cmpl $0x1, %eax
jne 0x60a94
movsd 0x318(%rbx), %xmm0
ucomisd 0x8d885(%rip), %xmm0    # 0xee258
jb 0x60a4f
sqrtsd %xmm0, %xmm0
jmp 0x60a5e
movapd %xmm2, %xmm3
jmp 0x60a94
movsd 0x318(%rbx), %xmm0
movsd 0x90b11(%rip), %xmm1    # 0xf1508
ucomisd %xmm0, %xmm1
xorpd 0x8d82d(%rip), %xmm0    # 0xee230
jb 0x60a0b
sqrtsd %xmm0, %xmm0
jmp 0x60a1a
movsd %xmm2, (%rsp)
callq 0x82b0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x8370
movapd %xmm0, %xmm3
movsd 0x318(%rbx), %xmm0
movsd 0x90acd(%rip), %xmm1    # 0xf1508
ucomisd %xmm0, %xmm1
xorpd 0x8d7e9(%rip), %xmm0    # 0xee230
jb 0x60a81
sqrtsd %xmm0, %xmm0
jmp 0x60a90
movsd %xmm2, (%rsp)
callq 0x82b0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x80a0
movapd %xmm0, %xmm3
movsd 0x318(%rbx), %xmm0
ucomisd 0x8d7d9(%rip), %xmm0    # 0xee258
jae 0x60a49
movsd %xmm3, (%rsp)
callq 0x82b0
movsd (%rsp), %xmm3
divsd %xmm0, %xmm3
movl 0x160(%rbx), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x60b38
movq 0x460(%rbx), %rax
movslq 0x43c(%rbx), %rcx
movslq %r12d, %rdx
imulq %rcx, %rdx
movslq 0x3d4(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x200(%rbx), %xmm0
jbe 0x60b38
movq 0x458(%rbx), %rax
movsd %xmm0, 0x30(%rsp)
movsd (%rax,%r12,8), %xmm0
movsd %xmm3, (%rsp)
callq 0x81d0
movsd (%rsp), %xmm3
movsd %xmm0, 0x1f0(%rbx)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x200(%rbx)
movq 0x460(%rbx), %rax
movslq 0x43c(%rbx), %rcx
movslq %r12d, %rdx
imulq %rcx, %rdx
movslq 0x3bc(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x208(%rbx)
cmpw $0x0, 0x4c2(%rbx)
je 0x60c23
cmpl $0x1, 0x40(%rbx)
jne 0x60c23
movl 0x44(%rbx), %eax
decl %eax
cmpl $0x1, %eax
ja 0x60c23
movq 0x460(%rbx), %rax
movslq 0x43c(%rbx), %rcx
movslq %r12d, %rdx
imulq %rcx, %rdx
movslq 0x3a8(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0xc0(%rbx), %xmm0
movzwl 0xd1a(%rbx), %eax
jbe 0x60be5
movq 0x458(%rbx), %rcx
movsd (%rcx,%r12,8), %xmm1
movsd 0x8d6b8(%rip), %xmm2    # 0xee260
addsd %xmm2, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, 0xb8(%rbx)
movsd %xmm0, 0xc0(%rbx)
cmpw $0x9, %ax
jl 0x60be5
movq %rbp, %rdi
movapd %xmm0, %xmm1
movb $0x2, %al
movsd %xmm3, (%rsp)
callq 0x8030
movsd (%rsp), %xmm3
movzwl 0xd1a(%rbx), %eax
cmpw $0x3, %ax
jl 0x60c23
movsd 0x8d66d(%rip), %xmm0    # 0xee260
divsd 0xb8(%rbx), %xmm0
addsd 0x8dbe5(%rip), %xmm0    # 0xee7e8
movsd 0xc0(%rbx), %xmm1
leaq 0xab9ba(%rip), %rdi     # 0x10c5cc
movb $0x2, %al
movsd %xmm3, (%rsp)
callq 0x8030
movsd (%rsp), %xmm3
movq 0x458(%rbx), %rdi
movsd (%rdi,%r12,8), %xmm0
movsd 0x8d628(%rip), %xmm2    # 0xee260
addsd %xmm2, %xmm0
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movq 0x460(%rbx), %rax
movl 0x43c(%rbx), %ecx
movl %r12d, %edx
imull %ecx, %edx
movslq 0x414(%rbx), %rsi
movslq %edx, %rdx
addq %rdx, %rsi
movsd %xmm1, (%rax,%rsi,8)
movsd (%rdi,%r12,8), %xmm0
addsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
movslq 0x418(%rbx), %rsi
addq %rdx, %rsi
movsd %xmm0, (%rax,%rsi,8)
incq %r12
movslq 0x440(%rbx), %rsi
cmpq %rsi, %r12
jl 0x60964
jmp 0x60ca2
movq 0x458(%rbx), %rdi
movq 0x450(%rbx), %rdx
movq 0x468(%rbx), %r8
subq $0x8, %rsp
movl $0x1, %ebp
movl $0x1, %ecx
movl $0x1, %r9d
movq 0x20(%rsp), %r12
pushq %r12
callq 0x142a8
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x60d14
leaq 0x8d710(%rip), %rsi     # 0xee3f0
leaq 0xab92d(%rip), %rdx     # 0x10c614
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d334(%rip), %rsi     # 0xee034
leaq 0xab48f(%rip), %rdx     # 0x10c196
movq %r12, %rdi
movl $0x9cd, %ecx            # imm = 0x9CD
jmp 0x60f5e
movq 0x450(%rbx), %rdi
movl 0x440(%rbx), %esi
movq 0x458(%rbx), %rdx
movq 0x470(%rbx), %r8
subq $0x8, %rsp
movl $0x1, %ebp
movl $0x1, %ecx
movl $0x1, %r9d
pushq %r12
callq 0x142a8
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x60ee8
leaq 0x8d692(%rip), %rsi     # 0xee3f0
leaq 0xab924(%rip), %rdx     # 0x10c689
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d2b6(%rip), %rsi     # 0xee034
leaq 0xab411(%rip), %rdx     # 0x10c196
movq %r12, %rdi
movl $0x9d7, %ecx            # imm = 0x9D7
jmp 0x60f5e
leaq 0x8d657(%rip), %rsi     # 0xee3f0
leaq 0xab4d2(%rip), %rdx     # 0x10c272
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d276(%rip), %rsi     # 0xee034
leaq 0xab3d1(%rip), %rdx     # 0x10c196
movq %r14, %rdi
movl $0x921, %ecx            # imm = 0x921
jmp 0x6087b
shll $0x3, %ebp
leaq 0x8d228(%rip), %rsi     # 0xee004
leaq 0xab4e0(%rip), %rdx     # 0x10c2c3
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d239(%rip), %rsi     # 0xee034
leaq 0xab394(%rip), %rdx     # 0x10c196
movq 0x18(%rsp), %rdi
movl $0x923, %ecx            # imm = 0x923
jmp 0x6087b
leal (,%rbp,4), %ecx
leaq 0x8d1e5(%rip), %rsi     # 0xee004
leaq 0xaec3d(%rip), %rdx     # 0x10fa63
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x8d1f8(%rip), %rsi     # 0xee034
leaq 0xab353(%rip), %rdx     # 0x10c196
movq 0x18(%rsp), %rdi
movl $0x924, %ecx            # imm = 0x924
jmp 0x6087b
leaq 0x8d597(%rip), %rsi     # 0xee3f0
leaq 0xab473(%rip), %rdx     # 0x10c2d3
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d1b6(%rip), %rsi     # 0xee034
leaq 0xab311(%rip), %rdx     # 0x10c196
movq %r14, %rdi
movl $0x93f, %ecx            # imm = 0x93F
jmp 0x6087b
leaq 0xab57f(%rip), %rsi     # 0x10c418
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x8d1d3(%rip), %rsi     # 0xee082
leaq 0xab605(%rip), %rdx     # 0x10c4bb
leaq 0x850(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d162(%rip), %rsi     # 0xee034
leaq 0xab2bd(%rip), %rdx     # 0x10c196
movq 0x18(%rsp), %rdi
movl $0x94a, %ecx            # imm = 0x94A
jmp 0x60508
movq 0x448(%rbx), %rdi
movl 0x43c(%rbx), %ecx
movl 0x440(%rbx), %esi
movq 0x460(%rbx), %rdx
movq 0x478(%rbx), %r8
subq $0x8, %rsp
movl $0x1, %ebp
movl $0x1, %r9d
pushq %r12
callq 0x142a8
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x60f6d
leaq 0x8d4c1(%rip), %rsi     # 0xee3f0
leaq 0xab7c8(%rip), %rdx     # 0x10c6fe
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x8d0e5(%rip), %rsi     # 0xee034
leaq 0xab240(%rip), %rdx     # 0x10c196
movq %r12, %rdi
movl $0x9e1, %ecx            # imm = 0x9E1
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
jmp 0x60517
movq 0x460(%rbx), %rax
movslq 0x404(%rbx), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq 0x408(%rbx), %rcx
movslq 0x38c(%rbx), %rdx
mulsd (%rax,%rcx,8), %xmm0
movsd (%rax,%rdx,8), %xmm1
subsd %xmm1, %xmm0
mulsd 0xa9b14(%rip), %xmm1    # 0x10aab8
divsd %xmm1, %xmm0
movsd %xmm0, 0x328(%rbx)
cmpw $0x0, 0xd1a(%rbx)
movq 0x20(%rsp), %r12
jle 0x614f9
movsd 0x308(%rbx), %xmm0
leaq 0xab7c0(%rip), %rdi     # 0x10c792
movb $0x1, %al
callq 0x8030
movsd 0x310(%rbx), %xmm0
leaq 0xab7bc(%rip), %rdi     # 0x10c7a4
movb $0x1, %al
callq 0x8030
movsd (%rbx), %xmm0
divsd 0x91c55(%rip), %xmm0    # 0xf2c50
leaq 0xab7be(%rip), %rdi     # 0x10c7c0
movb $0x1, %al
callq 0x8030
movsd 0x328(%rbx), %xmm0
leaq 0xab7be(%rip), %rdi     # 0x10c7d6
movb $0x1, %al
callq 0x8030
cmpw $0x3, 0xd1a(%rbx)
jl 0x614f9
cmpw $0x1, 0x4b8(%rbx)
jne 0x610be
cmpw $0x1, 0x4ba(%rbx)
jne 0x610be
leaq 0xac430(%rip), %rdi     # 0x10d47c
callq 0x8510
movsd 0x330(%rbx), %xmm0
leaq 0xab7ca(%rip), %rdi     # 0x10c82a
movb $0x1, %al
callq 0x8030
movsd 0x338(%rbx), %xmm0
leaq 0xab7ce(%rip), %rdi     # 0x10c844
movb $0x1, %al
callq 0x8030
movsd 0x338(%rbx), %xmm0
addsd 0x330(%rbx), %xmm0
movsd 0x108(%rbx), %xmm1
leaq 0xab7c0(%rip), %rdi     # 0x10c85c
movb $0x2, %al
callq 0x8030
movsd 0x120(%rbx), %xmm0
divsd 0x20(%rbx), %xmm0
leaq 0xab7db(%rip), %rdi     # 0x10c892
movb $0x1, %al
callq 0x8030
cmpw $0x1, 0x4bc(%rbx)
jne 0x614f9
leaq 0xac3de(%rip), %rdi     # 0x10d4b1
callq 0x8510
movq 0x460(%rbx), %rax
movslq 0x440(%rbx), %rcx
decq %rcx
movslq 0x43c(%rbx), %rdx
imulq %rcx, %rdx
movslq 0x3d0(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
movslq 0x408(%rbx), %rcx
movslq %edx, %rdx
addq %rcx, %rdx
divsd (%rax,%rdx,8), %xmm0
movsd 0x128(%rbx), %xmm1
leaq 0xab793(%rip), %rdi     # 0x10c8b7
movb $0x2, %al
callq 0x8030
movl 0x160(%rbx), %eax
cmpl $0x4, %eax
jne 0x611dc
leaq 0xac38a(%rip), %rdi     # 0x10d4cb
callq 0x8510
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
leaq 0xab782(%rip), %rdi     # 0x10c8da
movb $0x1, %al
callq 0x8030
movsd (%rbx), %xmm0
divsd 0x919f5(%rip), %xmm0    # 0xf2b60
leaq 0xab775(%rip), %rdi     # 0x10c8e7
movb $0x1, %al
callq 0x8030
cmpw $0x1, 0x4b4(%rbx)
jne 0x611d6
movq 0x460(%rbx), %rax
movslq 0x440(%rbx), %rcx
decq %rcx
movslq 0x43c(%rbx), %rdx
imulq %rcx, %rdx
movslq 0x3d0(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
movslq 0x394(%rbx), %rcx
movslq %edx, %rdx
addq %rcx, %rdx
movsd (%rax,%rdx,8), %xmm1
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
leaq 0xab725(%rip), %rdi     # 0x10c8f4
movb $0x1, %al
callq 0x8030
movl 0x160(%rbx), %eax
cmpl $0x2, %eax
jne 0x61311
leaq 0xac2df(%rip), %rdi     # 0x10d4cb
callq 0x8510
movsd 0x210(%rbx), %xmm0
movsd 0x188(%rbx), %xmm1
movsd 0x190(%rbx), %xmm2
mulsd (%rbx), %xmm1
divsd 0xa98ab(%rip), %xmm1    # 0x10aac0
leaq 0xab701(%rip), %rdi     # 0x10c91d
movb $0x3, %al
callq 0x8030
movsd 0x150(%rbx), %xmm1
movsd 0x178(%rbx), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x61253
jp 0x61253
movapd %xmm1, %xmm0
divsd 0x190(%rbx), %xmm0
movsd %xmm0, 0x178(%rbx)
leaq 0xab6e5(%rip), %rdi     # 0x10c93f
movb $0x2, %al
callq 0x8030
movsd 0x1f0(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x200(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x81d0
movapd %xmm0, %xmm2
leaq 0xab6db(%rip), %rdi     # 0x10c967
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movb $0x3, %al
callq 0x8030
movsd 0x1b8(%rbx), %xmm1
ucomisd 0x918c2(%rip), %xmm1    # 0xf2b70
jbe 0x612f0
movsd 0x8d538(%rip), %xmm0    # 0xee7f0
callq 0x8620
movsd 0x8cf9b(%rip), %xmm1    # 0xee260
divsd %xmm0, %xmm1
addsd 0x8d517(%rip), %xmm1    # 0xee7e8
movapd %xmm1, %xmm0
callq 0x81d0
movsd 0x1b8(%rbx), %xmm1
leaq 0xab6bb(%rip), %rdi     # 0x10c9a4
movb $0x2, %al
callq 0x8030
movsd 0x208(%rbx), %xmm0
leaq 0xab6dc(%rip), %rdi     # 0x10c9db
movb $0x1, %al
callq 0x8030
movl 0x160(%rbx), %eax
movq 0x20(%rsp), %r12
cmpl $0x3, %eax
jne 0x6141a
movsd 0x1b8(%rbx), %xmm1
movsd 0x8d4c6(%rip), %xmm0    # 0xee7f0
callq 0x8620
movsd 0x8cf29(%rip), %xmm1    # 0xee260
divsd %xmm0, %xmm1
addsd 0x8d4a5(%rip), %xmm1    # 0xee7e8
movapd %xmm1, %xmm0
callq 0x81d0
movsd %xmm0, (%rsp)
movsd 0x1d0(%rbx), %xmm1
movsd 0x8d48f(%rip), %xmm0    # 0xee7f0
callq 0x8620
movaps %xmm0, %xmm1
leaq 0xab683(%rip), %rdi     # 0x10c9f3
movsd (%rsp), %xmm0
movb $0x2, %al
callq 0x8030
movsd 0x1f0(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x200(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x81d0
movaps %xmm0, %xmm2
leaq 0xab5c1(%rip), %rdi     # 0x10c967
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movb $0x3, %al
callq 0x8030
movsd 0x150(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x1c0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x210(%rbx), %xmm0
callq 0x8310
mulsd 0x1c0(%rbx), %xmm0
movsd 0x8d8e0(%rip), %xmm1    # 0xeecd0
callq 0x8620
movapd %xmm0, %xmm2
movsd (%rbx), %xmm3
divsd %xmm3, %xmm2
leaq 0xab61d(%rip), %rdi     # 0x10ca25
movsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x4, %al
callq 0x8030
cmpw $0x1, 0x4c0(%rbx)
jne 0x61474
movq 0x460(%rbx), %rax
movslq 0x440(%rbx), %rcx
decq %rcx
movslq 0x43c(%rbx), %rdx
imulq %rcx, %rdx
movslq 0x39c(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
movslq 0x408(%rbx), %rcx
movslq %edx, %rdx
addq %rcx, %rdx
divsd (%rax,%rdx,8), %xmm0
movsd 0x30(%rbx), %xmm1
leaq 0xab5ef(%rip), %rdi     # 0x10ca5c
movb $0x2, %al
callq 0x8030
cmpl $0x1, 0x160(%rbx)
ja 0x614f9
leaq 0xac068(%rip), %rdi     # 0x10d4ec
callq 0x8510
leaq 0xab5f2(%rip), %rdi     # 0x10ca82
xorl %eax, %eax
callq 0x8030
movslq 0x170(%rbx), %rax
cmpq $0x1, %rax
jle 0x614d7
xorl %ebp, %ebp
leaq 0xab5eb(%rip), %r12     # 0x10ca98
movq 0x168(%rbx), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x8030
incq %rbp
movslq 0x170(%rbx), %rax
decq %rax
cmpq %rax, %rbp
jl 0x614ad
jmp 0x614da
decq %rax
movq 0x168(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
leaq 0xab5b2(%rip), %rdi     # 0x10ca9f
movb $0x1, %al
callq 0x8030
movq 0x20(%rsp), %r12
movq 0x460(%rbx), %rax
movslq 0x440(%rbx), %rcx
decq %rcx
movslq 0x43c(%rbx), %rdx
imulq %rcx, %rdx
movslq 0x40c(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x340(%rbx)
movslq 0x404(%rbx), %rcx
movslq %edx, %rdx
addq %rcx, %rdx
movsd (%rax,%rdx,8), %xmm1
movsd %xmm1, 0x348(%rbx)
addsd %xmm1, %xmm0
addsd 0x2d0(%rbx), %xmm0
movsd 0x8cd06(%rip), %xmm1    # 0xee260
subsd %xmm0, %xmm1
movsd %xmm1, 0x350(%rbx)
movsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
cmpw $0x1, 0x4b4(%rbx)
jne 0x6158a
addsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
cmpw $0x1, 0x4b6(%rbx)
jne 0x615a4
addsd 0xf0(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
cmpw $0x1, 0x4b8(%rbx)
jne 0x615be
addsd 0x330(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
movslq 0x248(%rbx), %rax
testq %rax, %rax
jle 0x61603
movq 0x270(%rbx), %rcx
movsd 0x88(%r15), %xmm1
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x615fb
movq 0x280(%rbx), %rsi
addsd (%rsi,%rdx,8), %xmm0
movsd %xmm0, 0x358(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x615dc
movq %r14, %rdi
callq 0x8410
movq %r12, %rdi
callq 0x8410
movw $0x1, 0x230(%rbx)
movq %r13, %rdi
callq 0x8410
xorl %ebp, %ebp
jmp 0x60517