// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/input.c
// Function: input_prepare_pk_eq
int input_prepare_pk_eq(struct precision * ppr,
                        struct background *pba,
                        struct thermodynamics *pth,
                        struct fourier *pfo,
                        int input_verbose,
                        ErrorMsg errmsg) {

  /** Summary: */

  /** Define local variables */
  double tau_of_z;
  double delta_tau;
  double error;
  double delta_tau_eq;
  double * pvecback;
  int last_index=0;
  int index_pk_eq_z;
  int index_eq;
  int true_background_verbose;
  int true_thermodynamics_verbose;
  int true_hyrec_verbose;
  double true_w0_fld;
  double true_wa_fld;
  double * z;

  /** Store the true cosmological parameters (w0, wa) somwhere before using temporarily some fake ones in this function */
  true_background_verbose = pba->background_verbose;
  true_thermodynamics_verbose = pth->thermodynamics_verbose;
  true_hyrec_verbose = pth->hyrec_verbose;
  true_w0_fld = pba->w0_fld;
  true_wa_fld = pba->wa_fld;

  /** The fake calls of the background and thermodynamics module will be done in non-verbose mode */
  pba->background_verbose = 0;
  pth->thermodynamics_verbose = 0;
  pth->hyrec_verbose = 0;

  /** Allocate indices and arrays for storing the results */
  pfo->pk_eq_tau_size = ppr->pk_eq_Nzlog;
  class_alloc(pfo->pk_eq_tau,
              pfo->pk_eq_tau_size*sizeof(double),
              errmsg);
  class_alloc(z,
              pfo->pk_eq_tau_size*sizeof(double),
              errmsg);

  index_eq = 0;
  class_define_index(pfo->index_pk_eq_w,_TRUE_,index_eq,1);
  class_define_index(pfo->index_pk_eq_Omega_m,_TRUE_,index_eq,1);
  pfo->pk_eq_size = index_eq;
  class_alloc(pfo->pk_eq_w_and_Omega,
              pfo->pk_eq_tau_size*pfo->pk_eq_size*sizeof(double),
              errmsg);
  class_alloc(pfo->pk_eq_ddw_and_ddOmega,
              pfo->pk_eq_tau_size*pfo->pk_eq_size*sizeof(double),
              errmsg);

  /** Call the background module in order to fill a table of tau_i[z_i] */
  class_call(background_init(ppr,pba), pba->error_message, errmsg);
  for (index_pk_eq_z=0; index_pk_eq_z<pfo->pk_eq_tau_size; index_pk_eq_z++) {
    z[index_pk_eq_z] = exp(log(1.+ppr->pk_eq_z_max)/(pfo->pk_eq_tau_size-1)*index_pk_eq_z)-1.;
    class_call(background_tau_of_z(pba,
                                   z[index_pk_eq_z],
                                   &tau_of_z),
               pba->error_message,
               errmsg);
    pfo->pk_eq_tau[index_pk_eq_z] = tau_of_z;
  }
  class_call(background_free_noinput(pba),
             pba->error_message,
             errmsg);

  /** Loop over z_i values. For each of them, we will call the
      background and thermodynamics module for fake models. The goal is
      to find, for each z_i, and effective w0_eff[z_i] and
      Omega_m_eff{z_i], such that: the true model with (w0,wa) and the
      equivalent model with (w0_eff[z_i],0) have the same conformal
      distance between z_i and z_recombination, namely chi = tau[z_i] -
      tau_rec. It is thus necessary to call both the background and
      thermodynamics module for each fake model and to re-compute
      tau_rec for each of them. Once the eqauivalent model is found we
      compute and store Omega_m_effa(z_i) of the equivalent model */
  for (index_pk_eq_z=0; index_pk_eq_z<pfo->pk_eq_tau_size; index_pk_eq_z++) {

    if (input_verbose > 2)
      printf("    * computing Pk_equal parameters at z=%e\n",z[index_pk_eq_z]);
    /* get chi = (tau[z_i] - tau_rec) in true model */
    pba->w0_fld = true_w0_fld;
    pba->wa_fld = true_wa_fld;
    class_call(background_init(ppr,pba),
               pba->error_message,
               errmsg);
    class_call(thermodynamics_init(ppr,pba,pth),
               pth->error_message,
               errmsg);
    delta_tau = pfo->pk_eq_tau[index_pk_eq_z] - pth->tau_rec;
    /* launch iterations in order to coverge to effective model with wa=0 but the same chi = (tau[z_i] - tau_rec) */
    pba->wa_fld=0.;

    do {
      class_call(background_free_noinput(pba),
                 pba->error_message,
                 errmsg);
      class_call(thermodynamics_free(pth),
                 pth->error_message,
                 errmsg);

      class_call(background_init(ppr,pba),
                 pba->error_message,
                 errmsg);
      class_call(background_tau_of_z(pba,
                                     z[index_pk_eq_z],
                                     &tau_of_z),
                 pba->error_message,
                 errmsg);
      class_call(thermodynamics_init(ppr,pba,pth),
                 pth->error_message,
                 errmsg);

      delta_tau_eq = tau_of_z - pth->tau_rec;

      error = 1.-delta_tau_eq/delta_tau;
      pba->w0_fld = pba->w0_fld*pow(1.+error,10.);

    }
    while(fabs(error) > ppr->pk_eq_tol);

    /* Equivalent model found. Store w0(z) in that model. Find Omega_m(z) in that model and store it. */
    pfo->pk_eq_w_and_Omega[pfo->pk_eq_size*index_pk_eq_z+pfo->index_pk_eq_w] = pba->w0_fld;
    class_alloc(pvecback,
                pba->bg_size*sizeof(double),
                pba->error_message);
    class_call(background_at_tau(pba,
                                 tau_of_z,
                                 long_info,
                                 inter_normal,
                                 &last_index,
                                 pvecback),
               pba->error_message, errmsg);
    pfo->pk_eq_w_and_Omega[pfo->pk_eq_size*index_pk_eq_z+pfo->index_pk_eq_Omega_m] = pvecback[pba->index_bg_Omega_m];
    free(pvecback);

    class_call(background_free_noinput(pba),
               pba->error_message,
               errmsg);
    class_call(thermodynamics_free(pth),
               pth->error_message,
               errmsg);
  }

  /** Restore cosmological parameters (w0, wa) to their true values before main call to CLASS modules */
  pba->background_verbose = true_background_verbose;
  pth->thermodynamics_verbose = true_thermodynamics_verbose;
  pth->hyrec_verbose = true_hyrec_verbose;

  pba->w0_fld = true_w0_fld;
  pba->wa_fld = true_wa_fld;

  /* in verbose mode, report the results */

  if (input_verbose > 1) {
    fprintf(stdout,"    Effective parameters for Pk_equal:\n");

    for (index_pk_eq_z=0; index_pk_eq_z<pfo->pk_eq_tau_size; index_pk_eq_z++) {
      fprintf(stdout,"    * at z=%e, tau=%e w=%e Omega_m=%e\n",
              z[index_pk_eq_z],
              pfo->pk_eq_tau[index_pk_eq_z],
              pfo->pk_eq_w_and_Omega[pfo->pk_eq_size*index_pk_eq_z+pfo->index_pk_eq_w],
              pfo->pk_eq_w_and_Omega[pfo->pk_eq_size*index_pk_eq_z+pfo->index_pk_eq_Omega_m]);
    }
  }
  free(z);

  /** Spline the table for later interpolation */
  class_call(array_spline_table_lines(pfo->pk_eq_tau,
                                      pfo->pk_eq_tau_size,
                                      pfo->pk_eq_w_and_Omega,
                                      pfo->pk_eq_size,
                                      pfo->pk_eq_ddw_and_ddOmega,
                                      _SPLINE_NATURAL_,
                                      errmsg),
             errmsg,
             errmsg);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x888, %rsp            # imm = 0x888
movq %r9, %r12
movl %r8d, 0x1c(%rsp)
andl $0x0, 0x3c(%rsp)
movq %rsi, %r14
movzwl 0xd1a(%rsi), %eax
movw %ax, 0x1a(%rsp)
movsd 0x1060(%rdx), %xmm0
movaps %xmm0, 0x70(%rsp)
movupd 0x48(%rsi), %xmm0
movapd %xmm0, 0x60(%rsp)
andw $0x0, 0xd1a(%rsi)
movq %rcx, %r15
movq %rdx, 0x20(%rsp)
andl $0x0, 0x1060(%rdx)
movq %rdi, %rbx
movslq 0x878(%rdi), %rbp
movl %ebp, 0x170(%rcx)
leaq (,%rbp,8), %r13
movq %r13, %rdi
callq 0x8490
movq %rax, 0x178(%r15)
testq %rax, %rax
je 0x38fc7
movq %r12, 0x10(%rsp)
movq %r13, %rdi
callq 0x8490
testq %rax, %rax
je 0x39007
movq %rax, %r12
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x164(%r15)
movl $0x2, 0x16c(%r15)
movq %rbp, %r13
shlq $0x4, %r13
movq %r13, %rdi
callq 0x8490
movq %rax, 0x180(%r15)
testq %rax, %rax
je 0x39049
movq %r13, %rdi
callq 0x8490
movq %rax, 0x188(%r15)
testq %rax, %rax
je 0x3908b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a9de
cmpl $0x1, %eax
jne 0x390cd
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xac462(%rip), %rsi     # 0xe53f0
leaq 0xc1923(%rip), %rdx     # 0xfa8b8
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xac083(%rip), %rsi     # 0xe5034
leaq 0xc18ba(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x164a, %ecx           # imm = 0x164A
jmp 0x391e2
shll $0x3, %ebp
leaq 0xac033(%rip), %rsi     # 0xe5004
leaq 0xc188b(%rip), %rdx     # 0xfa863
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xac041(%rip), %rsi     # 0xe5034
leaq 0xc1878(%rip), %rdx     # 0xfa872
movq %r12, %rdi
movl $0x1639, %ecx           # imm = 0x1639
jmp 0x391e2
shll $0x3, %ebp
leaq 0xabff3(%rip), %rsi     # 0xe5004
leaq 0xe5e3b(%rip), %rdx     # 0x11ee53
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xac001(%rip), %rsi     # 0xe5034
leaq 0xc1838(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x163c, %ecx           # imm = 0x163C
jmp 0x391e2
shll $0x4, %ebp
leaq 0xabfb1(%rip), %rsi     # 0xe5004
leaq 0xc182c(%rip), %rdx     # 0xfa886
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xabfbf(%rip), %rsi     # 0xe5034
leaq 0xc17f6(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1644, %ecx           # imm = 0x1644
jmp 0x391e2
shll $0x4, %ebp
leaq 0xabf6f(%rip), %rsi     # 0xe5004
leaq 0xc1801(%rip), %rdx     # 0xfa89d
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xabf7d(%rip), %rsi     # 0xe5034
leaq 0xc17b4(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1647, %ecx           # imm = 0x1647
jmp 0x391e2
xorl %r13d, %r13d
leaq 0x28(%rsp), %rbp
movslq 0x170(%r15), %rax
cmpq %rax, %r13
jge 0x3914b
movsd 0x870(%rbx), %xmm0
addsd 0xac16f(%rip), %xmm0    # 0xe5260
callq 0x82e0
movl 0x170(%r15), %eax
decl %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
cvtsi2sd %r13d, %xmm1
mulsd %xmm1, %xmm0
callq 0x86a0
addsd 0xac6cb(%rip), %xmm0    # 0xe57e8
movsd %xmm0, (%r12,%r13,8)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x58adb
cmpl $0x1, %eax
je 0x391a0
movsd 0x28(%rsp), %xmm0
movq 0x178(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x390d5
movq %r14, %rdi
callq 0x5dfa6
cmpl $0x1, %eax
jne 0x39203
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xac286(%rip), %rsi     # 0xe53f0
leaq 0xc1796(%rip), %rdx     # 0xfa907
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xabea7(%rip), %rsi     # 0xe5034
leaq 0xc16de(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1656, %ecx           # imm = 0x1656
jmp 0x391e2
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xac242(%rip), %rsi     # 0xe53f0
leaq 0xc171c(%rip), %rdx     # 0xfa8d1
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xabe63(%rip), %rsi     # 0xe5034
leaq 0xc169a(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1651, %ecx           # imm = 0x1651
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x888, %rsp            # imm = 0x888
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
movslq 0x170(%r15), %rbp
cmpq %rbp, %r13
jge 0x395ed
cmpl $0x3, 0x1c(%rsp)
jl 0x39231
movsd (%r12,%r13,8), %xmm0
leaq 0xc16fa(%rip), %rdi     # 0xfa924
movb $0x1, %al
callq 0x8030
movq %r12, %rbp
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x48(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a9de
cmpl $0x1, %eax
movq 0x20(%rsp), %r12
je 0x396b6
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x62e7f
cmpl $0x1, %eax
je 0x396fd
movq 0x178(%r15), %rax
movsd (%rax,%r13,8), %xmm0
subsd 0xf38(%r12), %xmm0
movsd %xmm0, 0x58(%rsp)
andq $0x0, 0x50(%r14)
movq %r14, %rdi
callq 0x5dfa6
cmpl $0x1, %eax
je 0x3948a
movq %r12, %rdi
callq 0x66ecc
cmpl $0x1, %eax
je 0x394d1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a9de
cmpl $0x1, %eax
je 0x39518
movsd (%rbp,%r13,8), %xmm0
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
callq 0x58adb
cmpl $0x1, %eax
je 0x3955f
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x62e7f
cmpl $0x1, %eax
je 0x395a6
movsd 0x28(%rsp), %xmm0
subsd 0xf38(%r12), %xmm0
divsd 0x58(%rsp), %xmm0
movsd 0xabf48(%rip), %xmm1    # 0xe5260
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, 0x40(%rsp)
movsd 0x48(%r14), %xmm0
movsd %xmm0, 0x30(%rsp)
movapd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xac4ae(%rip), %xmm1    # 0xe57f0
callq 0x8650
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x48(%r14)
movapd 0x40(%rsp), %xmm1
andpd 0xabedf(%rip), %xmm1    # 0xe5240
ucomisd 0x880(%rbx), %xmm1
ja 0x39290
movq 0x180(%r15), %rax
movslq 0x16c(%r15), %rcx
movslq %r13d, %rdx
movq %rdx, 0x40(%rsp)
imulq %rdx, %rcx
movslq 0x164(%r15), %rdx
addq %rcx, %rdx
movsd %xmm0, (%rax,%rdx,8)
movslq 0x43c(%r14), %r12
leaq (,%r12,8), %rdi
callq 0x8490
testq %rax, %rax
je 0x397c7
movsd 0x28(%rsp), %xmm0
movq %r14, %rdi
pushq $0x2
popq %rsi
xorl %edx, %edx
leaq 0x3c(%rsp), %rcx
movq %rax, 0x30(%rsp)
movq %rax, %r8
callq 0x5887d
cmpl $0x1, %eax
je 0x39810
movq %rbp, %r12
movslq 0x40c(%r14), %rax
movq 0x30(%rsp), %rdi
movsd (%rdi,%rax,8), %xmm0
movq 0x180(%r15), %rax
movslq 0x16c(%r15), %rcx
imulq 0x40(%rsp), %rcx
movslq 0x168(%r15), %rdx
addq %rcx, %rdx
movsd %xmm0, (%rax,%rdx,8)
callq 0x8430
movq %r14, %rdi
callq 0x5dfa6
cmpl $0x1, %eax
je 0x39857
movq 0x20(%rsp), %rdi
callq 0x66ecc
incq %r13
cmpl $0x1, %eax
jne 0x39206
movq 0x20(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0xabf9c(%rip), %rsi     # 0xe53f0
leaq 0xc1517(%rip), %rdx     # 0xfa972
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xabbc0(%rip), %rsi     # 0xe5034
leaq 0xc13f7(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x16a3, %ecx           # imm = 0x16A3
jmp 0x391e2
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xabf58(%rip), %rsi     # 0xe53f0
leaq 0xc1468(%rip), %rdx     # 0xfa907
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xabb79(%rip), %rsi     # 0xe5034
leaq 0xc13b0(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1676, %ecx           # imm = 0x1676
jmp 0x391e2
addq $0x1064, %r12           # imm = 0x1064
leaq 0xabf11(%rip), %rsi     # 0xe53f0
leaq 0xc148c(%rip), %rdx     # 0xfa972
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xabb32(%rip), %rsi     # 0xe5034
leaq 0xc1369(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1679, %ecx           # imm = 0x1679
jmp 0x391e2
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xabeca(%rip), %rsi     # 0xe53f0
leaq 0xc138b(%rip), %rdx     # 0xfa8b8
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xabaeb(%rip), %rsi     # 0xe5034
leaq 0xc1322(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x167d, %ecx           # imm = 0x167D
jmp 0x391e2
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xabe83(%rip), %rsi     # 0xe53f0
leaq 0xc135d(%rip), %rdx     # 0xfa8d1
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xabaa4(%rip), %rsi     # 0xe5034
leaq 0xc12db(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1682, %ecx           # imm = 0x1682
jmp 0x391e2
addq $0x1064, %r12           # imm = 0x1064
leaq 0xabe3c(%rip), %rsi     # 0xe53f0
leaq 0xc1396(%rip), %rdx     # 0xfa951
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xaba5d(%rip), %rsi     # 0xe5034
leaq 0xc1294(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x1685, %ecx           # imm = 0x1685
jmp 0x391e2
movzwl 0x1a(%rsp), %eax
movw %ax, 0xd1a(%r14)
movq 0x20(%rsp), %rax
movaps 0x70(%rsp), %xmm0
movss %xmm0, 0x1060(%rax)
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x48(%r14)
cmpl $0x2, 0x1c(%rsp)
jl 0x39747
movq %r12, %r13
movq 0x109925(%rip), %r14    # 0x142f50
movq (%r14), %rcx
leaq 0xc13a7(%rip), %rdi     # 0xfa9dc
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x8700
xorl %r12d, %r12d
leaq 0xc13ba(%rip), %rbx     # 0xfaa04
movslq 0x170(%r15), %rbp
cmpq %rbp, %r12
jge 0x39744
movq (%r14), %rdi
movsd (%r13,%r12,8), %xmm0
movq 0x178(%r15), %rax
movq 0x180(%r15), %rcx
movsd (%rax,%r12,8), %xmm1
movslq 0x16c(%r15), %rax
movslq %r12d, %rdx
imulq %rax, %rdx
movslq 0x164(%r15), %rax
addq %rdx, %rax
movsd (%rcx,%rax,8), %xmm2
movslq 0x168(%r15), %rax
movslq %edx, %rdx
addq %rax, %rdx
movsd (%rcx,%rdx,8), %xmm3
movq %rbx, %rsi
movb $0x4, %al
callq 0x8510
incq %r12
jmp 0x3964a
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xabd2c(%rip), %rsi     # 0xe53f0
leaq 0xc11ed(%rip), %rdx     # 0xfa8b8
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xab94d(%rip), %rsi     # 0xe5034
leaq 0xc1184(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x166b, %ecx           # imm = 0x166B
jmp 0x391e2
addq $0x1064, %r12           # imm = 0x1064
leaq 0xabce5(%rip), %rsi     # 0xe53f0
leaq 0xc123f(%rip), %rdx     # 0xfa951
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xab906(%rip), %rsi     # 0xe5034
leaq 0xc113d(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x166e, %ecx           # imm = 0x166E
jmp 0x391e2
movq %r13, %r12
movq %r12, %rdi
callq 0x8430
movq 0x178(%r15), %rdi
movq 0x180(%r15), %rdx
movl 0x16c(%r15), %ecx
movq 0x188(%r15), %r8
movq 0x10(%rsp), %r14
movq %r14, (%rsp)
xorl %ebx, %ebx
movl %ebp, %esi
xorl %r9d, %r9d
callq 0x125a5
cmpl $0x1, %eax
jne 0x391ef
leaq 0xabc60(%rip), %rsi     # 0xe53f0
leaq 0xc1294(%rip), %rdx     # 0xfaa2b
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xab881(%rip), %rsi     # 0xe5034
leaq 0xc10b8(%rip), %rdx     # 0xfa872
movq %r14, %rdi
movl $0x16c6, %ecx           # imm = 0x16C6
jmp 0x391e2
shll $0x3, %r12d
leaq 0xab832(%rip), %rsi     # 0xe5004
leaq 0xd2959(%rip), %rdx     # 0x10c132
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x2e014
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xab838(%rip), %rsi     # 0xe5034
leaq 0xc106f(%rip), %rdx     # 0xfa872
movq %r14, %rdi
movl $0x1693, %ecx           # imm = 0x1693
jmp 0x391e2
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xabbd2(%rip), %rsi     # 0xe53f0
leaq 0xc1166(%rip), %rdx     # 0xfa98b
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xab7f3(%rip), %rsi     # 0xe5034
leaq 0xc102a(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x169a, %ecx           # imm = 0x169A
jmp 0x391e2
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xabb8b(%rip), %rsi     # 0xe53f0
leaq 0xc109b(%rip), %rdx     # 0xfa907
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xab7ac(%rip), %rsi     # 0xe5034
leaq 0xc0fe3(%rip), %rdx     # 0xfa872
movq 0x10(%rsp), %rdi
movl $0x16a0, %ecx           # imm = 0x16A0
jmp 0x391e2