// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/perturbations.c
// Function: perturbations_solve
int perturbations_solve(
                        struct precision * ppr,
                        struct background * pba,
                        struct thermodynamics * pth,
                        struct perturbations * ppt,
                        int index_md,
                        int index_ic,
                        int index_k,
                        struct perturbations_workspace * ppw
                        ) {

  /** Summary: */

  /** - define local variables */

  /* contains all fixed parameters, indices and workspaces used by the perturbations_derivs function */
  struct perturbations_parameters_and_workspace ppaw;

  /* conformal time */
  double tau,tau_lower,tau_upper,tau_mid;

  /* multipole */
  int l;

  /* index running over time */
  int index_tau;

  /* number of values in the tau_sampling array that should be considered for a given mode */
  int tau_actual_size;

  /* running index over types (temperature, etc) */
  int index_tp;

  /* Fourier mode */
  double k;

  /* number of time intervals where the approximation scheme is uniform */
  int interval_number;

  /* index running over such time intervals */
  int index_interval;

  /* number of time intervals where each particular approximation is uniform */
  int * interval_number_of;

  /* edge of intervals where approximation scheme is uniform: tau_ini, tau_switch_1, ..., tau_end */
  double * interval_limit;

  /* array of approximation scheme within each interval: interval_approx[index_interval][index_ap] */
  int ** interval_approx;

  /* index running over approximations */
  int index_ap;

  /* approximation scheme within previous interval: previous_approx[index_ap] */
  int * previous_approx;

  int n_ncdm,is_early_enough;

  /* function pointer to ODE evolver and names of possible evolvers */


  auto generic_evolver = &(evolver_ndf15);


  /* Related to the perturbation output */
  int (*perhaps_print_variables)(double, double*, double*, void*, char*);
  int index_ikout;

  /** - initialize indices relevant for back/thermo tables search */
  ppw->last_index_back=0;
  ppw->last_index_thermo=0;
  ppw->inter_mode = inter_normal;

  /** - get wavenumber value */
  k = ppt->k[index_md][index_k];

  class_test(k == 0.,
             ppt->error_message,
             "stop to avoid division by zero");

  /** - If non-zero curvature, update array of free-streaming coefficients ppw->s_l */
  if (pba->has_curvature == _TRUE_){
    for (l = 0; l<=ppw->max_l_max; l++){
      ppw->s_l[l] = sqrt(MAX(1.0-pba->K*(l*l-1.0)/k/k,0.));
    }
  }

  /** - maximum value of tau for which sources are calculated for this wavenumber */

  /* by default, today */
  tau_actual_size = ppt->tau_size;

  /** - using bisection, compute minimum value of tau for which this
      wavenumber is integrated */

  /* will be at least the first time in the background table */
  tau_lower = pba->tau_table[0];

  class_call(background_at_tau(pba,
                               tau_lower,
                               normal_info,
                               inter_normal,
                               &(ppw->last_index_back),
                               ppw->pvecback),
             pba->error_message,
             ppt->error_message);

  class_call(thermodynamics_at_z(pba,
                                 pth,
                                 1./ppw->pvecback[pba->index_bg_a]-1.,
                                 inter_normal,
                                 &(ppw->last_index_thermo),
                                 ppw->pvecback,
                                 ppw->pvecthermo),
             pth->error_message,
             ppt->error_message);

  /* check that this initial time is indeed OK given imposed
     conditions on kappa' and on k/aH */

  class_test(ppw->pvecback[pba->index_bg_a]*
             ppw->pvecback[pba->index_bg_H]/
             ppw->pvecthermo[pth->index_th_dkappa] >
             ppr->start_small_k_at_tau_c_over_tau_h, ppt->error_message, "your choice of initial time for integrating wavenumbers is inappropriate: it corresponds to a time before that at which the background has been integrated. You should increase 'start_small_k_at_tau_c_over_tau_h' up to at least %g, or decrease 'a_ini_over_a_today_default'\n",
             ppw->pvecback[pba->index_bg_a]*
             ppw->pvecback[pba->index_bg_H]/
             ppw->pvecthermo[pth->index_th_dkappa]);

  class_test(k/ppw->pvecback[pba->index_bg_a]/ppw->pvecback[pba->index_bg_H] >
             ppr->start_large_k_at_tau_h_over_tau_k,
             ppt->error_message,
             "your choice of initial time for integrating wavenumbers is inappropriate: it corresponds to a time before that at which the background has been integrated. You should increase 'start_large_k_at_tau_h_over_tau_k' up to at least %g, or decrease 'a_ini_over_a_today_default'\n",
             ppt->k[index_md][ppt->k_size[index_md]-1]/ppw->pvecback[pba->index_bg_a]/ ppw->pvecback[pba->index_bg_H]);

  if (pba->has_ncdm == _TRUE_) {
    for (n_ncdm=0; n_ncdm < pba->N_ncdm; n_ncdm++) {
      class_test(fabs(ppw->pvecback[pba->index_bg_p_ncdm1+n_ncdm]/ppw->pvecback[pba->index_bg_rho_ncdm1+n_ncdm]-1./3.)>ppr->tol_ncdm_initial_w,
                 ppt->error_message,
                 "your choice of initial time for integrating wavenumbers is inappropriate: it corresponds to a time at which the ncdm species number %d is not ultra-relativistic anymore, with w=%g, p=%g and rho=%g\n",
                 n_ncdm,
                 ppw->pvecback[pba->index_bg_p_ncdm1+n_ncdm]/ppw->pvecback[pba->index_bg_rho_ncdm1+n_ncdm],
                 ppw->pvecback[pba->index_bg_p_ncdm1+n_ncdm],
                 ppw->pvecback[pba->index_bg_rho_ncdm1+n_ncdm]);
    }
  }

  /* is at most the time at which sources must be sampled */
  tau_upper = ppt->tau_sampling[0];

  /* start bisection */
  tau_mid = 0.5*(tau_lower + tau_upper);

  while ((tau_upper - tau_lower)/tau_lower > ppr->tol_tau_approx) {

    is_early_enough = _TRUE_;

    class_call(background_at_tau(pba,
                                 tau_mid,
                                 normal_info,
                                 inter_normal,
                                 &(ppw->last_index_back),
                                 ppw->pvecback),
               pba->error_message,
               ppt->error_message);

    /* if there are non-cold relics, check that they are relativistic enough */
    if (pba->has_ncdm == _TRUE_) {
      for (n_ncdm=0; n_ncdm < pba->N_ncdm; n_ncdm++) {
        if (fabs(ppw->pvecback[pba->index_bg_p_ncdm1+n_ncdm]/ppw->pvecback[pba->index_bg_rho_ncdm1+n_ncdm]-1./3.) > ppr->tol_ncdm_initial_w)
          is_early_enough = _FALSE_;
      }
    }

    /* also check that the two conditions on (aH/kappa') and (aH/k) are fulfilled */
    if (is_early_enough == _TRUE_) {

      class_call(thermodynamics_at_z(pba,
                                     pth,
                                     1./ppw->pvecback[pba->index_bg_a]-1.,  /* redshift z=1/a-1 */
                                     inter_normal,
                                     &(ppw->last_index_thermo),
                                     ppw->pvecback,
                                     ppw->pvecthermo),
                 pth->error_message,
                 ppt->error_message);

      if ((ppw->pvecback[pba->index_bg_a]*
           ppw->pvecback[pba->index_bg_H]/
           ppw->pvecthermo[pth->index_th_dkappa] >
           ppr->start_small_k_at_tau_c_over_tau_h) ||
          (k/ppw->pvecback[pba->index_bg_a]/ppw->pvecback[pba->index_bg_H] >
           ppr->start_large_k_at_tau_h_over_tau_k))

        is_early_enough = _FALSE_;
    }

    if (is_early_enough == _TRUE_)
      tau_lower = tau_mid;
    else
      tau_upper = tau_mid;

    tau_mid = 0.5*(tau_lower + tau_upper);

  }

  tau = tau_mid;

  /** - find the number of intervals over which approximation scheme is constant */

  class_alloc(interval_number_of,ppw->ap_size*sizeof(int),ppt->error_message);

  ppw->inter_mode = inter_normal;

  class_call(perturbations_find_approximation_number(ppr,
                                                     pba,
                                                     pth,
                                                     ppt,
                                                     index_md,
                                                     k,
                                                     ppw,
                                                     tau,
                                                     ppt->tau_sampling[tau_actual_size-1],
                                                     &interval_number,
                                                     interval_number_of),
             ppt->error_message,
             ppt->error_message);

  class_alloc(interval_limit,(interval_number+1)*sizeof(double),ppt->error_message);

  class_alloc(interval_approx,interval_number*sizeof(int*),ppt->error_message);

  for (index_interval=0; index_interval<interval_number; index_interval++)
    class_alloc(interval_approx[index_interval],ppw->ap_size*sizeof(int),ppt->error_message);

  class_call(perturbations_find_approximation_switches(ppr,
                                                       pba,
                                                       pth,
                                                       ppt,
                                                       index_md,
                                                       k,
                                                       ppw,
                                                       tau,
                                                       ppt->tau_sampling[tau_actual_size-1],
                                                       ppr->tol_tau_approx,
                                                       interval_number,
                                                       interval_number_of,
                                                       interval_limit,
                                                       interval_approx),
             ppt->error_message,
             ppt->error_message);

  free(interval_number_of);

  /** - fill the structure containing all fixed parameters, indices
      and workspaces needed by perturbations_derivs */

  ppaw.ppr = ppr;
  ppaw.pba = pba;
  ppaw.pth = pth;
  ppaw.ppt = ppt;
  ppaw.index_md = index_md;
  ppaw.index_ic = index_ic;
  ppaw.index_k = index_k;
  ppaw.k = k;
  ppaw.ppw = ppw;
  ppaw.ppw->inter_mode = inter_closeby;
  ppaw.ppw->last_index_back = 0;
  ppaw.ppw->last_index_thermo = 0;

  /** - check whether we need to print perturbations to a file for this wavenumber */

  perhaps_print_variables = NULL;
  ppw->index_ikout = -1;
  for (index_ikout=0; index_ikout<ppt->k_output_values_num; index_ikout++){
    if (ppt->index_k_output_values[index_md*ppt->k_output_values_num+index_ikout] == index_k){
      ppw->index_ikout = index_ikout;
      perhaps_print_variables = perturbations_print_variables;
    }
  }

  /** - loop over intervals over which approximation scheme is uniform. For each interval: */

  for (index_interval=0; index_interval<interval_number; index_interval++) {

    /** - --> (a) fix the approximation scheme */

    for (index_ap=0; index_ap<ppw->ap_size; index_ap++)
      ppw->approx[index_ap]=interval_approx[index_interval][index_ap];

    /** - --> (b) get the previous approximation scheme. If the current
        interval starts from the initial time tau_ini, the previous
        approximation is set to be a NULL pointer, so that the
        function perturbations_vector_init() knows that perturbations must
        be initialized */

    if (index_interval==0) {
      previous_approx=NULL;
    }
    else {
      previous_approx=interval_approx[index_interval-1];
    }

    /** - --> (c) define the vector of perturbations to be integrated
        over. If the current interval starts from the initial time
        tau_ini, fill the vector with initial conditions for each
        mode. If it starts from an approximation switching point,
        redistribute correctly the perturbations from the previous to
        the new vector of perturbations. */

    class_call(perturbations_vector_init(ppr,
                                         pba,
                                         pth,
                                         ppt,
                                         index_md,
                                         index_ic,
                                         k,
                                         interval_limit[index_interval],
                                         ppw,
                                         previous_approx),
               ppt->error_message,
               ppt->error_message);

    /** - --> (d) integrate the perturbations over the current interval. */

    if (ppr->evolver == rk){
      generic_evolver = evolver_rk;
    }
    else {
      generic_evolver = evolver_ndf15;
    }


    class_call(generic_evolver(perturbations_derivs,
                               interval_limit[index_interval],
                               interval_limit[index_interval+1],
                               ppw->pv->y,
                               ppw->pv->used_in_sources,
                               ppw->pv->pt_size,
                               &ppaw,
                               ppr->tol_perturbations_integration,
                               ppr->smallest_allowed_variation,
                               perturbations_timescale,
                               ppr->perturbations_integration_stepsize,
                               ppt->tau_sampling,
                               tau_actual_size,
                               perturbations_sources,
                               perhaps_print_variables,
                               ppt->error_message),
               ppt->error_message,
               ppt->error_message);

  }

  /** - if perturbations were printed in a file, close the file */

  //if (perhaps_print_variables != NULL)
  //  fclose(ppw->perturbations_output_file);

  /** - fill the source terms array with zeros for all times between
      the last integrated time tau_max and tau_today. */

  for (index_tau = tau_actual_size; index_tau < ppt->tau_size; index_tau++) {
    for (index_tp = 0; index_tp < ppt->tp_size[index_md]; index_tp++) {
      ppt->sources[index_md]
        [index_ic * ppt->tp_size[index_md] + index_tp]
        [index_tau * ppt->k_size[index_md] + index_k] = 0.;
    }
  }

  /** - free quantities allocated at the beginning of the routine */

  class_call(perturbations_vector_free(ppw->pv),
             ppt->error_message,
             ppt->error_message);

  for (index_interval=0; index_interval<interval_number; index_interval++)
    free(interval_approx[index_interval]);

  free(interval_approx);

  free(interval_limit);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa970, %rsp           # imm = 0xA970
movq 0xa998(%rsp), %rax
movl 0xa990(%rsp), %eax
movq %rdi, 0xa960(%rsp)
movq %rsi, 0xa958(%rsp)
movq %rdx, 0xa950(%rsp)
movq %rcx, 0xa948(%rsp)
movl %r8d, 0xa944(%rsp)
movl %r9d, 0xa940(%rsp)
leaq -0xc8271(%rip), %rax    # 0xf540
movq %rax, 0xa888(%rsp)
movq 0xa998(%rsp), %rax
movl $0x0, 0x158(%rax)
movq 0xa998(%rsp), %rax
movl $0x0, 0x15c(%rax)
movq 0xa998(%rsp), %rax
movw $0x0, 0x154(%rax)
movq 0xa948(%rsp), %rax
movq 0x9d0(%rax), %rax
movslq 0xa944(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xa990(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xa8c8(%rsp)
movsd 0xa8c8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd78af
jp 0xd78af
leaq 0xa070(%rsp), %rdi
leaq 0xfc4e2(%rip), %rsi     # 0x1d3d24
movb $0x0, %al
callq 0x5b9c0
leaq 0x9870(%rsp), %rdi
leaq 0xa070(%rsp), %rcx
leaq 0xfa822(%rip), %rsi     # 0x1d2082
leaq 0x123eda(%rip), %rdx    # 0x1fb741
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x9870(%rsp), %r8
leaq 0xfa7a8(%rip), %rsi     # 0x1d2034
leaq 0x121a49(%rip), %rdx    # 0x1f92dc
movl $0xbf3, %ecx            # imm = 0xBF3
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa958(%rsp), %rax
movswl 0x4c8(%rax), %eax
cmpl $0x1, %eax
jne 0xd79e8
movl $0x0, 0xa8dc(%rsp)
movl 0xa8dc(%rsp), %eax
movq 0xa998(%rsp), %rcx
cmpl 0x188(%rcx), %eax
jg 0xd79e6
movq 0xa958(%rsp), %rax
movsd 0x318(%rax), %xmm0
movl 0xa8dc(%rsp), %eax
imull 0xa8dc(%rsp), %eax
cvtsi2sd %eax, %xmm1
movsd 0xfa930(%rip), %xmm2    # 0x1d2248
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
divsd 0xa8c8(%rsp), %xmm0
divsd 0xa8c8(%rsp), %xmm0
movsd 0xfa90e(%rip), %xmm1    # 0x1d2248
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd7952
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0xd79a9
movq 0xa958(%rsp), %rax
movsd 0x318(%rax), %xmm1
movl 0xa8dc(%rsp), %eax
imull 0xa8dc(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd 0xfa8cb(%rip), %xmm2    # 0x1d2248
subsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
divsd 0xa8c8(%rsp), %xmm1
divsd 0xa8c8(%rsp), %xmm1
movsd 0xfa8a9(%rip), %xmm0    # 0x1d2248
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x82e0
movq 0xa998(%rsp), %rax
movq 0x190(%rax), %rax
movslq 0xa8dc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xa8dc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8dc(%rsp)
jmp 0xd78d2
jmp 0xd79e8
movq 0xa948(%rsp), %rax
movl 0x9f8(%rax), %eax
movl %eax, 0xa8d4(%rsp)
movq 0xa958(%rsp), %rax
movq 0x450(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0xa8f0(%rsp)
movq 0xa958(%rsp), %rdi
movsd 0xa8f0(%rsp), %xmm0
movq 0xa998(%rsp), %rcx
addq $0x158, %rcx            # imm = 0x158
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %r8
movl $0x1, %esi
xorl %edx, %edx
callq 0x9e9b0
cmpl $0x1, %eax
jne 0xd7ac3
leaq 0x9070(%rsp), %rdi
movq 0xa958(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0xfa964(%rip), %rsi     # 0x1d23d8
leaq 0x121875(%rip), %rdx    # 0x1f92f0
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x9070(%rsp), %r8
leaq 0xfa594(%rip), %rsi     # 0x1d2034
leaq 0x121835(%rip), %rdx    # 0x1f92dc
movl $0xc0e, %ecx            # imm = 0xC0E
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa958(%rsp), %rdi
movq 0xa950(%rsp), %rsi
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
movsd 0xfa752(%rip), %xmm0    # 0x1d2248
divsd (%rax,%rcx,8), %xmm0
movsd 0xfa745(%rip), %xmm1    # 0x1d2248
subsd %xmm1, %xmm0
movq 0xa998(%rsp), %rcx
addq $0x15c, %rcx            # imm = 0x15C
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %r8
movq 0xa998(%rsp), %rax
movq 0x38(%rax), %r9
xorl %edx, %edx
callq 0xb05b0
cmpl $0x1, %eax
jne 0xd7ba7
leaq 0x8870(%rsp), %rdi
movq 0xa950(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0xfa880(%rip), %rsi     # 0x1d23d8
leaq 0x1217f6(%rip), %rdx    # 0x1f9355
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x8870(%rsp), %r8
leaq 0xfa4b0(%rip), %rsi     # 0x1d2034
leaq 0x121751(%rip), %rdx    # 0x1f92dc
movl $0xc18, %ecx            # imm = 0xC18
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x384(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa950(%rsp), %rcx
movslq 0xe80(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa960(%rsp), %rax
ucomisd 0x568(%rax), %xmm0
jbe 0xd7cf9
leaq 0x8070(%rsp), %rdi
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x384(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa950(%rsp), %rcx
movslq 0xe80(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
leaq 0x121756(%rip), %rsi    # 0x1f93e2
movb $0x1, %al
callq 0x5b9c0
leaq 0x7870(%rsp), %rdi
leaq 0x8070(%rsp), %rcx
leaq 0xfa3d8(%rip), %rsi     # 0x1d2082
leaq 0x121842(%rip), %rdx    # 0x1f94f3
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x7870(%rsp), %r8
leaq 0xfa35e(%rip), %rsi     # 0x1d2034
leaq 0x1215ff(%rip), %rdx    # 0x1f92dc
movl $0xc23, %ecx            # imm = 0xC23
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movsd 0xa8c8(%rsp), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x384(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa960(%rsp), %rax
ucomisd 0x570(%rax), %xmm0
jbe 0xd7e54
leaq 0x7070(%rsp), %rdi
movq 0xa948(%rsp), %rax
movq 0x9d0(%rax), %rax
movslq 0xa944(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xa948(%rsp), %rcx
movq 0x9c8(%rcx), %rcx
movslq 0xa944(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x384(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
leaq 0x12179b(%rip), %rsi    # 0x1f9582
movb $0x1, %al
callq 0x5b9c0
leaq 0x6870(%rsp), %rdi
leaq 0x7070(%rsp), %rcx
leaq 0xfa27d(%rip), %rsi     # 0x1d2082
leaq 0x121887(%rip), %rdx    # 0x1f9693
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x6870(%rsp), %r8
leaq 0xfa203(%rip), %rsi     # 0x1d2034
leaq 0x1214a4(%rip), %rdx    # 0x1f92dc
movl $0xc29, %ecx            # imm = 0xC29
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa958(%rsp), %rax
movswl 0x4be(%rax), %eax
cmpl $0x1, %eax
jne 0xd804f
movl $0x0, 0xa894(%rsp)
movl 0xa894(%rsp), %eax
movq 0xa958(%rsp), %rcx
cmpl 0x248(%rcx), %eax
jge 0xd804d
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3f0(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3ec(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
divsd (%rax,%rcx,8), %xmm0
movsd 0xfd5ac(%rip), %xmm1    # 0x1d5498
subsd %xmm1, %xmm0
movaps 0xfa339(%rip), %xmm1    # 0x1d2230
pand %xmm1, %xmm0
movq 0xa960(%rsp), %rax
ucomisd 0x50(%rax), %xmm0
jbe 0xd8035
leaq 0x6070(%rsp), %rdi
movl 0xa894(%rsp), %edx
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3f0(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3ec(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3f0(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3ec(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
leaq 0x121734(%rip), %rsi    # 0x1f96fc
movb $0x3, %al
callq 0x5b9c0
leaq 0x5870(%rsp), %rdi
leaq 0x6070(%rsp), %rcx
leaq 0xfa09c(%rip), %rsi     # 0x1d2082
leaq 0x1217d5(%rip), %rdx    # 0x1f97c2
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x5870(%rsp), %r8
leaq 0xfa022(%rip), %rsi     # 0x1d2034
leaq 0x1212c3(%rip), %rdx    # 0x1f92dc
movl $0xc33, %ecx            # imm = 0xC33
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
jmp 0xd8037
movl 0xa894(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa894(%rsp)
jmp 0xd7e77
jmp 0xd804f
movq 0xa948(%rsp), %rax
movq 0x9f0(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0xa8e8(%rsp)
movsd 0xa8f0(%rsp), %xmm1
addsd 0xa8e8(%rsp), %xmm1
movsd 0xfac03(%rip), %xmm0    # 0x1d2c88
mulsd %xmm1, %xmm0
movsd %xmm0, 0xa8e0(%rsp)
movsd 0xa8e8(%rsp), %xmm0
subsd 0xa8f0(%rsp), %xmm0
divsd 0xa8f0(%rsp), %xmm0
movq 0xa960(%rsp), %rax
ucomisd 0x618(%rax), %xmm0
jbe 0xd847b
movl $0x1, 0xa890(%rsp)
movq 0xa958(%rsp), %rdi
movsd 0xa8e0(%rsp), %xmm0
movq 0xa998(%rsp), %rcx
addq $0x158, %rcx            # imm = 0x158
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %r8
movl $0x1, %esi
xorl %edx, %edx
callq 0x9e9b0
cmpl $0x1, %eax
jne 0xd8178
leaq 0x5070(%rsp), %rdi
movq 0xa958(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0xfa2af(%rip), %rsi     # 0x1d23d8
leaq 0x121710(%rip), %rdx    # 0x1f9840
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x5070(%rsp), %r8
leaq 0xf9edf(%rip), %rsi     # 0x1d2034
leaq 0x121180(%rip), %rdx    # 0x1f92dc
movl $0xc48, %ecx            # imm = 0xC48
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa958(%rsp), %rax
movswl 0x4be(%rax), %eax
cmpl $0x1, %eax
jne 0xd8253
movl $0x0, 0xa894(%rsp)
movl 0xa894(%rsp), %eax
movq 0xa958(%rsp), %rcx
cmpl 0x248(%rcx), %eax
jge 0xd8251
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3f0(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movl 0x3ec(%rcx), %ecx
addl 0xa894(%rsp), %ecx
movslq %ecx, %rcx
divsd (%rax,%rcx,8), %xmm0
movsd 0xfd288(%rip), %xmm1    # 0x1d5498
subsd %xmm1, %xmm0
movaps 0xfa015(%rip), %xmm1    # 0x1d2230
pand %xmm1, %xmm0
movq 0xa960(%rsp), %rax
ucomisd 0x50(%rax), %xmm0
jbe 0xd8239
movl $0x0, 0xa890(%rsp)
jmp 0xd823b
movl 0xa894(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa894(%rsp)
jmp 0xd819b
jmp 0xd8253
cmpl $0x1, 0xa890(%rsp)
jne 0xd841f
movq 0xa958(%rsp), %rdi
movq 0xa950(%rsp), %rsi
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
movsd 0xf9fb4(%rip), %xmm0    # 0x1d2248
divsd (%rax,%rcx,8), %xmm0
movsd 0xf9fa7(%rip), %xmm1    # 0x1d2248
subsd %xmm1, %xmm0
movq 0xa998(%rsp), %rcx
addq $0x15c, %rcx            # imm = 0x15C
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %r8
movq 0xa998(%rsp), %rax
movq 0x38(%rax), %r9
xorl %edx, %edx
callq 0xb05b0
cmpl $0x1, %eax
jne 0xd8345
leaq 0x4870(%rsp), %rdi
movq 0xa950(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0xfa0e2(%rip), %rsi     # 0x1d23d8
leaq 0x121058(%rip), %rdx    # 0x1f9355
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x4870(%rsp), %r8
leaq 0xf9d12(%rip), %rsi     # 0x1d2034
leaq 0x120fb3(%rip), %rdx    # 0x1f92dc
movl $0xc5d, %ecx            # imm = 0xC5D
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x384(%rcx), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa950(%rsp), %rcx
movslq 0xe80(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa960(%rsp), %rax
ucomisd 0x568(%rax), %xmm0
ja 0xd8412
movsd 0xa8c8(%rsp), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x380(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa998(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xa958(%rsp), %rcx
movslq 0x384(%rcx), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0xa960(%rsp), %rax
ucomisd 0x570(%rax), %xmm0
jbe 0xd841d
movl $0x0, 0xa890(%rsp)
jmp 0xd841f
cmpl $0x1, 0xa890(%rsp)
jne 0xd843d
movsd 0xa8e0(%rsp), %xmm0
movsd %xmm0, 0xa8f0(%rsp)
jmp 0xd844f
movsd 0xa8e0(%rsp), %xmm0
movsd %xmm0, 0xa8e8(%rsp)
movsd 0xa8f0(%rsp), %xmm1
addsd 0xa8e8(%rsp), %xmm1
movsd 0xfa81f(%rip), %xmm0    # 0x1d2c88
mulsd %xmm1, %xmm0
movsd %xmm0, 0xa8e0(%rsp)
jmp 0xd8092
movsd 0xa8e0(%rsp), %xmm0
movsd %xmm0, 0xa8f8(%rsp)
movq 0xa998(%rsp), %rax
movslq 0x178(%rax), %rdi
shlq $0x2, %rdi
callq 0x8460
movq %rax, 0xa8b8(%rsp)
cmpq $0x0, 0xa8b8(%rsp)
jne 0xd8537
movq 0xa998(%rsp), %rax
movslq 0x178(%rax), %rax
shlq $0x2, %rax
movl %eax, 0x486c(%rsp)
leaq 0x4060(%rsp), %rdi
movl 0x486c(%rsp), %ecx
leaq 0xf9b1c(%rip), %rsi     # 0x1d2004
leaq 0x1213b4(%rip), %rdx    # 0x1f98a3
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x4060(%rsp), %r8
leaq 0xf9b20(%rip), %rsi     # 0x1d2034
leaq 0x120dc1(%rip), %rdx    # 0x1f92dc
movl $0xc76, %ecx            # imm = 0xC76
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa998(%rsp), %rax
movw $0x0, 0x154(%rax)
movq 0xa960(%rsp), %rdi
movq 0xa958(%rsp), %rsi
movq 0xa950(%rsp), %rdx
movq 0xa948(%rsp), %rcx
movl 0xa944(%rsp), %r8d
movsd 0xa8c8(%rsp), %xmm0
movq 0xa998(%rsp), %r9
movsd 0xa8f8(%rsp), %xmm1
movq 0xa948(%rsp), %rax
movq 0x9f0(%rax), %rax
movl 0xa8d4(%rsp), %r10d
subl $0x1, %r10d
movslq %r10d, %r10
movsd (%rax,%r10,8), %xmm2
movq 0xa8b8(%rsp), %rax
leaq 0xa8c4(%rsp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xd9090
cmpl $0x1, %eax
jne 0xd863e
leaq 0x3860(%rsp), %rdi
movq 0xa948(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0xf9de9(%rip), %rsi     # 0x1d23d8
leaq 0x1212c0(%rip), %rdx    # 0x1f98b6
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x3860(%rsp), %r8
leaq 0xf9a19(%rip), %rsi     # 0x1d2034
leaq 0x120cba(%rip), %rdx    # 0x1f92dc
movl $0xc86, %ecx            # imm = 0xC86
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movl 0xa8c4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xa8b0(%rsp)
cmpq $0x0, 0xa8b0(%rsp)
jne 0xd86e3
movl 0xa8c4(%rsp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, 0x385c(%rsp)
leaq 0x3050(%rsp), %rdi
movl 0x385c(%rsp), %ecx
leaq 0xf9970(%rip), %rsi     # 0x1d2004
leaq 0x11a8ac(%rip), %rdx    # 0x1f2f47
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x3050(%rsp), %r8
leaq 0xf9974(%rip), %rsi     # 0x1d2034
leaq 0x120c15(%rip), %rdx    # 0x1f92dc
movl $0xc88, %ecx            # imm = 0xC88
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movslq 0xa8c4(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xa8a8(%rsp)
cmpq $0x0, 0xa8a8(%rsp)
jne 0xd877f
movslq 0xa8c4(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x304c(%rsp)
leaq 0x2840(%rsp), %rdi
movl 0x304c(%rsp), %ecx
leaq 0xf98d4(%rip), %rsi     # 0x1d2004
leaq 0x12121e(%rip), %rdx    # 0x1f9955
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x2840(%rsp), %r8
leaq 0xf98d8(%rip), %rsi     # 0x1d2034
leaq 0x120b79(%rip), %rdx    # 0x1f92dc
movl $0xc8a, %ecx            # imm = 0xC8A
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movl $0x0, 0xa8c0(%rsp)
movl 0xa8c0(%rsp), %eax
cmpl 0xa8c4(%rsp), %eax
jge 0xd887b
movq 0xa998(%rsp), %rax
movslq 0x178(%rax), %rdi
shlq $0x2, %rdi
callq 0x8460
movq %rax, %rdx
movq 0xa8a8(%rsp), %rax
movslq 0xa8c0(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0xa8a8(%rsp), %rax
movslq 0xa8c0(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xd8863
movq 0xa998(%rsp), %rax
movslq 0x178(%rax), %rax
shlq $0x2, %rax
movl %eax, 0x283c(%rsp)
leaq 0x2030(%rsp), %rdi
movl 0x283c(%rsp), %ecx
leaq 0xf97f0(%rip), %rsi     # 0x1d2004
leaq 0x12114a(%rip), %rdx    # 0x1f9965
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x2030(%rsp), %r8
leaq 0xf97f4(%rip), %rsi     # 0x1d2034
leaq 0x120a95(%rip), %rdx    # 0x1f92dc
movl $0xc8d, %ecx            # imm = 0xC8D
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
jmp 0xd8865
movl 0xa8c0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8c0(%rsp)
jmp 0xd878a
movq 0xa960(%rsp), %rdi
movq 0xa958(%rsp), %rsi
movq 0xa950(%rsp), %rdx
movq 0xa948(%rsp), %rcx
movl 0xa944(%rsp), %r8d
movsd 0xa8c8(%rsp), %xmm0
movq 0xa998(%rsp), %r9
movsd 0xa8f8(%rsp), %xmm1
movq 0xa948(%rsp), %rax
movq 0x9f0(%rax), %rax
movl 0xa8d4(%rsp), %r10d
subl $0x1, %r10d
movslq %r10d, %r10
movsd (%rax,%r10,8), %xmm2
movq 0xa960(%rsp), %rax
movsd 0x618(%rax), %xmm3
movl 0xa8c4(%rsp), %ebx
movq 0xa8b8(%rsp), %r11
movq 0xa8b0(%rsp), %r10
movq 0xa8a8(%rsp), %rax
movl %ebx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0xd93d0
cmpl $0x1, %eax
jne 0xd8999
leaq 0x1830(%rsp), %rdi
movq 0xa948(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0xf9a8e(%rip), %rsi     # 0x1d23d8
leaq 0x121034(%rip), %rdx    # 0x1f9985
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x1830(%rsp), %r8
leaq 0xf96be(%rip), %rsi     # 0x1d2034
leaq 0x12095f(%rip), %rdx    # 0x1f92dc
movl $0xc9e, %ecx            # imm = 0xC9E
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa8b8(%rsp), %rdi
callq 0x8420
movq 0xa960(%rsp), %rax
movq %rax, 0xa900(%rsp)
movq 0xa958(%rsp), %rax
movq %rax, 0xa908(%rsp)
movq 0xa950(%rsp), %rax
movq %rax, 0xa910(%rsp)
movq 0xa948(%rsp), %rax
movq %rax, 0xa918(%rsp)
movl 0xa944(%rsp), %eax
movl %eax, 0xa920(%rsp)
movl 0xa940(%rsp), %eax
movl %eax, 0xa924(%rsp)
movl 0xa990(%rsp), %eax
movl %eax, 0xa928(%rsp)
movsd 0xa8c8(%rsp), %xmm0
movsd %xmm0, 0xa930(%rsp)
movq 0xa998(%rsp), %rax
movq %rax, 0xa938(%rsp)
movq 0xa938(%rsp), %rax
movw $0x1, 0x154(%rax)
movq 0xa938(%rsp), %rax
movl $0x0, 0x158(%rax)
movq 0xa938(%rsp), %rax
movl $0x0, 0x15c(%rax)
movq $0x0, 0xa880(%rsp)
movq 0xa998(%rsp), %rax
movl $0xffffffff, 0x150(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0xa87c(%rsp)
movl 0xa87c(%rsp), %eax
movq 0xa948(%rsp), %rcx
cmpl 0x6d4(%rcx), %eax
jge 0xd8b1e
movq 0xa948(%rsp), %rax
movq 0xa78(%rax), %rax
movl 0xa944(%rsp), %ecx
movq 0xa948(%rsp), %rdx
imull 0x6d4(%rdx), %ecx
addl 0xa87c(%rsp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl 0xa990(%rsp), %eax
jne 0xd8b06
movl 0xa87c(%rsp), %ecx
movq 0xa998(%rsp), %rax
movl %ecx, 0x150(%rax)
leaq 0x1b22(%rip), %rax      # 0xda620
movq %rax, 0xa880(%rsp)
jmp 0xd8b08
movl 0xa87c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa87c(%rsp)
jmp 0xd8a90
movl $0x0, 0xa8c0(%rsp)
movl 0xa8c0(%rsp), %eax
cmpl 0xa8c4(%rsp), %eax
jge 0xd8e80
movl $0x0, 0xa8a4(%rsp)
movl 0xa8a4(%rsp), %eax
movq 0xa998(%rsp), %rcx
cmpl 0x178(%rcx), %eax
jge 0xd8bab
movq 0xa8a8(%rsp), %rax
movslq 0xa8c0(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xa8a4(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0xa998(%rsp), %rax
movq 0x180(%rax), %rax
movslq 0xa8a4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xa8a4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8a4(%rsp)
jmp 0xd8b48
cmpl $0x0, 0xa8c0(%rsp)
jne 0xd8bc3
movq $0x0, 0xa898(%rsp)
jmp 0xd8be4
movq 0xa8a8(%rsp), %rax
movl 0xa8c0(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0xa898(%rsp)
movq 0xa960(%rsp), %rdi
movq 0xa958(%rsp), %rsi
movq 0xa950(%rsp), %rdx
movq 0xa948(%rsp), %rcx
movl 0xa944(%rsp), %r8d
movl 0xa940(%rsp), %r9d
movsd 0xa8c8(%rsp), %xmm0
movq 0xa8b0(%rsp), %rax
movslq 0xa8c0(%rsp), %r10
movsd (%rax,%r10,8), %xmm1
movq 0xa998(%rsp), %r10
movq 0xa898(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xdffa0
cmpl $0x1, %eax
jne 0xd8cc3
leaq 0x1030(%rsp), %rdi
movq 0xa948(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0xf9764(%rip), %rsi     # 0x1d23d8
leaq 0x120de0(%rip), %rdx    # 0x1f9a5b
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x1030(%rsp), %r8
leaq 0xf9394(%rip), %rsi     # 0x1d2034
leaq 0x120635(%rip), %rdx    # 0x1f92dc
movl $0xce5, %ecx            # imm = 0xCE5
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movq 0xa960(%rsp), %rax
cmpl $0x0, 0x678(%rax)
jne 0xd8ce5
leaq -0xca21b(%rip), %rax    # 0xeac0
movq %rax, 0xa888(%rsp)
jmp 0xd8cf4
leaq -0xc97ac(%rip), %rax    # 0xf540
movq %rax, 0xa888(%rsp)
movq 0xa888(%rsp), %rax
movq 0xa8b0(%rsp), %rcx
movslq 0xa8c0(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0xa8b0(%rsp), %rcx
movl 0xa8c0(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm1
movq 0xa998(%rsp), %rcx
movq 0x48(%rcx), %rcx
movq 0xf0(%rcx), %rsi
movq 0xa998(%rsp), %rcx
movq 0x48(%rcx), %rcx
movq 0x100(%rcx), %rdx
movq 0xa998(%rsp), %rcx
movq 0x48(%rcx), %rcx
movl 0xe8(%rcx), %ecx
movq 0xa960(%rsp), %rdi
movsd 0x608(%rdi), %xmm2
movq 0xa960(%rsp), %rdi
movsd 0xa28(%rdi), %xmm3
movq 0xa960(%rsp), %rdi
movsd 0x5f0(%rdi), %xmm4
movq 0xa948(%rsp), %rdi
movq 0x9f0(%rdi), %r14
movl 0xa8d4(%rsp), %ebp
movq 0xa880(%rsp), %r11
movq 0xa948(%rsp), %r10
addq $0x6c8a, %r10           # imm = 0x6C8A
leaq 0xeb19(%rip), %rdi      # 0xe78e0
leaq 0xa900(%rsp), %r8
leaq 0x199ca(%rip), %r9      # 0xf27a0
leaq 0x1a3d3(%rip), %rbx     # 0xf31b0
movq %r14, (%rsp)
movl %ebp, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
callq *%rax
cmpl $0x1, %eax
jne 0xd8e68
leaq 0x830(%rsp), %rdi
movq 0xa948(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0xf95bf(%rip), %rsi     # 0x1d23d8
leaq 0x120cb6(%rip), %rdx    # 0x1f9ad6
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x830(%rsp), %r8
leaq 0xf91ef(%rip), %rsi     # 0x1d2034
leaq 0x120490(%rip), %rdx    # 0x1f92dc
movl $0xd02, %ecx            # imm = 0xD02
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
jmp 0xd8e6a
movl 0xa8c0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8c0(%rsp)
jmp 0xd8b29
movl 0xa8d4(%rsp), %eax
movl %eax, 0xa8d8(%rsp)
movl 0xa8d8(%rsp), %eax
movq 0xa948(%rsp), %rcx
cmpl 0x9f8(%rcx), %eax
jge 0xd8f88
movl $0x0, 0xa8d0(%rsp)
movl 0xa8d0(%rsp), %eax
movq 0xa948(%rsp), %rcx
movq 0x998(%rcx), %rcx
movslq 0xa944(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xd8f70
movq 0xa948(%rsp), %rax
movq 0xa38(%rax), %rax
movslq 0xa944(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0xa940(%rsp), %ecx
movq 0xa948(%rsp), %rdx
movq 0x998(%rdx), %rdx
movslq 0xa944(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0xa8d0(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0xa8d8(%rsp), %ecx
movq 0xa948(%rsp), %rdx
movq 0x9c8(%rdx), %rdx
movslq 0xa944(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0xa990(%rsp), %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0xa8d0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8d0(%rsp)
jmp 0xd8eb4
jmp 0xd8f72
movl 0xa8d8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8d8(%rsp)
jmp 0xd8e8e
movq 0xa998(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0xf8cb0
cmpl $0x1, %eax
jne 0xd9002
leaq 0x30(%rsp), %rdi
movq 0xa948(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0xf941f(%rip), %rsi     # 0x1d23d8
leaq 0x120cac(%rip), %rdx    # 0x1f9c6c
movb $0x0, %al
callq 0x5b9c0
movq 0xa948(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x30(%rsp), %r8
leaq 0xf9052(%rip), %rsi     # 0x1d2034
leaq 0x1202f3(%rip), %rdx    # 0x1f92dc
movl $0xd1a, %ecx            # imm = 0xD1A
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xa96c(%rsp)
jmp 0xd906e
movl $0x0, 0xa8c0(%rsp)
movl 0xa8c0(%rsp), %eax
cmpl 0xa8c4(%rsp), %eax
jge 0xd9049
movq 0xa8a8(%rsp), %rax
movslq 0xa8c0(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0xa8c0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8c0(%rsp)
jmp 0xd900d
movq 0xa8a8(%rsp), %rdi
callq 0x8420
movq 0xa8b0(%rsp), %rdi
callq 0x8420
movl $0x0, 0xa96c(%rsp)
movl 0xa96c(%rsp), %eax
addq $0xa970, %rsp           # imm = 0xA970
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)