// File: /workspace/github_c_makefile_star2_O3/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)
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x3c(%rsp)
movzwl 0xd1a(%rsi), %ecx
movw %cx, 0x1a(%rsp)
movsd 0x1060(%rdx), %xmm0
movaps %xmm0, 0x70(%rsp)
movupd 0x48(%rsi), %xmm0
movapd %xmm0, 0x60(%rsp)
movw $0x0, 0xd1a(%rsi)
movq %rdx, 0x30(%rsp)
movl %eax, 0x1060(%rdx)
movslq 0x878(%rdi), %rbp
movl %ebp, 0x170(%r15)
leaq (,%rbp,8), %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x178(%r15)
testq %rax, %rax
je 0x3c494
movq %r12, 0x10(%rsp)
movq %r13, %rdi
callq 0x8460
testq %rax, %rax
je 0x3c4d4
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 0x8460
movq %rax, 0x180(%r15)
testq %rax, %rax
je 0x3c516
movq %r13, %rdi
callq 0x8460
movq %rax, 0x188(%r15)
testq %rax, %rax
je 0x3c558
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e98e
cmpl $0x1, %eax
jne 0x3c59a
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb1f95(%rip), %rsi     # 0xee3f0
leaq 0xc758e(%rip), %rdx     # 0x1039f0
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1bb6(%rip), %rsi     # 0xee034
leaq 0xc7525(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x164a, %ecx           # imm = 0x164A
jmp 0x3ca88
shll $0x3, %ebp
leaq 0xb1b66(%rip), %rsi     # 0xee004
leaq 0xc74f6(%rip), %rdx     # 0x10399b
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1b74(%rip), %rsi     # 0xee034
leaq 0xc74e3(%rip), %rdx     # 0x1039aa
movq %r12, %rdi
movl $0x1639, %ecx           # imm = 0x1639
jmp 0x3ca88
shll $0x3, %ebp
leaq 0xb1b26(%rip), %rsi     # 0xee004
leaq 0xebabe(%rip), %rdx     # 0x127fa3
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1b34(%rip), %rsi     # 0xee034
leaq 0xc74a3(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x163c, %ecx           # imm = 0x163C
jmp 0x3ca88
shll $0x4, %ebp
leaq 0xb1ae4(%rip), %rsi     # 0xee004
leaq 0xc7497(%rip), %rdx     # 0x1039be
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1af2(%rip), %rsi     # 0xee034
leaq 0xc7461(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1644, %ecx           # imm = 0x1644
jmp 0x3ca88
shll $0x4, %ebp
leaq 0xb1aa2(%rip), %rsi     # 0xee004
leaq 0xc746c(%rip), %rdx     # 0x1039d5
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1ab0(%rip), %rsi     # 0xee034
leaq 0xc741f(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1647, %ecx           # imm = 0x1647
jmp 0x3ca88
cmpl $0x0, 0x170(%r15)
jle 0x3c62e
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
movsd 0x870(%rbx), %xmm0
addsd 0xb1ca0(%rip), %xmm0    # 0xee260
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 0xb21f6(%rip), %xmm0    # 0xee7e8
movsd %xmm0, (%r12,%r13,8)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5c896
cmpl $0x1, %eax
je 0x3ca46
movsd 0x20(%rsp), %xmm0
movq 0x178(%r15), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
movslq 0x170(%r15), %rax
cmpq %rax, %r13
jl 0x3c5b0
movq %r14, %rdi
callq 0x61ff2
cmpl $0x1, %eax
jne 0x3c682
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb1da7(%rip), %rsi     # 0xee3f0
leaq 0xc73ef(%rip), %rdx     # 0x103a3f
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb19c8(%rip), %rsi     # 0xee034
leaq 0xc7337(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1656, %ecx           # imm = 0x1656
jmp 0x3ca88
movl 0x170(%r15), %ebp
testl %ebp, %ebp
jle 0x3c8f2
movq $0x0, 0x28(%rsp)
leaq 0xc73bb(%rip), %rdi     # 0x103a5c
cmpl $0x3, 0x1c(%rsp)
movq 0x28(%rsp), %rbp
jl 0x3c6ba
movsd (%r12,%rbp,8), %xmm0
movb $0x1, %al
callq 0x8030
movq %r12, %r13
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x48(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e98e
cmpl $0x1, %eax
movq 0x30(%rsp), %r12
je 0x3cc0b
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x67151
cmpl $0x1, %eax
je 0x3cc52
movq 0x178(%r15), %rax
movsd (%rax,%rbp,8), %xmm0
subsd 0xf38(%r12), %xmm0
movsd %xmm0, 0x50(%rsp)
movq $0x0, 0x50(%r14)
movq %r14, %rdi
callq 0x61ff2
cmpl $0x1, %eax
je 0x3caab
movq %r12, %rdi
callq 0x6b2ba
cmpl $0x1, %eax
je 0x3caef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e98e
cmpl $0x1, %eax
je 0x3cb36
movsd (%r13,%rbp,8), %xmm0
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x5c896
cmpl $0x1, %eax
je 0x3cb7d
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x67151
cmpl $0x1, %eax
je 0x3cbc4
movsd 0x20(%rsp), %xmm0
subsd 0xf38(%r12), %xmm0
divsd 0x50(%rsp), %xmm0
movsd 0xb1abd(%rip), %xmm1    # 0xee260
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, 0x40(%rsp)
movsd 0x48(%r14), %xmm0
movsd %xmm0, 0x58(%rsp)
movapd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xb2023(%rip), %xmm1    # 0xee7f0
callq 0x8620
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x48(%r14)
movapd 0x40(%rsp), %xmm1
andpd 0xb1a54(%rip), %xmm1    # 0xee240
ucomisd 0x880(%rbx), %xmm1
ja 0x3c71b
movq 0x180(%r15), %rax
movslq 0x16c(%r15), %rcx
movslq %ebp, %rdx
movq %rdx, 0x40(%rsp)
imulq %rdx, %rcx
movslq 0x164(%r15), %rdx
addq %rcx, %rdx
movsd %xmm0, (%rax,%rdx,8)
movslq 0x43c(%r14), %rax
movq %rax, %r12
leaq (,%rax,8), %rdi
callq 0x8460
testq %rax, %rax
je 0x3cc99
movq %rax, %rbp
movsd 0x20(%rsp), %xmm0
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
leaq 0x3c(%rsp), %rcx
movq %rax, %r8
callq 0x5c63f
cmpl $0x1, %eax
je 0x3cce2
movslq 0x40c(%r14), %rax
movsd (%rbp,%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)
movq %rbp, %rdi
callq 0x8410
movq %r14, %rdi
callq 0x61ff2
cmpl $0x1, %eax
je 0x3cd29
movq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x6b2ba
cmpl $0x1, %eax
movq 0x28(%rsp), %rax
je 0x3cd70
incq %rax
movslq 0x170(%r15), %rbp
movq %rax, 0x28(%rsp)
cmpq %rbp, %rax
movq %r13, %r12
leaq 0xc7170(%rip), %rdi     # 0x103a5c
jl 0x3c6a1
movzwl 0x1a(%rsp), %eax
movw %ax, 0xd1a(%r14)
movq 0x30(%rsp), %rax
movaps 0x70(%rsp), %xmm0
movss %xmm0, 0x1060(%rax)
movapd 0x60(%rsp), %xmm0
movupd %xmm0, 0x48(%r14)
cmpl $0x2, 0x1c(%rsp)
jl 0x3c9c9
movq 0x10c631(%rip), %r14    # 0x148f60
movq (%r14), %rcx
leaq 0xc71db(%rip), %rdi     # 0x103b14
movl $0x27, %esi
movl $0x1, %edx
callq 0x86d0
movl 0x170(%r15), %ebp
testl %ebp, %ebp
jle 0x3c9c9
movq %r12, %r13
xorl %r12d, %r12d
leaq 0xc71dc(%rip), %rbx     # 0x103b3c
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 0x84e0
incq %r12
movslq 0x170(%r15), %rbp
cmpq %rbp, %r12
jl 0x3c960
movq %r13, %r12
movq %r12, %rdi
callq 0x8410
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 0x142a8
cmpl $0x1, %eax
jne 0x3ca97
leaq 0xb19de(%rip), %rsi     # 0xee3f0
leaq 0xc714a(%rip), %rdx     # 0x103b63
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb15ff(%rip), %rsi     # 0xee034
leaq 0xc6f6e(%rip), %rdx     # 0x1039aa
movq %r14, %rdi
movl $0x16c6, %ecx           # imm = 0x16C6
jmp 0x3ca88
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb199c(%rip), %rsi     # 0xee3f0
leaq 0xc6fae(%rip), %rdx     # 0x103a09
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb15bd(%rip), %rsi     # 0xee034
leaq 0xc6f2c(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1651, %ecx           # imm = 0x1651
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %ebx
movl %ebx, %eax
addq $0x888, %rsp            # imm = 0x888
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb1937(%rip), %rsi     # 0xee3f0
leaq 0xc6f7f(%rip), %rdx     # 0x103a3f
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1558(%rip), %rsi     # 0xee034
leaq 0xc6ec7(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1676, %ecx           # imm = 0x1676
jmp 0x3ca88
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb18f3(%rip), %rsi     # 0xee3f0
leaq 0xc6fa6(%rip), %rdx     # 0x103aaa
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1514(%rip), %rsi     # 0xee034
leaq 0xc6e83(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1679, %ecx           # imm = 0x1679
jmp 0x3ca88
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb18ac(%rip), %rsi     # 0xee3f0
leaq 0xc6ea5(%rip), %rdx     # 0x1039f0
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb14cd(%rip), %rsi     # 0xee034
leaq 0xc6e3c(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x167d, %ecx           # imm = 0x167D
jmp 0x3ca88
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb1865(%rip), %rsi     # 0xee3f0
leaq 0xc6e77(%rip), %rdx     # 0x103a09
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1486(%rip), %rsi     # 0xee034
leaq 0xc6df5(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1682, %ecx           # imm = 0x1682
jmp 0x3ca88
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb181e(%rip), %rsi     # 0xee3f0
leaq 0xc6eb0(%rip), %rdx     # 0x103a89
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb143f(%rip), %rsi     # 0xee034
leaq 0xc6dae(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x1685, %ecx           # imm = 0x1685
jmp 0x3ca88
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb17d7(%rip), %rsi     # 0xee3f0
leaq 0xc6dd0(%rip), %rdx     # 0x1039f0
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb13f8(%rip), %rsi     # 0xee034
leaq 0xc6d67(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x166b, %ecx           # imm = 0x166B
jmp 0x3ca88
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb1790(%rip), %rsi     # 0xee3f0
leaq 0xc6e22(%rip), %rdx     # 0x103a89
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb13b1(%rip), %rsi     # 0xee034
leaq 0xc6d20(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x166e, %ecx           # imm = 0x166E
jmp 0x3ca88
shll $0x3, %r12d
leaq 0xb1360(%rip), %rsi     # 0xee004
leaq 0xd85e7(%rip), %rdx     # 0x115292
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb1366(%rip), %rsi     # 0xee034
leaq 0xc6cd5(%rip), %rdx     # 0x1039aa
movq %r14, %rdi
movl $0x1693, %ecx           # imm = 0x1693
jmp 0x3ca88
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb1700(%rip), %rsi     # 0xee3f0
leaq 0xc6dcc(%rip), %rdx     # 0x103ac3
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1321(%rip), %rsi     # 0xee034
leaq 0xc6c90(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x169a, %ecx           # imm = 0x169A
jmp 0x3ca88
addq $0xd1c, %r14            # imm = 0xD1C
leaq 0xb16b9(%rip), %rsi     # 0xee3f0
leaq 0xc6d01(%rip), %rdx     # 0x103a3f
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb12da(%rip), %rsi     # 0xee034
leaq 0xc6c49(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x16a0, %ecx           # imm = 0x16A0
jmp 0x3ca88
addq $0x1064, %r12           # imm = 0x1064
leaq 0xb1672(%rip), %rsi     # 0xee3f0
leaq 0xc6d25(%rip), %rdx     # 0x103aaa
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xb1293(%rip), %rsi     # 0xee034
leaq 0xc6c02(%rip), %rdx     # 0x1039aa
movq 0x10(%rsp), %rdi
movl $0x16a3, %ecx           # imm = 0x16A3
jmp 0x3ca88