// File: /workspace/github_c_makefile_star2_O1/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 0xa4aab
testl %r13d, %r13d
jle 0xa4a05
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 0xa49f5
movq %r12, %rbx
movw $0x1, 0x50(%r12)
movzwl 0x4be(%rbp), %ecx
xorl %eax, %eax
xorl %edx, %edx
cmpw $0x1, %cx
sete %dl
movw %dx, 0x52(%r12)
jne 0xa4a36
movl $0x0, 0x58(%rbx)
movl $0x1, %eax
leal 0x1(%rax), %edx
movl %eax, 0x54(%rbx)
movl %edx, 0x64(%rbx)
movl %eax, 0x5c(%rbx)
cmpw $0x1, %cx
jne 0xa4a4b
movl 0x58(%rbx), %eax
movl %eax, 0x60(%rbx)
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa6293
testl %eax, %eax
je 0xa4aed
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c979(%rip), %rsi     # 0xf13f0
leaq 0x7bc4c(%rip), %rdx     # 0x1206ca
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4c59d(%rip), %rsi     # 0xf1034
leaq 0x7bc1c(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x7f0, %ecx            # imm = 0x7F0
jmp 0xa4b39
addl %r13d, %r13d
leaq 0x4c54f(%rip), %rsi     # 0xf1004
leaq 0x7bbed(%rip), %rdx     # 0x1206a9
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %r12            # imm = 0x192
leaq 0x4c558(%rip), %rsi     # 0xf1034
leaq 0x7bbd7(%rip), %rdx     # 0x1206ba
movq %r12, %rdi
movl $0x7ca, %ecx            # imm = 0x7CA
jmp 0xa4b39
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa666c
testl %eax, %eax
je 0xa4b5c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c8e6(%rip), %rsi     # 0xf13f0
leaq 0x7bbdd(%rip), %rdx     # 0x1206ee
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4c50a(%rip), %rsi     # 0xf1034
leaq 0x7bb89(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x7f6, %ecx            # imm = 0x7F6
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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 0xa5034
movq %r14, %rdi
callq 0x8460
movq %rax, 0xa8(%rbx)
testq %rax, %rax
je 0xa5078
movq %r14, %rdi
callq 0x8460
movq %rax, 0x108(%rbx)
testq %rax, %rax
je 0xa50be
movq %r14, 0x18(%rsp)
testl %ebp, %ebp
jle 0xa4c84
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 %r14d, %r14d
movq %r12, %rdi
callq 0x8460
movq 0x98(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq 0x98(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0xa5105
movq %r13, %rdi
callq 0x8460
movq 0xa8(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq 0xa8(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0xa5150
movq %rbp, %r15
movslq 0x104(%rbx), %rbp
imulq 0x8(%rsp), %rbp
leaq (,%rbp,8), %rdi
callq 0x8460
movq 0x108(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq 0x108(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0xa519b
incq %r14
movq %r15, %rbp
cmpq %r14, %r15
jne 0xa4bf1
movl (%rbx), %r13d
cmpl $0x2, %r13d
je 0xa4c94
cmpw $0x1, 0x3a(%rbx)
jne 0xa4c9a
movw $0x1, 0x38(%rbx)
cmpw $0x1, 0x38(%rbx)
movq %rbx, %r15
jne 0xa4ce2
movslq 0x104(%r15), %rbx
movq %rbx, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x8460
movq %rax, 0x118(%r15)
testq %rax, %rax
je 0xa51df
movq %r12, %rdi
callq 0x8460
movq %rax, 0x120(%r15)
testq %rax, %rax
je 0xa52af
movslq 0x90(%r15), %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x2, %rcx
movq %r15, %rbx
jl 0xa4e14
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x8460
movq %rax, 0xa0(%rbx)
testq %rax, %rax
je 0xa5269
movq %r14, %rdi
callq 0x8460
movq %rax, 0xb0(%rbx)
testq %rax, %rax
je 0xa52f5
movq %r14, %rdi
callq 0x8460
movq %rax, 0x110(%rbx)
testq %rax, %rax
je 0xa537f
testl %ebp, %ebp
jle 0xa4e14
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 %r14d, %r14d
movq 0x10(%rsp), %rdi
callq 0x8460
movq 0xa0(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq 0xa0(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0xa5496
movq %r12, %rdi
callq 0x8460
movq 0xb0(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq 0xb0(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0xa54e1
movq %rbp, %r15
movslq 0x104(%rbx), %rbp
imulq 0x8(%rsp), %rbp
leaq (,%rbp,8), %rdi
callq 0x8460
movq 0x110(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq 0x110(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0xa552c
incq %r14
movq %r15, %rbp
cmpq %r14, %r15
jne 0xa4d7f
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x8460
movq %rax, 0xc8(%rbx)
testq %rax, %rax
je 0xa5225
testl %r13d, %r13d
je 0xa4f8f
movq %r14, %rdi
callq 0x8460
movq %rax, 0x158(%rbx)
testq %rax, %rax
je 0xa5339
movq %r14, %rdi
callq 0x8460
movq %rax, 0x150(%rbx)
testq %rax, %rax
je 0xa53c5
movq %r14, %rdi
callq 0x8460
movq %rax, 0xb8(%rbx)
testq %rax, %rax
je 0xa5409
cmpl $0x2, 0x8(%rsp)
jl 0xa4ea1
movq %r14, %rdi
callq 0x8460
movq %rax, 0xc0(%rbx)
testq %rax, %rax
je 0xa5570
testl %ebp, %ebp
jle 0xa4f8f
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 0xa55b4
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 0xa55ff
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 0xa5645
cmpl $0x2, %r15d
jl 0xa4f80
movq %r12, %rdi
callq 0x8460
movq 0xc0(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0xc0(%rbx), %rax
cmpq $0x0, (%rax,%r13,8)
je 0xa5689
incq %r13
movq %r14, %rbp
cmpq %r13, %r14
jne 0xa4ec6
xorl %ebp, %ebp
cmpw $0x1, 0x3a(%rbx)
jne 0xa4b48
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 0xa544f
cmpl $0x2, %r12d
jl 0xa4b48
movq %r14, %rdi
callq 0x8460
movq %rax, 0x138(%rbx)
testq %rax, %rax
jne 0xa4b48
leal (,%r15,8), %ecx
leaq 0x4c008(%rip), %rsi     # 0xf1004
leaq 0x7b903(%rip), %rdx     # 0x120906
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4c014(%rip), %rsi     # 0xf1034
leaq 0x7b693(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x847, %ecx            # imm = 0x847
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4bfc6(%rip), %rsi     # 0xf1004
leaq 0x7b6c7(%rip), %rdx     # 0x12070c
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bfd0(%rip), %rsi     # 0xf1034
leaq 0x7b64f(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x7fa, %ecx            # imm = 0x7FA
jmp 0xa50fd
leal (,%rbp,8), %ecx
leaq 0x4bf7e(%rip), %rsi     # 0xf1004
leaq 0x7b68f(%rip), %rdx     # 0x12071c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bf8a(%rip), %rsi     # 0xf1034
leaq 0x7b609(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x7fb, %ecx            # imm = 0x7FB
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4bf3c(%rip), %rsi     # 0xf1004
leaq 0x7b65a(%rip), %rdx     # 0x120729
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bf46(%rip), %rsi     # 0xf1034
leaq 0x7b5c5(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x7fc, %ecx            # imm = 0x7FC
movq %r15, %r8
jmp 0xa4b3c
movq 0x10(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4beec(%rip), %rsi     # 0xf1004
leaq 0x7b61d(%rip), %rdx     # 0x12073c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bef8(%rip), %rsi     # 0xf1034
leaq 0x7b577(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x7ff, %ecx            # imm = 0x7FF
jmp 0xa4b39
movq 0x20(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4bea1(%rip), %rsi     # 0xf1004
leaq 0x7b5ec(%rip), %rdx     # 0x120756
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bead(%rip), %rsi     # 0xf1034
leaq 0x7b52c(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x800, %ecx            # imm = 0x800
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4be5f(%rip), %rsi     # 0xf1004
leaq 0x7b5c1(%rip), %rdx     # 0x12076d
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4be69(%rip), %rsi     # 0xf1034
leaq 0x7b4e8(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x801, %ecx            # imm = 0x801
jmp 0xa4b39
leal (,%rbx,8), %ecx
leaq 0x4be17(%rip), %rsi     # 0xf1004
leaq 0x7b596(%rip), %rdx     # 0x12078a
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %r15            # imm = 0x192
leaq 0x4be23(%rip), %rsi     # 0xf1034
leaq 0x7b4a2(%rip), %rdx     # 0x1206ba
movq %r15, %rdi
movl $0x80e, %ecx            # imm = 0x80E
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4bdd5(%rip), %rsi     # 0xf1004
leaq 0x7b60c(%rip), %rdx     # 0x120842
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bddf(%rip), %rsi     # 0xf1034
leaq 0x7b45e(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x824, %ecx            # imm = 0x824
jmp 0xa50fd
leal (,%rbp,8), %ecx
leaq 0x4bd8d(%rip), %rsi     # 0xf1004
leaq 0x7b53a(%rip), %rdx     # 0x1207b8
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bd99(%rip), %rsi     # 0xf1034
leaq 0x7b418(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x817, %ecx            # imm = 0x817
jmp 0xa4b39
leal (,%rbx,8), %ecx
leaq 0x4bd47(%rip), %rsi     # 0xf1004
leaq 0x7b4dc(%rip), %rdx     # 0x1207a0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %r15            # imm = 0x192
leaq 0x4bd53(%rip), %rsi     # 0xf1034
leaq 0x7b3d2(%rip), %rdx     # 0x1206ba
movq %r15, %rdi
movl $0x80f, %ecx            # imm = 0x80F
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4bd05(%rip), %rsi     # 0xf1004
leaq 0x7b4c4(%rip), %rdx     # 0x1207ca
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bd0f(%rip), %rsi     # 0xf1034
leaq 0x7b38e(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x818, %ecx            # imm = 0x818
jmp 0xa50fd
leal (,%rbp,8), %ecx
leaq 0x4bcbd(%rip), %rsi     # 0xf1004
leaq 0x7b500(%rip), %rdx     # 0x12084e
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bcc9(%rip), %rsi     # 0xf1034
leaq 0x7b348(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x82e, %ecx            # imm = 0x82E
jmp 0xa4b39
leal (,%rbp,8), %ecx
leaq 0x4bc77(%rip), %rsi     # 0xf1004
leaq 0x7b445(%rip), %rdx     # 0x1207d9
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bc83(%rip), %rsi     # 0xf1034
leaq 0x7b302(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x819, %ecx            # imm = 0x819
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4bc35(%rip), %rsi     # 0xf1004
leaq 0x7b482(%rip), %rdx     # 0x120858
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bc3f(%rip), %rsi     # 0xf1034
leaq 0x7b2be(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x832, %ecx            # imm = 0x832
jmp 0xa50fd
leal (,%rbp,8), %ecx
leaq 0x4bbed(%rip), %rsi     # 0xf1004
leaq 0x7b44f(%rip), %rdx     # 0x12086d
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bbf9(%rip), %rsi     # 0xf1034
leaq 0x7b278(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x834, %ecx            # imm = 0x834
jmp 0xa4b39
leal (,%r15,8), %ecx
leaq 0x4bba6(%rip), %rsi     # 0xf1004
leaq 0x7b48b(%rip), %rdx     # 0x1208f0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bbb2(%rip), %rsi     # 0xf1034
leaq 0x7b231(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x844, %ecx            # imm = 0x844
jmp 0xa4b39
movq 0x20(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4bb5b(%rip), %rsi     # 0xf1004
leaq 0x7b33e(%rip), %rdx     # 0x1207ee
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bb67(%rip), %rsi     # 0xf1034
leaq 0x7b1e6(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x81c, %ecx            # imm = 0x81C
jmp 0xa4b39
movq 0x28(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4bb10(%rip), %rsi     # 0xf1004
leaq 0x7b30f(%rip), %rdx     # 0x12080a
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bb1c(%rip), %rsi     # 0xf1034
leaq 0x7b19b(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x81d, %ecx            # imm = 0x81D
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4bace(%rip), %rsi     # 0xf1004
leaq 0x7b2e6(%rip), %rdx     # 0x120823
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4bad8(%rip), %rsi     # 0xf1034
leaq 0x7b157(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x81e, %ecx            # imm = 0x81E
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4ba8a(%rip), %rsi     # 0xf1004
leaq 0x7b2fa(%rip), %rdx     # 0x12087b
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4ba94(%rip), %rsi     # 0xf1034
leaq 0x7b113(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x836, %ecx            # imm = 0x836
jmp 0xa50fd
movq 0x18(%rsp), %rax
leal (,%rax,8), %ecx
leaq 0x4ba3d(%rip), %rsi     # 0xf1004
leaq 0x7b2bd(%rip), %rdx     # 0x12088b
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4ba49(%rip), %rsi     # 0xf1034
leaq 0x7b0c8(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x839, %ecx            # imm = 0x839
jmp 0xa4b39
shll $0x3, %r12d
leaq 0x4b9fa(%rip), %rsi     # 0xf1004
leaq 0x7b28e(%rip), %rdx     # 0x12089f
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4ba03(%rip), %rsi     # 0xf1034
leaq 0x7b082(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x83a, %ecx            # imm = 0x83A
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4b9b5(%rip), %rsi     # 0xf1004
leaq 0x7b268(%rip), %rdx     # 0x1208be
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b9bf(%rip), %rsi     # 0xf1034
leaq 0x7b03e(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x83b, %ecx            # imm = 0x83B
jmp 0xa4b39
shll $0x3, %ebp
leaq 0x4b971(%rip), %rsi     # 0xf1004
leaq 0x7b23c(%rip), %rdx     # 0x1208d6
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b97b(%rip), %rsi     # 0xf1034
leaq 0x7affa(%rip), %rdx     # 0x1206ba
movq %rbx, %rdi
movl $0x83d, %ecx            # imm = 0x83D
jmp 0xa4b39