// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/fourier.c
// Function: fourier_indices
int fourier_indices(
                    struct precision *ppr,
                    struct background *pba,
                    struct perturbations * ppt,
                    struct primordial * ppm,
                    struct fourier * pfo
                    ) {

  int index_ic1_ic2;
  int index_pk;

  /** - define indices for initial conditions (and allocate related arrays) */
  pfo->index_md_scalars = ppt->index_md_scalars;
  pfo->ic_size = ppm->ic_size[pfo->index_md_scalars];
  pfo->ic_ic_size = ppm->ic_ic_size[pfo->index_md_scalars];
  class_alloc(pfo->is_non_zero,sizeof(short)*pfo->ic_ic_size,pfo->error_message);
  for (index_ic1_ic2=0; index_ic1_ic2 < pfo->ic_ic_size; index_ic1_ic2++)
    pfo->is_non_zero[index_ic1_ic2] = ppm->is_non_zero[pfo->index_md_scalars][index_ic1_ic2];

  /** - define flags indices for pk types (_m, _cb). Note: due to some
      dependencies in HMcode, when pfo->index_pk_cb exists, it must
      come first (e.g. the calculation of the non-linear P_m depends on
      sigma_cb so the cb-related quantitites must be evaluated
      first) */

  pfo->has_pk_m = _TRUE_;
  if (pba->has_ncdm == _TRUE_) {
    pfo->has_pk_cb = _TRUE_;
  }
  else {
    pfo->has_pk_cb = _FALSE_;
  }

  index_pk = 0;
  class_define_index(pfo->index_pk_cb, pfo->has_pk_cb, index_pk,1);
  class_define_index(pfo->index_pk_m, pfo->has_pk_m, index_pk,1);
  pfo->pk_size = index_pk;

  /* and two redundent but useful indices: */

  if (pfo->has_pk_cb == _TRUE_) {
    pfo->index_pk_total = pfo->index_pk_m;
    pfo->index_pk_cluster = pfo->index_pk_cb;
  }
  else {
    pfo->index_pk_total = pfo->index_pk_m;
    pfo->index_pk_cluster = pfo->index_pk_m;
  }

  /** - get list of k values */

  class_call(fourier_get_k_list(ppr,ppm,ppt,pfo),
             pfo->error_message,
             pfo->error_message);

  /** - get list of tau values */

  class_call(fourier_get_tau_list(ppt,pfo),
             pfo->error_message,
             pfo->error_message);

  /** - given previous indices, we can allocate the array of linear power spectrum values */

  class_alloc(pfo->ln_pk_ic_l,pfo->pk_size*sizeof(double*),pfo->error_message);
  class_alloc(pfo->ln_pk_l   ,pfo->pk_size*sizeof(double*),pfo->error_message);
  class_alloc(pfo->ln_pk_l_extra,pfo->pk_size*sizeof(double*),pfo->error_message);

  for (index_pk=0; index_pk<pfo->pk_size; index_pk++) {
    class_alloc(pfo->ln_pk_ic_l[index_pk],pfo->ln_tau_size*pfo->k_size*pfo->ic_ic_size*sizeof(double*),pfo->error_message);
    class_alloc(pfo->ln_pk_l[index_pk]   ,pfo->ln_tau_size*pfo->k_size*sizeof(double*),pfo->error_message);
    class_alloc(pfo->ln_pk_l_extra[index_pk],pfo->ln_tau_size*pfo->k_size_extra*sizeof(double),pfo->error_message);
  }

  /** - do we we want to compute and store the analytic_nowiggle power
        spectrum? This flag was already set by the user in input.c. If
        we need HMcode, overwrite the user request and compute
        it. Will soon do the same for Oneloop. */

  if ((pfo->method == nl_HMcode) || (pfo->has_pk_numerical_nowiggle == _TRUE_)) {
    pfo->has_pk_analytic_nowiggle = _TRUE_;
  }

  if (pfo->has_pk_analytic_nowiggle == _TRUE_) {
    class_alloc(pfo->ln_pk_l_an_extra,pfo->k_size_extra*sizeof(double),pfo->error_message);
    class_alloc(pfo->ddln_pk_l_an_extra,pfo->k_size_extra*sizeof(double),pfo->error_message);
  }

  /** - if interpolation of \f$P(k,\tau)\f$ will be needed (as a function of tau),
      compute also the array of second derivatives in view of spline interpolation */

  if (pfo->ln_tau_size > 1) {

    class_alloc(pfo->ddln_pk_ic_l,pfo->pk_size*sizeof(double*),pfo->error_message);
    class_alloc(pfo->ddln_pk_l   ,pfo->pk_size*sizeof(double*),pfo->error_message);
    class_alloc(pfo->ddln_pk_l_extra,pfo->pk_size*sizeof(double*),pfo->error_message);

    for (index_pk=0; index_pk<pfo->pk_size; index_pk++) {
      class_alloc(pfo->ddln_pk_ic_l[index_pk],pfo->ln_tau_size*pfo->k_size*pfo->ic_ic_size*sizeof(double*),pfo->error_message);
      class_alloc(pfo->ddln_pk_l[index_pk]   ,pfo->ln_tau_size*pfo->k_size*sizeof(double*),pfo->error_message);
      class_alloc(pfo->ddln_pk_l_extra[index_pk],pfo->ln_tau_size*pfo->k_size_extra*sizeof(double),pfo->error_message);
    }
  }

  /** - array of sigma8 values */

  class_alloc(pfo->sigma8,pfo->pk_size*sizeof(double*),pfo->error_message);

  /** - if non-linear computations needed, allocate array of
      non-linear correction ratio R_nl(k,z), k_nl(z) and P_nl(k,z)
      for each P(k) type */

  if (pfo->method > nl_none) {

    class_alloc(pfo->k_nl,
                pfo->pk_size*sizeof(double *),
                pfo->error_message);

    class_alloc(pfo->nl_corr_density,
                pfo->pk_size*sizeof(double *),
                pfo->error_message);

    class_alloc(pfo->ln_pk_nl,pfo->pk_size*sizeof(double*),pfo->error_message);
    if (pfo->ln_tau_size > 1)
      class_alloc(pfo->ddln_pk_nl,pfo->pk_size*sizeof(double*),pfo->error_message);

    for (index_pk=0; index_pk<pfo->pk_size; index_pk++){
      class_alloc(pfo->k_nl[index_pk],pfo->tau_size*sizeof(double),pfo->error_message);
      class_alloc(pfo->nl_corr_density[index_pk],pfo->tau_size*pfo->k_size*sizeof(double),pfo->error_message);
      class_alloc(pfo->ln_pk_nl[index_pk],pfo->ln_tau_size*pfo->k_size*sizeof(double*),pfo->error_message);
      if (pfo->ln_tau_size > 1)
        class_alloc(pfo->ddln_pk_nl[index_pk],pfo->ln_tau_size*pfo->k_size*sizeof(double*),pfo->error_message);
    }
  }

  /** - allocate arrays for P_nw(k,z) and its splines in log(tau) */

  if (pfo->has_pk_numerical_nowiggle == _TRUE_) {
    class_alloc(pfo->ln_pk_l_nw_extra, pfo->ln_tau_size*pfo->k_size_extra*sizeof(double), pfo->error_message);

    if (pfo->ln_tau_size > 1)
      class_alloc(pfo->ddln_pk_l_nw_extra, pfo->ln_tau_size*pfo->k_size_extra*sizeof(double), pfo->error_message);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
movslq 0x848(%rdx), %rbx
movl %ebx, 0x3c(%r8)
movq 0x280(%rcx), %rax
movl (%rax,%rbx,4), %eax
movl %eax, 0x40(%r8)
movq 0x288(%rcx), %rax
movslq (%rax,%rbx,4), %r13
movl %r13d, 0x44(%r8)
leaq (,%r13,2), %rdi
callq 0x8460
movq %rax, 0x48(%r12)
testq %rax, %rax
je 0xa1b91
testl %r13d, %r13d
jle 0xa1b63
movq 0x2b0(%r15), %rcx
movq (%rcx,%rbx,8), %rcx
xorl %edx, %edx
movzwl (%rcx,%rdx,2), %esi
movw %si, (%rax,%rdx,2)
incq %rdx
cmpq %rdx, %r13
jne 0xa1b53
movq %r12, %rbx
movw $0x1, 0x50(%r12)
cmpw $0x1, 0x4be(%rbp)
jne 0xa1bd6
movw $0x1, 0x52(%rbx)
movl $0x0, 0x58(%rbx)
movl $0x2, %eax
movl $0x1, %ecx
jmp 0xa1be3
addl %r13d, %r13d
leaq 0x4c469(%rip), %rsi     # 0xee004
leaq 0x7bb47(%rip), %rdx     # 0x11d6e9
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %r12            # imm = 0x192
leaq 0x4c472(%rip), %rsi     # 0xee034
leaq 0x7bb31(%rip), %rdx     # 0x11d6fa
movq %r12, %rdi
movl $0x7ca, %ecx            # imm = 0x7CA
jmp 0xa1c95
movw $0x0, 0x52(%rbx)
movl $0x1, %eax
xorl %ecx, %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x54(%rbx)
movl %eax, 0x64(%rbx)
movl %ecx, 0x5c(%rbx)
movl $0x0, 0x60(%rbx)
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa33cb
testl %eax, %eax
je 0xa1c49
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c7d8(%rip), %rsi     # 0xee3f0
leaq 0x7baeb(%rip), %rdx     # 0x11d70a
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4c3fc(%rip), %rsi     # 0xee034
leaq 0x7babb(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x7f0, %ecx            # imm = 0x7F0
jmp 0xa1c95
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa37cf
testl %eax, %eax
je 0xa1cb8
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c78a(%rip), %rsi     # 0xee3f0
leaq 0x7bac1(%rip), %rdx     # 0x11d72e
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4c3ae(%rip), %rsi     # 0xee034
leaq 0x7ba6d(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x7f6, %ecx            # imm = 0x7F6
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %ebp
movl %ebp, %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq 0x64(%rbx), %rbp
leaq (,%rbp,8), %r14
movq %r14, %rdi
callq 0x8460
movq %rax, 0x98(%rbx)
testq %rax, %rax
je 0xa1e81
movq %r14, %rdi
callq 0x8460
movq %rax, 0xa8(%rbx)
testq %rax, %rax
je 0xa1ec7
movq %r14, %rdi
callq 0x8460
movq %rax, 0x108(%rbx)
testq %rax, %rax
je 0xa1f0e
movq %r14, 0x18(%rsp)
testl %ebp, %ebp
jle 0xa1de0
movslq 0x90(%rbx), %rax
movslq 0x6c(%rbx), %r13
movq %rax, 0x8(%rsp)
imulq %rax, %r13
movslq 0x44(%rbx), %rax
movslq %r13d, %r12
imulq %rax, %r12
movq %r12, 0x10(%rsp)
shlq $0x3, %r12
movq %r13, 0x20(%rsp)
shlq $0x3, %r13
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x8460
movq 0x98(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x98(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0xa1f9a
movq %r13, %rdi
callq 0x8460
movq 0xa8(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0xa8(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0xa1fe5
movq %rbp, %r14
movslq 0x104(%rbx), %rbp
imulq 0x8(%rsp), %rbp
leaq (,%rbp,8), %rdi
callq 0x8460
movq 0x108(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x108(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0xa2030
incq %r15
movq %r14, %rbp
cmpq %r15, %r14
jne 0xa1d4d
movl (%rbx), %r13d
cmpl $0x2, %r13d
je 0xa1df4
cmpw $0x1, 0x3a(%rbx)
jne 0xa2074
movw $0x1, 0x38(%rbx)
movq %rbx, %r15
movslq 0x104(%r15), %rbx
movq %rbx, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x8460
movq %rax, 0x118(%r15)
testq %rax, %rax
je 0xa1f54
movq %r12, %rdi
callq 0x8460
movq %rax, 0x120(%r15)
testq %rax, %rax
jne 0xa2082
leal (,%rbx,8), %ecx
leaq 0x4c1bb(%rip), %rsi     # 0xee004
leaq 0x7b990(%rip), %rdx     # 0x11d7e0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %r15            # imm = 0x192
leaq 0x4c1c7(%rip), %rsi     # 0xee034
leaq 0x7b886(%rip), %rdx     # 0x11d6fa
movq %r15, %rdi
movl $0x80f, %ecx            # imm = 0x80F
jmp 0xa1c95
leal (,%rbp,8), %ecx
leaq 0x4c175(%rip), %rsi     # 0xee004
leaq 0x7b8b6(%rip), %rdx     # 0x11d74c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c181(%rip), %rsi     # 0xee034
leaq 0x7b840(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x7fa, %ecx            # imm = 0x7FA
jmp 0xa1c95
shll $0x3, %ebp
leaq 0x4c133(%rip), %rsi     # 0xee004
leaq 0x7b884(%rip), %rdx     # 0x11d75c
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c13d(%rip), %rsi     # 0xee034
leaq 0x7b7fc(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x7fb, %ecx            # imm = 0x7FB
movq %r15, %r8
jmp 0xa1c98
leal (,%rbp,8), %ecx
leaq 0x4c0e8(%rip), %rsi     # 0xee004
leaq 0x7b846(%rip), %rdx     # 0x11d769
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c0f4(%rip), %rsi     # 0xee034
leaq 0x7b7b3(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x7fc, %ecx            # imm = 0x7FC
jmp 0xa1c95
leal (,%rbx,8), %ecx
leaq 0x4c0a2(%rip), %rsi     # 0xee004
leaq 0x7b861(%rip), %rdx     # 0x11d7ca
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %r15            # imm = 0x192
leaq 0x4c0ae(%rip), %rsi     # 0xee034
leaq 0x7b76d(%rip), %rdx     # 0x11d6fa
movq %r15, %rdi
movl $0x80e, %ecx            # imm = 0x80E
jmp 0xa1c95
movq 0x10(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4c057(%rip), %rsi     # 0xee004
leaq 0x7b7c8(%rip), %rdx     # 0x11d77c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c063(%rip), %rsi     # 0xee034
leaq 0x7b722(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x7ff, %ecx            # imm = 0x7FF
jmp 0xa1c95
movq 0x20(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4c00c(%rip), %rsi     # 0xee004
leaq 0x7b797(%rip), %rdx     # 0x11d796
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c018(%rip), %rsi     # 0xee034
leaq 0x7b6d7(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x800, %ecx            # imm = 0x800
jmp 0xa1c95
shll $0x3, %ebp
leaq 0x4bfca(%rip), %rsi     # 0xee004
leaq 0x7b76c(%rip), %rdx     # 0x11d7ad
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bfd4(%rip), %rsi     # 0xee034
leaq 0x7b693(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x801, %ecx            # imm = 0x801
jmp 0xa1c95
cmpw $0x1, 0x38(%rbx)
movq %rbx, %r15
je 0xa1dfd
movslq 0x90(%r15), %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x2, %rcx
movq %r15, %rbx
jl 0xa21b4
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x8460
movq %rax, 0xa0(%rbx)
testq %rax, %rax
je 0xa241a
movq %r14, %rdi
callq 0x8460
movq %rax, 0xb0(%rbx)
testq %rax, %rax
je 0xa2460
movq %r14, %rdi
callq 0x8460
movq %rax, 0x110(%rbx)
testq %rax, %rax
je 0xa24e8
testl %ebp, %ebp
jle 0xa21b4
movslq 0x6c(%rbx), %r12
imulq 0x8(%rsp), %r12
movslq 0x44(%rbx), %rax
movslq %r12d, %rcx
imulq %rax, %rcx
movq %rcx, 0x20(%rsp)
shlq $0x3, %rcx
movq %rcx, 0x10(%rsp)
movq %r12, 0x28(%rsp)
shlq $0x3, %r12
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
callq 0x8460
movq 0xa0(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0xa0(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0xa2601
movq %rbp, %r14
movq %r12, %rdi
callq 0x8460
movq 0xb0(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0xb0(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0xa264c
movslq 0x104(%rbx), %rbp
imulq 0x8(%rsp), %rbp
leaq (,%rbp,8), %rdi
callq 0x8460
movq 0x110(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x110(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0xa2697
incq %r15
movq %r14, %rbp
cmpq %r15, %r14
jne 0xa211f
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x8460
movq %rax, 0xc8(%rbx)
testq %rax, %rax
je 0xa23d4
testl %r13d, %r13d
je 0xa232f
movq %r14, %rdi
callq 0x8460
movq %rax, 0x158(%rbx)
testq %rax, %rax
je 0xa24a4
movq %r14, %rdi
callq 0x8460
movq %rax, 0x150(%rbx)
testq %rax, %rax
je 0xa252e
movq %r14, %rdi
callq 0x8460
movq %rax, 0xb8(%rbx)
testq %rax, %rax
je 0xa2574
cmpl $0x2, 0x8(%rsp)
jl 0xa2241
movq %r14, %rdi
callq 0x8460
movq %rax, 0xc0(%rbx)
testq %rax, %rax
je 0xa26db
testl %ebp, %ebp
jle 0xa232f
movslq 0x140(%rbx), %rcx
movq %rcx, 0x18(%rsp)
shlq $0x3, %rcx
movq %rcx, 0x10(%rsp)
xorl %r13d, %r13d
movq 0x8(%rsp), %r15
movq %rbp, %r14
movq 0x10(%rsp), %rdi
callq 0x8460
movq 0x158(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x158(%rbx), %rax
cmpq $0x0, (%rax,%r13,8)
je 0xa271f
movl 0x6c(%rbx), %ebp
movl %ebp, %r12d
imull 0x18(%rsp), %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x8460
movq 0x150(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x150(%rbx), %rax
cmpq $0x0, (%rax,%r13,8)
je 0xa276a
imull %r15d, %ebp
movslq %ebp, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x8460
movq 0xb8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0xb8(%rbx), %rax
cmpq $0x0, (%rax,%r13,8)
je 0xa27b0
cmpl $0x2, %r15d
jl 0xa2320
movq %r12, %rdi
callq 0x8460
movq 0xc0(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0xc0(%rbx), %rax
cmpq $0x0, (%rax,%r13,8)
je 0xa27f4
incq %r13
movq %r14, %rbp
cmpq %r13, %r14
jne 0xa2266
xorl %ebp, %ebp
cmpw $0x1, 0x3a(%rbx)
jne 0xa1ca4
movslq 0x104(%rbx), %r15
movq 0x8(%rsp), %r12
imulq %r12, %r15
movq %r15, %r14
shlq $0x3, %r14
movq %r14, %rdi
callq 0x8460
movq %rax, 0x130(%rbx)
testq %rax, %rax
je 0xa25ba
cmpl $0x2, %r12d
jl 0xa1ca4
movq %r14, %rdi
callq 0x8460
movq %rax, 0x138(%rbx)
testq %rax, %rax
jne 0xa1ca4
leal (,%r15,8), %ecx
leaq 0x4bc68(%rip), %rsi     # 0xee004
leaq 0x7b5a3(%rip), %rdx     # 0x11d946
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bc74(%rip), %rsi     # 0xee034
leaq 0x7b333(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x847, %ecx            # imm = 0x847
jmp 0xa1c95
leal (,%rbp,8), %ecx
leaq 0x4bc22(%rip), %rsi     # 0xee004
leaq 0x7b499(%rip), %rdx     # 0x11d882
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bc2e(%rip), %rsi     # 0xee034
leaq 0x7b2ed(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x824, %ecx            # imm = 0x824
jmp 0xa1c95
leal (,%rbp,8), %ecx
leaq 0x4bbdc(%rip), %rsi     # 0xee004
leaq 0x7b3c9(%rip), %rdx     # 0x11d7f8
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bbe8(%rip), %rsi     # 0xee034
leaq 0x7b2a7(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x817, %ecx            # imm = 0x817
jmp 0xa1c95
shll $0x3, %ebp
leaq 0x4bb9a(%rip), %rsi     # 0xee004
leaq 0x7b399(%rip), %rdx     # 0x11d80a
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bba4(%rip), %rsi     # 0xee034
leaq 0x7b263(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x818, %ecx            # imm = 0x818
jmp 0xa1f06
shll $0x3, %ebp
leaq 0x4bb56(%rip), %rsi     # 0xee004
leaq 0x7b3d9(%rip), %rdx     # 0x11d88e
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bb60(%rip), %rsi     # 0xee034
leaq 0x7b21f(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x82e, %ecx            # imm = 0x82E
jmp 0xa1f06
leal (,%rbp,8), %ecx
leaq 0x4bb0e(%rip), %rsi     # 0xee004
leaq 0x7b31c(%rip), %rdx     # 0x11d819
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bb1a(%rip), %rsi     # 0xee034
leaq 0x7b1d9(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x819, %ecx            # imm = 0x819
jmp 0xa1c95
leal (,%rbp,8), %ecx
leaq 0x4bac8(%rip), %rsi     # 0xee004
leaq 0x7b355(%rip), %rdx     # 0x11d898
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bad4(%rip), %rsi     # 0xee034
leaq 0x7b193(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x832, %ecx            # imm = 0x832
jmp 0xa1c95
leal (,%rbp,8), %ecx
leaq 0x4ba82(%rip), %rsi     # 0xee004
leaq 0x7b324(%rip), %rdx     # 0x11d8ad
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4ba8e(%rip), %rsi     # 0xee034
leaq 0x7b14d(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x834, %ecx            # imm = 0x834
jmp 0xa1c95
leal (,%r15,8), %ecx
leaq 0x4ba3b(%rip), %rsi     # 0xee004
leaq 0x7b360(%rip), %rdx     # 0x11d930
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4ba47(%rip), %rsi     # 0xee034
leaq 0x7b106(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x844, %ecx            # imm = 0x844
jmp 0xa1c95
movq 0x20(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4b9f0(%rip), %rsi     # 0xee004
leaq 0x7b213(%rip), %rdx     # 0x11d82e
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b9fc(%rip), %rsi     # 0xee034
leaq 0x7b0bb(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x81c, %ecx            # imm = 0x81C
jmp 0xa1c95
movq 0x28(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4b9a5(%rip), %rsi     # 0xee004
leaq 0x7b1e4(%rip), %rdx     # 0x11d84a
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b9b1(%rip), %rsi     # 0xee034
leaq 0x7b070(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x81d, %ecx            # imm = 0x81D
jmp 0xa1c95
shll $0x3, %ebp
leaq 0x4b963(%rip), %rsi     # 0xee004
leaq 0x7b1bb(%rip), %rdx     # 0x11d863
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b96d(%rip), %rsi     # 0xee034
leaq 0x7b02c(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x81e, %ecx            # imm = 0x81E
jmp 0xa1c95
shll $0x3, %ebp
leaq 0x4b91f(%rip), %rsi     # 0xee004
leaq 0x7b1cf(%rip), %rdx     # 0x11d8bb
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b929(%rip), %rsi     # 0xee034
leaq 0x7afe8(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x836, %ecx            # imm = 0x836
jmp 0xa1f06
movq 0x18(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4b8d2(%rip), %rsi     # 0xee004
leaq 0x7b192(%rip), %rdx     # 0x11d8cb
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b8de(%rip), %rsi     # 0xee034
leaq 0x7af9d(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x839, %ecx            # imm = 0x839
jmp 0xa1c95
shll $0x3, %r12d
leaq 0x4b88f(%rip), %rsi     # 0xee004
leaq 0x7b163(%rip), %rdx     # 0x11d8df
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b898(%rip), %rsi     # 0xee034
leaq 0x7af57(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x83a, %ecx            # imm = 0x83A
jmp 0xa1c95
shll $0x3, %ebp
leaq 0x4b84a(%rip), %rsi     # 0xee004
leaq 0x7b13d(%rip), %rdx     # 0x11d8fe
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b854(%rip), %rsi     # 0xee034
leaq 0x7af13(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x83b, %ecx            # imm = 0x83B
jmp 0xa1c95
shll $0x3, %ebp
leaq 0x4b806(%rip), %rsi     # 0xee004
leaq 0x7b111(%rip), %rdx     # 0x11d916
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b810(%rip), %rsi     # 0xee034
leaq 0x7aecf(%rip), %rdx     # 0x11d6fa
movq %rbx, %rdi
movl $0x83d, %ecx            # imm = 0x83D
jmp 0xa1c95