// File: /workspace/github_c_makefile_star2_O1/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, %rbp
movq %rsi, 0x40(%rsp)
movslq 0x43c(%rsi), %r15
movq %r15, %rdi
shlq $0x3, %rdi
callq 0x8460
testq %rax, %rax
je 0x62a7b
movq %rax, %r14
movq %rax, 0x48(%rsp)
movslq 0x8(%rbp), %r12
movl %r12d, 0x440(%rbx)
movq %r12, %r13
shlq $0x3, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x450(%rbx)
testq %rax, %rax
je 0x62ac2
movq %r13, %rdi
callq 0x8460
movq %rax, 0x458(%rbx)
testq %rax, %rax
je 0x62b09
movq %r13, %rdi
callq 0x8460
movq %rax, 0x468(%rbx)
testq %rax, %rax
je 0x62b50
movq %r13, %rdi
callq 0x8460
movq %rax, 0x470(%rbx)
testq %rax, %rax
je 0x62b97
imull %r15d, %r12d
movslq %r12d, %r13
shlq $0x3, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x460(%rbx)
testq %rax, %rax
je 0x62bde
movq %r13, %rdi
callq 0x8460
movq %rax, 0x478(%rbx)
testq %rax, %rax
je 0x62c21
movl 0xc(%rbp), %eax
cmpl $0x1, %eax
je 0x62c85
testl %eax, %eax
jne 0x62ca8
leaq -0x55b11(%rip), %rax    # 0xcf4c
movq %rax, (%rsp)
cmpw $0x1, 0xd1a(%rbx)
jle 0x62cb3
leaq 0xac78c(%rip), %rdi     # 0x10f202
jmp 0x62ca1
leal (,%r15,8), %ecx
leaq 0x8e57a(%rip), %rsi     # 0xf1004
leaq 0xb57c1(%rip), %rdx     # 0x118252
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8e586(%rip), %rsi     # 0xf1034
leaq 0xac6c1(%rip), %rdx     # 0x10f176
movq %rbx, %rdi
movl $0x8ee, %ecx            # imm = 0x8EE
jmp 0x62c62
leal (,%r12,8), %ecx
leaq 0x8e533(%rip), %rsi     # 0xf1004
leaq 0xac6af(%rip), %rdx     # 0x10f187
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8e53f(%rip), %rsi     # 0xf1034
leaq 0xac67a(%rip), %rdx     # 0x10f176
movq %rbx, %rdi
movl $0x8f8, %ecx            # imm = 0x8F8
jmp 0x62c62
leal (,%r12,8), %ecx
leaq 0x8e4ec(%rip), %rsi     # 0xf1004
leaq 0xac677(%rip), %rdx     # 0x10f196
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8e4f8(%rip), %rsi     # 0xf1034
leaq 0xac633(%rip), %rdx     # 0x10f176
movq %rbx, %rdi
movl $0x8f9, %ecx            # imm = 0x8F9
jmp 0x62c62
leal (,%r12,8), %ecx
leaq 0x8e4a5(%rip), %rsi     # 0xf1004
leaq 0xac63d(%rip), %rdx     # 0x10f1a3
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8e4b1(%rip), %rsi     # 0xf1034
leaq 0xac5ec(%rip), %rdx     # 0x10f176
movq %rbx, %rdi
movl $0x8fb, %ecx            # imm = 0x8FB
jmp 0x62c62
leal (,%r12,8), %ecx
leaq 0x8e45e(%rip), %rsi     # 0xf1004
leaq 0xac60b(%rip), %rdx     # 0x10f1b8
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8e46a(%rip), %rsi     # 0xf1034
leaq 0xac5a5(%rip), %rdx     # 0x10f176
movq %rbx, %rdi
movl $0x8fc, %ecx            # imm = 0x8FC
jmp 0x62c62
shll $0x3, %r12d
leaq 0x8e41b(%rip), %rsi     # 0xf1004
leaq 0xac5dd(%rip), %rdx     # 0x10f1cd
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8e424(%rip), %rsi     # 0xf1034
leaq 0xac55f(%rip), %rdx     # 0x10f176
movq %rbx, %rdi
movl $0x8fe, %ecx            # imm = 0x8FE
jmp 0x62c62
shll $0x3, %r12d
leaq 0x8e3d8(%rip), %rsi     # 0xf1004
leaq 0xac5b0(%rip), %rdx     # 0x10f1e3
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x8e3e1(%rip), %rsi     # 0xf1034
leaq 0xac51c(%rip), %rdx     # 0x10f176
movq %rbx, %rdi
movl $0x8ff, %ecx            # imm = 0x8FF
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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 -0x556b8(%rip), %rax    # 0xd5d4
movq %rax, (%rsp)
cmpw $0x2, 0xd1a(%rbx)
jl 0x62cb3
leaq 0xac57d(%rip), %rdi     # 0x10f21e
callq 0x8510
jmp 0x62cb3
leaq -0x556db(%rip), %rax    # 0xd5d4
movq %rax, (%rsp)
movsd 0x128(%rbx), %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpeqsd %xmm1, %xmm2
andnpd %xmm0, %xmm2
movapd %xmm2, 0x20(%rsp)
leaq 0xd1c(%rbx), %rax
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
movq %rbp, 0x18(%rsp)
movslq 0x4b0(%rbx), %r12
leaq (,%r12,8), %rdi
callq 0x8460
testq %rax, %rax
je 0x63436
movq %rax, %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
leaq 0x30(%rsp), %r8
callq 0x66393
testl %eax, %eax
jne 0x63477
movslq 0x440(%rbx), %rbp
leaq (,%rbp,8), %rdi
callq 0x8460
movq %rax, 0x448(%rbx)
testq %rax, %rax
je 0x634b7
movq %rax, %r12
movq %r13, 0x10(%rsp)
leaq (,%rbp,4), %rdi
callq 0x8460
testq %rax, %rax
je 0x634f3
movq %rax, %r13
testl %ebp, %ebp
jle 0x62db1
movsd 0x30(%rsp), %xmm0
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 0x62d87
movsd 0x30(%rsp), %xmm0
movl 0x4b0(%rbx), %ecx
movq 0x18(%rsp), %rax
movsd 0xa28(%rax), %xmm3
movsd 0x10(%rax), %xmm2
movsd 0x18(%rax), %xmm4
subq $0x8, %rsp
xorpd %xmm1, %xmm1
leaq 0x41dd(%rip), %rdi      # 0x66fc0
movq 0x18(%rsp), %rsi
movq %r13, %rdx
leaq 0x48(%rsp), %r8
leaq 0x46f9(%rip), %r9       # 0x674f0
pushq 0x10(%rsp)
pushq $0x0
pushq 0xe918d(%rip)           # 0x14bf90
pushq %rbp
pushq %r12
callq *0x30(%rsp)
addq $0x30, %rsp
cmpl $0x1, %eax
je 0x63531
movw $0x1, %bp
cmpw $0x1, 0x23a(%rbx)
jne 0x62f85
movl 0x160(%rbx), %eax
cmpl $0x4, %eax
je 0x62e3d
cmpl $0x2, %eax
jne 0x62f85
movsd 0x128(%rbx), %xmm0
ucomisd 0x8e40b(%rip), %xmm0    # 0xf1258
ja 0x62f85
cmpw $0x0, 0x4bc(%rbx)
je 0x63674
movslq 0x48c(%rbx), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm1
movsd (%rbx), %xmm0
divsd %xmm0, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x1e0(%rbx)
cmpw $0x1, 0x4c0(%rbx)
jne 0x62ef0
movsd 0x30(%rbx), %xmm0
subsd %xmm1, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rbx)
cmpw $0x0, 0xd1a(%rbx)
jle 0x62ebc
leaq 0xac5fe(%rip), %rdi     # 0x10f4b3
movb $0x1, %al
callq 0x8030
cmpw $0xa, 0xd1a(%rbx)
jl 0x62f26
movsd 0x1e0(%rbx), %xmm0
movapd %xmm0, %xmm2
movapd 0x20(%rsp), %xmm1
subsd %xmm1, %xmm2
divsd %xmm0, %xmm2
leaq 0xac623(%rip), %rdi     # 0x10f50a
movb $0x3, %al
callq 0x8030
jmp 0x62f26
cmpw $0x1, 0x4c2(%rbx)
jne 0x62f26
movsd 0x38(%rbx), %xmm0
subsd %xmm1, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
cmpw $0x0, 0xd1a(%rbx)
jle 0x62f26
leaq 0xac612(%rip), %rdi     # 0x10f531
movb $0x1, %al
callq 0x8030
movsd 0x1e0(%rbx), %xmm2
movsd 0x240(%rbx), %xmm0
movapd %xmm2, %xmm1
subsd 0x20(%rsp), %xmm1
andpd 0x8e2f8(%rip), %xmm1    # 0xf1240
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
ja 0x62f85
movq 0x10(%rsp), %rdi
movsd %xmm2, 0x20(%rsp)
callq 0x8410
movq 0x448(%rbx), %rdi
callq 0x8410
movq %r13, %rdi
callq 0x8410
movsd 0x20(%rsp), %xmm0
movapd %xmm0, 0x20(%rsp)
movl %r15d, %ebp
movl %ebp, %r15d
testw %bp, %bp
movq 0x18(%rsp), %rbp
je 0x62ce6
movslq 0x498(%rbx), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm0
divsd 0xaaad9(%rip), %xmm0    # 0x10da88
movsd %xmm0, 0x308(%rbx)
movslq 0x4a0(%rbx), %rax
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, 0x310(%rbx)
cmpw $0x1, 0x4b8(%rbx)
jne 0x62ffa
movslq 0x480(%rbx), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd (%rbx), %xmm1
divsd %xmm1, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x330(%rbx)
cmpw $0x1, 0x4ba(%rbx)
movq 0x8(%rsp), %r15
jne 0x6302e
movslq 0x484(%rbx), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd (%rbx), %xmm1
divsd %xmm1, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x338(%rbx)
cmpw $0x1, 0x4bc(%rbx)
jne 0x63043
movq $0x0, 0x200(%rbx)
movl 0x440(%rbx), %esi
testl %esi, %esi
jle 0x633be
movslq 0x4a4(%rbx), %rax
movsd 0x8e200(%rip), %xmm0    # 0xf1260
movq 0x10(%rsp), %rcx
divsd (%rcx,%rax,8), %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r12d, %r12d
leaq 0xac50a(%rip), %rbp     # 0x10f584
xorpd %xmm3, %xmm3
movq 0x460(%rbx), %rax
movslq 0x43c(%rbx), %rcx
movslq %r12d, %rdx
imulq %rcx, %rdx
movslq 0x424(%rbx), %rcx
addq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x310(%rbx), %xmm2
movq 0x450(%rbx), %rcx
subsd (%rcx,%r12,8), %xmm2
movslq 0x410(%rbx), %rcx
movslq %edx, %rdx
addq %rcx, %rdx
movsd %xmm2, (%rax,%rdx,8)
movl 0x320(%rbx), %eax
cmpl $-0x1, %eax
je 0x63110
testl %eax, %eax
je 0x63107
cmpl $0x1, %eax
jne 0x631bd
movsd 0x318(%rbx), %xmm0
ucomisd 0x8e15c(%rip), %xmm0    # 0xf1258
jb 0x63178
sqrtsd %xmm0, %xmm0
jmp 0x63187
movapd %xmm2, %xmm3
jmp 0x631bd
movsd 0x318(%rbx), %xmm0
movsd 0x913d8(%rip), %xmm1    # 0xf44f8
ucomisd %xmm0, %xmm1
xorpd 0x8e104(%rip), %xmm0    # 0xf1230
jb 0x63134
sqrtsd %xmm0, %xmm0
jmp 0x63143
movsd %xmm2, (%rsp)
callq 0x82b0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x8370
movapd %xmm0, %xmm3
movsd 0x318(%rbx), %xmm0
movsd 0x91394(%rip), %xmm1    # 0xf44f8
ucomisd %xmm0, %xmm1
xorpd 0x8e0c0(%rip), %xmm0    # 0xf1230
jb 0x631aa
sqrtsd %xmm0, %xmm0
jmp 0x631b9
movsd %xmm2, (%rsp)
callq 0x82b0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x80a0
movapd %xmm0, %xmm3
movsd 0x318(%rbx), %xmm0
ucomisd 0x8e0b0(%rip), %xmm0    # 0xf1258
jae 0x63172
movsd %xmm3, (%rsp)
callq 0x82b0
movsd (%rsp), %xmm3
divsd %xmm0, %xmm3
movl 0x160(%rbx), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x63261
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 0x63261
movq 0x458(%rbx), %rax
movsd %xmm0, 0x38(%rsp)
movsd (%rax,%r12,8), %xmm0
movsd %xmm3, (%rsp)
callq 0x81d0
movsd (%rsp), %xmm3
movsd %xmm0, 0x1f0(%rbx)
movsd 0x38(%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 0x63346
cmpl $0x1, 0x40(%rbx)
jne 0x63346
movl 0x44(%rbx), %eax
decl %eax
cmpl $0x1, %eax
ja 0x63346
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
jbe 0x63304
movq 0x458(%rbx), %rax
movsd (%rax,%r12,8), %xmm1
movsd 0x8df96(%rip), %xmm2    # 0xf1260
addsd %xmm2, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, 0xb8(%rbx)
movsd %xmm0, 0xc0(%rbx)
cmpw $0x9, 0xd1a(%rbx)
jl 0x63304
movq %rbp, %rdi
movapd %xmm0, %xmm1
movb $0x2, %al
movsd %xmm3, (%rsp)
callq 0x8030
movsd (%rsp), %xmm3
cmpw $0x3, 0xd1a(%rbx)
jl 0x63346
movsd 0x8df4a(%rip), %xmm0    # 0xf1260
divsd 0xb8(%rbx), %xmm0
addsd 0x8e4c2(%rip), %xmm0    # 0xf17e8
movsd 0xc0(%rbx), %xmm1
leaq 0xac277(%rip), %rdi     # 0x10f5ac
movb $0x2, %al
movsd %xmm3, (%rsp)
callq 0x8030
movsd (%rsp), %xmm3
movq 0x458(%rbx), %rax
movq 0x460(%rbx), %rcx
movsd (%rax,%r12,8), %xmm0
movsd 0x8defe(%rip), %xmm2    # 0xf1260
addsd %xmm2, %xmm0
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movslq 0x43c(%rbx), %rdx
movslq %r12d, %rsi
imulq %rdx, %rsi
movslq 0x414(%rbx), %rdx
addq %rsi, %rdx
movsd %xmm1, (%rcx,%rdx,8)
movsd (%rax,%r12,8), %xmm0
addsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
movslq 0x418(%rbx), %rax
movslq %esi, %rdx
addq %rax, %rdx
movsd %xmm0, (%rcx,%rdx,8)
incq %r12
movslq 0x440(%rbx), %rsi
cmpq %rsi, %r12
jl 0x6307e
movq 0x450(%rbx), %rdx
movq 0x458(%rbx), %rdi
movq 0x468(%rbx), %r8
subq $0x8, %rsp
movl $0x1, %ebp
movl $0x1, %ecx
movl $0x1, %r9d
pushq %r15
callq 0x14191
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x63574
leaq 0x8dfee(%rip), %rsi     # 0xf13f0
leaq 0xac1eb(%rip), %rdx     # 0x10f5f4
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8dc12(%rip), %rsi     # 0xf1034
leaq 0xabd4d(%rip), %rdx     # 0x10f176
movq %r15, %rdi
movl $0x9cd, %ecx            # imm = 0x9CD
jmp 0x63665
shll $0x3, %r12d
leaq 0x8dbc3(%rip), %rsi     # 0xf1004
leaq 0xabdf5(%rip), %rdx     # 0x10f23d
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8dbd3(%rip), %rsi     # 0xf1034
leaq 0xabd0e(%rip), %rdx     # 0x10f176
movq 0x8(%rsp), %rdi
movl $0x91c, %ecx            # imm = 0x91C
jmp 0x6356c
leaq 0x8df72(%rip), %rsi     # 0xf13f0
leaq 0xabdcd(%rip), %rdx     # 0x10f252
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8db91(%rip), %rsi     # 0xf1034
leaq 0xabccc(%rip), %rdx     # 0x10f176
movq %r14, %rdi
movl $0x921, %ecx            # imm = 0x921
jmp 0x6356c
shll $0x3, %ebp
leaq 0x8db43(%rip), %rsi     # 0xf1004
leaq 0xabddb(%rip), %rdx     # 0x10f2a3
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8db54(%rip), %rsi     # 0xf1034
leaq 0xabc8f(%rip), %rdx     # 0x10f176
movq 0x8(%rsp), %rdi
movl $0x923, %ecx            # imm = 0x923
jmp 0x6356c
leal (,%rbp,4), %ecx
leaq 0x8db03(%rip), %rsi     # 0xf1004
leaq 0xaf50b(%rip), %rdx     # 0x112a13
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x8db16(%rip), %rsi     # 0xf1034
leaq 0xabc51(%rip), %rdx     # 0x10f176
movq 0x8(%rsp), %rdi
movl $0x924, %ecx            # imm = 0x924
jmp 0x6356c
leaq 0x8deb8(%rip), %rsi     # 0xf13f0
leaq 0xabd74(%rip), %rdx     # 0x10f2b3
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8dad7(%rip), %rsi     # 0xf1034
leaq 0xabc12(%rip), %rdx     # 0x10f176
movq %r14, %rdi
movl $0x93f, %ecx            # imm = 0x93F
movq %rbx, %r8
jmp 0x62c65
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 %r15
callq 0x14191
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x635eb
leaq 0x8de36(%rip), %rsi     # 0xf13f0
leaq 0xac0a8(%rip), %rdx     # 0x10f669
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8da5a(%rip), %rsi     # 0xf1034
leaq 0xabb95(%rip), %rdx     # 0x10f176
movq %r15, %rdi
movl $0x9d7, %ecx            # imm = 0x9D7
jmp 0x63665
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 %r15
callq 0x14191
addq $0x10, %rsp
cmpl $0x1, %eax
jne 0x636ca
leaq 0x8ddba(%rip), %rsi     # 0xf13f0
leaq 0xac0a1(%rip), %rdx     # 0x10f6de
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8d9de(%rip), %rsi     # 0xf1034
leaq 0xabb19(%rip), %rdx     # 0x10f176
movq %r15, %rdi
movl $0x9e1, %ecx            # imm = 0x9E1
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
jmp 0x62c71
leaq 0xabd7d(%rip), %rsi     # 0x10f3f8
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x8d9f1(%rip), %rsi     # 0xf1082
leaq 0xabe03(%rip), %rdx     # 0x10f49b
leaq 0x850(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x8d980(%rip), %rsi     # 0xf1034
leaq 0xababb(%rip), %rdx     # 0x10f176
movq 0x8(%rsp), %rdi
movl $0x94a, %ecx            # imm = 0x94A
jmp 0x62c62
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 0xaa38f(%rip), %xmm1    # 0x10da90
divsd %xmm1, %xmm0
movsd %xmm0, 0x328(%rbx)
cmpw $0x0, 0xd1a(%rbx)
jle 0x63773
movsd 0x308(%rbx), %xmm0
leaq 0xac04c(%rip), %rdi     # 0x10f772
movb $0x1, %al
callq 0x8030
movsd 0x310(%rbx), %xmm0
leaq 0xac048(%rip), %rdi     # 0x10f784
movb $0x1, %al
callq 0x8030
movsd (%rbx), %xmm0
divsd 0x924d1(%rip), %xmm0    # 0xf5c20
leaq 0xac04a(%rip), %rdi     # 0x10f7a0
movb $0x1, %al
callq 0x8030
movsd 0x328(%rbx), %xmm0
leaq 0xac04a(%rip), %rdi     # 0x10f7b6
movb $0x1, %al
callq 0x8030
cmpw $0x3, 0xd1a(%rbx)
movq 0x18(%rsp), %r15
jl 0x63c5b
cmpw $0x1, 0x4b8(%rbx)
jne 0x63817
cmpw $0x1, 0x4ba(%rbx)
jne 0x63817
leaq 0xaccb7(%rip), %rdi     # 0x11045c
callq 0x8510
movsd 0x330(%rbx), %xmm0
leaq 0xac051(%rip), %rdi     # 0x10f80a
movb $0x1, %al
callq 0x8030
movsd 0x338(%rbx), %xmm0
leaq 0xac055(%rip), %rdi     # 0x10f824
movb $0x1, %al
callq 0x8030
movsd 0x338(%rbx), %xmm0
addsd 0x330(%rbx), %xmm0
movsd 0x108(%rbx), %xmm1
leaq 0xac047(%rip), %rdi     # 0x10f83c
movb $0x2, %al
callq 0x8030
movsd 0x120(%rbx), %xmm0
divsd 0x20(%rbx), %xmm0
leaq 0xac062(%rip), %rdi     # 0x10f872
movb $0x1, %al
callq 0x8030
cmpw $0x1, 0x4bc(%rbx)
jne 0x63c5b
leaq 0xacc65(%rip), %rdi     # 0x110491
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 0xac01a(%rip), %rdi     # 0x10f897
movb $0x2, %al
callq 0x8030
cmpl $0x4, 0x160(%rbx)
jne 0x6392d
leaq 0xacc13(%rip), %rdi     # 0x1104ab
callq 0x8510
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
leaq 0xac00b(%rip), %rdi     # 0x10f8ba
movb $0x1, %al
callq 0x8030
movsd (%rbx), %xmm0
divsd 0x9226e(%rip), %xmm0    # 0xf5b30
leaq 0xabffe(%rip), %rdi     # 0x10f8c7
movb $0x1, %al
callq 0x8030
cmpw $0x1, 0x4b4(%rbx)
jne 0x6392d
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 0xabfae(%rip), %rdi     # 0x10f8d4
movb $0x1, %al
callq 0x8030
cmpl $0x2, 0x160(%rbx)
jne 0x63a6c
leaq 0xacb6a(%rip), %rdi     # 0x1104ab
callq 0x8510
movsd 0x210(%rbx), %xmm0
movsd 0x188(%rbx), %xmm1
movsd 0x190(%rbx), %xmm2
mulsd (%rbx), %xmm1
divsd 0xaa12e(%rip), %xmm1    # 0x10da98
leaq 0xabf8c(%rip), %rdi     # 0x10f8fd
movb $0x3, %al
callq 0x8030
movsd 0x178(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x639a4
jp 0x639a4
movsd 0x150(%rbx), %xmm0
divsd 0x190(%rbx), %xmm0
movsd %xmm0, 0x178(%rbx)
movsd 0x150(%rbx), %xmm1
movsd 0x178(%rbx), %xmm0
leaq 0xabf64(%rip), %rdi     # 0x10f91f
movb $0x2, %al
callq 0x8030
movsd 0x1f0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x200(%rbx), %xmm0
movsd %xmm0, (%rsp)
callq 0x81d0
movapd %xmm0, %xmm2
leaq 0xabf5a(%rip), %rdi     # 0x10f947
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x3, %al
callq 0x8030
movsd 0x1b8(%rbx), %xmm1
ucomisd 0x92131(%rip), %xmm1    # 0xf5b40
jbe 0x63a51
movsd 0x8ddd7(%rip), %xmm0    # 0xf17f0
callq 0x8620
movsd 0x8d83a(%rip), %xmm1    # 0xf1260
divsd %xmm0, %xmm1
addsd 0x8ddb6(%rip), %xmm1    # 0xf17e8
movapd %xmm1, %xmm0
callq 0x81d0
movsd 0x1b8(%rbx), %xmm1
leaq 0xabf3a(%rip), %rdi     # 0x10f984
movb $0x2, %al
callq 0x8030
movsd 0x208(%rbx), %xmm0
leaq 0xabf5b(%rip), %rdi     # 0x10f9bb
movb $0x1, %al
callq 0x8030
movq 0x18(%rsp), %r15
cmpl $0x3, 0x160(%rbx)
jne 0x63b7b
movsd 0x1b8(%rbx), %xmm1
movsd 0x8dd67(%rip), %xmm0    # 0xf17f0
callq 0x8620
movsd 0x8d7ca(%rip), %xmm1    # 0xf1260
divsd %xmm0, %xmm1
addsd 0x8dd46(%rip), %xmm1    # 0xf17e8
movapd %xmm1, %xmm0
callq 0x81d0
movsd %xmm0, 0x8(%rsp)
movsd 0x1d0(%rbx), %xmm1
movsd 0x8dd2f(%rip), %xmm0    # 0xf17f0
callq 0x8620
movaps %xmm0, %xmm1
leaq 0xabf03(%rip), %rdi     # 0x10f9d3
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x8030
movsd 0x1f0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x200(%rbx), %xmm0
movsd %xmm0, (%rsp)
callq 0x81d0
movaps %xmm0, %xmm2
leaq 0xabe40(%rip), %rdi     # 0x10f947
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x3, %al
callq 0x8030
movsd 0x150(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1c0(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x210(%rbx), %xmm0
callq 0x8310
mulsd 0x1c0(%rbx), %xmm0
movsd 0x8e17f(%rip), %xmm1    # 0xf1cd0
callq 0x8620
movapd %xmm0, %xmm2
movsd (%rbx), %xmm3
divsd %xmm3, %xmm2
leaq 0xabe9c(%rip), %rdi     # 0x10fa05
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movb $0x4, %al
callq 0x8030
cmpw $0x1, 0x4c0(%rbx)
jne 0x63bd5
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 0xabe6e(%rip), %rdi     # 0x10fa3c
movb $0x2, %al
callq 0x8030
cmpl $0x1, 0x160(%rbx)
ja 0x63c5b
leaq 0xac8e7(%rip), %rdi     # 0x1104cc
callq 0x8510
leaq 0xabe71(%rip), %rdi     # 0x10fa62
xorl %eax, %eax
callq 0x8030
movl 0x170(%rbx), %eax
cmpl $0x2, %eax
jl 0x63c38
xorl %r15d, %r15d
leaq 0xabe6b(%rip), %r12     # 0x10fa78
movq 0x168(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x8030
incq %r15
movslq 0x170(%rbx), %rax
decq %rax
cmpq %rax, %r15
jl 0x63c0d
jmp 0x63c3a
decl %eax
movq 0x168(%rbx), %rcx
cltq
movsd (%rcx,%rax,8), %xmm0
leaq 0xabe30(%rip), %rdi     # 0x10fa7f
movb $0x1, %al
callq 0x8030
movq 0x18(%rsp), %r15
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 0x8d5a4(%rip), %xmm1    # 0xf1260
subsd %xmm0, %xmm1
movsd %xmm1, 0x350(%rbx)
movsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
cmpw $0x1, 0x4b4(%rbx)
jne 0x63cec
addsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
cmpw $0x1, 0x4b6(%rbx)
jne 0x63d0e
movsd 0xf0(%rbx), %xmm0
addsd 0x358(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
cmpw $0x1, 0x4b8(%rbx)
jne 0x63d30
movsd 0x330(%rbx), %xmm0
addsd 0x358(%rbx), %xmm0
movsd %xmm0, 0x358(%rbx)
movslq 0x248(%rbx), %rax
testq %rax, %rax
jle 0x63d7d
movq 0x270(%rbx), %rcx
movsd 0x88(%r15), %xmm0
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x63d75
movq 0x280(%rbx), %rsi
movsd (%rsi,%rdx,8), %xmm1
addsd 0x358(%rbx), %xmm1
movsd %xmm1, 0x358(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x63d4e
movq %r14, %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
callq 0x8410
movw $0x1, 0x230(%rbx)
movq %r13, %rdi
callq 0x8410
xorl %ebp, %ebp
jmp 0x62c71