// File: /workspace/github_c_makefile_star2_O1/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 $0x878, %rsp            # imm = 0x878
movq %r9, %r12
movl %r8d, 0x14(%rsp)
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x24(%rsp)
movzwl 0xd1a(%rsi), %ecx
movw %cx, 0x12(%rsp)
movsd 0x1060(%rdx), %xmm0
movaps %xmm0, 0x60(%rsp)
movupd 0x48(%rsi), %xmm0
movapd %xmm0, 0x50(%rsp)
movw $0x0, 0xd1a(%rsi)
movq %rdx, 0x28(%rsp)
movl %eax, 0x1060(%rdx)
movslq 0x878(%rdi), %r13
movl %r13d, 0x170(%r15)
leaq (,%r13,8), %rbp
movq %rbp, %rdi
callq 0x8460
movq %rax, 0x178(%r15)
testq %rax, %rax
je 0x3d980
movq %r12, 0x8(%rsp)
movq %rbp, %rdi
callq 0x8460
testq %rax, %rax
je 0x3d9c0
movq %rax, %r12
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x164(%r15)
movl $0x2, 0x16c(%r15)
movq %r13, %rbp
shlq $0x4, %rbp
movq %rbp, %rdi
callq 0x8460
movq %rax, 0x180(%r15)
testq %rax, %rax
je 0x3da01
movq %rbp, %rdi
callq 0x8460
movq %rax, 0x188(%r15)
testq %rax, %rax
je 0x3da42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61036
cmpl $0x1, %eax
jne 0x3da83
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb3aa6(%rip), %rsi     # 0xf13f0
leaq 0xc9077(%rip), %rdx     # 0x1069c8
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb36ca(%rip), %rsi     # 0xf1034
leaq 0xc9011(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x164a, %ecx           # imm = 0x164A
jmp 0x3df43
leal (,%r13,8), %ecx
leaq 0xb3675(%rip), %rsi     # 0xf1004
leaq 0xc8fdd(%rip), %rdx     # 0x106973
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0xb3688(%rip), %rsi     # 0xf1034
leaq 0xc8fcf(%rip), %rdx     # 0x106982
movq %r12, %rdi
movl $0x1639, %ecx           # imm = 0x1639
jmp 0x3df43
shll $0x3, %r13d
leaq 0xb3639(%rip), %rsi     # 0xf1004
leaq 0xed5a9(%rip), %rdx     # 0x12af7b
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb3649(%rip), %rsi     # 0xf1034
leaq 0xc8f90(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x163c, %ecx           # imm = 0x163C
jmp 0x3df43
shll $0x4, %r13d
leaq 0xb35f8(%rip), %rsi     # 0xf1004
leaq 0xc8f83(%rip), %rdx     # 0x106996
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb3608(%rip), %rsi     # 0xf1034
leaq 0xc8f4f(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1644, %ecx           # imm = 0x1644
jmp 0x3df43
shll $0x4, %r13d
leaq 0xb35b7(%rip), %rsi     # 0xf1004
leaq 0xc8f59(%rip), %rdx     # 0x1069ad
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb35c7(%rip), %rsi     # 0xf1034
leaq 0xc8f0e(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1647, %ecx           # imm = 0x1647
jmp 0x3df43
cmpl $0x0, 0x170(%r15)
jle 0x3db17
xorl %r13d, %r13d
leaq 0x18(%rsp), %rbp
movsd 0x870(%rbx), %xmm0
addsd 0xb37b7(%rip), %xmm0    # 0xf1260
callq 0x82c0
movl 0x170(%r15), %eax
decl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
mulsd %xmm1, %xmm0
callq 0x8670
addsd 0xb3d0d(%rip), %xmm0    # 0xf17e8
movsd %xmm0, (%r12,%r13,8)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5efb7
cmpl $0x1, %eax
je 0x3df04
movsd 0x18(%rsp), %xmm0
movq 0x178(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
movslq 0x170(%r15), %rax
cmpq %rax, %r13
jl 0x3da99
movq %r14, %rdi
callq 0x6476b
cmpl $0x1, %eax
jne 0x3db68
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb38be(%rip), %rsi     # 0xf13f0
leaq 0xc8ede(%rip), %rdx     # 0x106a17
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb34e2(%rip), %rsi     # 0xf1034
leaq 0xc8e29(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1656, %ecx           # imm = 0x1656
jmp 0x3df43
movq %r12, %rbp
cmpl $0x0, 0x170(%r15)
movq 0x28(%rsp), %r12
jle 0x3ddb8
xorl %r13d, %r13d
cmpl $0x3, 0x14(%rsp)
jl 0x3db9d
movsd (%rbp,%r13,8), %xmm0
leaq 0xc8e9e(%rip), %rdi     # 0x106a34
movb $0x1, %al
callq 0x8030
movaps 0x50(%rsp), %xmm0
movups %xmm0, 0x48(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61036
cmpl $0x1, %eax
je 0x3e0b7
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x69a95
cmpl $0x1, %eax
je 0x3e0fb
movq 0x178(%r15), %rax
movsd (%rax,%r13,8), %xmm0
subsd 0xf38(%r12), %xmm0
movsd %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%r14)
movq %r14, %rdi
callq 0x6476b
cmpl $0x1, %eax
je 0x3df66
movq %r12, %rdi
callq 0x6dc22
cmpl $0x1, %eax
je 0x3dfa7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61036
cmpl $0x1, %eax
je 0x3dfeb
movsd (%rbp,%r13,8), %xmm0
movq %r14, %rdi
leaq 0x18(%rsp), %rsi
callq 0x5efb7
cmpl $0x1, %eax
je 0x3e02f
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x69a95
cmpl $0x1, %eax
je 0x3e073
movsd 0x18(%rsp), %xmm0
subsd 0xf38(%r12), %xmm0
divsd 0x40(%rsp), %xmm0
movsd 0xb35e1(%rip), %xmm1    # 0xf1260
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, 0x30(%rsp)
movsd 0x48(%r14), %xmm0
movsd %xmm0, 0x48(%rsp)
movapd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xb3b47(%rip), %xmm1    # 0xf17f0
callq 0x8620
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%r14)
movapd 0x30(%rsp), %xmm1
andpd 0xb3578(%rip), %xmm1    # 0xf1240
ucomisd 0x880(%rbx), %xmm1
ja 0x3dbf7
movq 0x180(%r15), %rax
movslq 0x16c(%r15), %rcx
movslq %r13d, %rdx
imulq %rcx, %rdx
movslq 0x164(%r15), %rcx
addq %rdx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movslq 0x43c(%r14), %rax
movq %rax, 0x30(%rsp)
leaq (,%rax,8), %rdi
callq 0x8460
testq %rax, %rax
je 0x3e13f
movq %rax, %r12
movsd 0x18(%rsp), %xmm0
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
leaq 0x24(%rsp), %rcx
movq %rax, %r8
callq 0x5ed53
cmpl $0x1, %eax
je 0x3e186
movslq 0x40c(%r14), %rax
movsd (%r12,%rax,8), %xmm0
movq 0x180(%r15), %rax
movslq 0x16c(%r15), %rcx
movslq %r13d, %rdx
imulq %rcx, %rdx
movslq 0x168(%r15), %rcx
addq %rdx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq %r12, %rdi
callq 0x8410
movq %r14, %rdi
callq 0x6476b
cmpl $0x1, %eax
je 0x3e1ca
movq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x6dc22
cmpl $0x1, %eax
je 0x3e20e
incq %r13
movslq 0x170(%r15), %rax
cmpq %rax, %r13
jl 0x3db81
movzwl 0x12(%rsp), %eax
movw %ax, 0xd1a(%r14)
movaps 0x60(%rsp), %xmm0
movss %xmm0, 0x1060(%r12)
movapd 0x50(%rsp), %xmm0
movupd %xmm0, 0x48(%r14)
cmpl $0x2, 0x14(%rsp)
jl 0x3de85
movq 0x10e14e(%rip), %r14    # 0x14bf40
movq (%r14), %rcx
leaq 0xc8cf0(%rip), %rdi     # 0x106aec
movl $0x27, %esi
movl $0x1, %edx
callq 0x86d0
cmpl $0x0, 0x170(%r15)
jle 0x3de85
xorl %r12d, %r12d
leaq 0xc8cf5(%rip), %rbx     # 0x106b14
movq (%r14), %rdi
movsd (%rbp,%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 0x84e0
incq %r12
movslq 0x170(%r15), %rax
cmpq %rax, %r12
jl 0x3de1f
movq %rbp, %rdi
callq 0x8410
movq 0x178(%r15), %rdi
movl 0x16c(%r15), %ecx
movl 0x170(%r15), %esi
movq 0x180(%r15), %rdx
movq 0x188(%r15), %r8
movq 0x8(%rsp), %r14
movq %r14, (%rsp)
xorl %ebx, %ebx
xorl %r9d, %r9d
callq 0x14191
cmpl $0x1, %eax
jne 0x3df52
leaq 0xb351d(%rip), %rsi     # 0xf13f0
leaq 0xc8c61(%rip), %rdx     # 0x106b3b
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb3141(%rip), %rsi     # 0xf1034
leaq 0xc8a88(%rip), %rdx     # 0x106982
movq %r14, %rdi
movl $0x16c6, %ecx           # imm = 0x16C6
jmp 0x3df43
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb34de(%rip), %rsi     # 0xf13f0
leaq 0xc8ac8(%rip), %rdx     # 0x1069e1
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb3102(%rip), %rsi     # 0xf1034
leaq 0xc8a49(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1651, %ecx           # imm = 0x1651
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebx
movl %ebx, %eax
addq $0x878, %rsp            # imm = 0x878
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb347c(%rip), %rsi     # 0xf13f0
leaq 0xc8a9c(%rip), %rdx     # 0x106a17
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb30a0(%rip), %rsi     # 0xf1034
leaq 0xc89e7(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1676, %ecx           # imm = 0x1676
jmp 0x3df43
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb343b(%rip), %rsi     # 0xf13f0
leaq 0xc8ac6(%rip), %rdx     # 0x106a82
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb305f(%rip), %rsi     # 0xf1034
leaq 0xc89a6(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1679, %ecx           # imm = 0x1679
jmp 0x3df43
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb33f7(%rip), %rsi     # 0xf13f0
leaq 0xc89c8(%rip), %rdx     # 0x1069c8
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb301b(%rip), %rsi     # 0xf1034
leaq 0xc8962(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x167d, %ecx           # imm = 0x167D
jmp 0x3df43
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb33b3(%rip), %rsi     # 0xf13f0
leaq 0xc899d(%rip), %rdx     # 0x1069e1
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb2fd7(%rip), %rsi     # 0xf1034
leaq 0xc891e(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1682, %ecx           # imm = 0x1682
jmp 0x3df43
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb336f(%rip), %rsi     # 0xf13f0
leaq 0xc89d9(%rip), %rdx     # 0x106a61
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb2f93(%rip), %rsi     # 0xf1034
leaq 0xc88da(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x1685, %ecx           # imm = 0x1685
jmp 0x3df43
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb332b(%rip), %rsi     # 0xf13f0
leaq 0xc88fc(%rip), %rdx     # 0x1069c8
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb2f4f(%rip), %rsi     # 0xf1034
leaq 0xc8896(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x166b, %ecx           # imm = 0x166B
jmp 0x3df43
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb32e7(%rip), %rsi     # 0xf13f0
leaq 0xc8951(%rip), %rdx     # 0x106a61
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb2f0b(%rip), %rsi     # 0xf1034
leaq 0xc8852(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x166e, %ecx           # imm = 0x166E
jmp 0x3df43
movq 0x30(%rsp), %rcx
shll $0x3, %ecx
leaq 0xb2eb6(%rip), %rsi     # 0xf1004
leaq 0xda0fd(%rip), %rdx     # 0x118252
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb2ec2(%rip), %rsi     # 0xf1034
leaq 0xc8809(%rip), %rdx     # 0x106982
movq %r14, %rdi
movl $0x1693, %ecx           # imm = 0x1693
jmp 0x3df43
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb325c(%rip), %rsi     # 0xf13f0
leaq 0xc8900(%rip), %rdx     # 0x106a9b
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb2e80(%rip), %rsi     # 0xf1034
leaq 0xc87c7(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x169a, %ecx           # imm = 0x169A
jmp 0x3df43
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb3218(%rip), %rsi     # 0xf13f0
leaq 0xc8838(%rip), %rdx     # 0x106a17
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb2e3c(%rip), %rsi     # 0xf1034
leaq 0xc8783(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x16a0, %ecx           # imm = 0x16A0
jmp 0x3df43
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb31d4(%rip), %rsi     # 0xf13f0
leaq 0xc885f(%rip), %rdx     # 0x106a82
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xb2df8(%rip), %rsi     # 0xf1034
leaq 0xc873f(%rip), %rdx     # 0x106982
movq 0x8(%rsp), %rdi
movl $0x16a3, %ecx           # imm = 0x16A3
jmp 0x3df43