// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_compute_for_each_q
int transfer_compute_for_each_q(
                                struct precision * ppr,
                                struct background * pba,
                                struct perturbations * ppt,
                                struct transfer * ptr,
                                int ** tp_of_tt,
                                int index_q,
                                int tau_size_max,
                                double tau_rec,
                                double *** pert_sources,
                                double *** pert_sources_spline,
                                double * window,
                                struct transfer_workspace * ptw,
                                short use_full_limber
                                ) {

  /** Summary: */

  /** - define local variables */

  /* running index for modes */
  int index_md;
  /* running index for initial conditions */
  int index_ic;
  /* running index for transfer types */
  int index_tt;
  /* running index for multipoles */
  int index_l;

  /** - we deal with workspaces, i.e. with contiguous memory zones (one
      per thread) containing various fields used by the integration
      routine */

  /* - first workspace field: perturbation source interpolated from perturbation structure */
  double * interpolated_sources;

  /* - second workspace field: list of tau0-tau values, tau0_minus_tau[index_tau] */
  double * tau0_minus_tau;

  /* - third workspace field: list of trapezoidal weights for integration over tau */
  double * w_trapz;

  /* - fourth workspace field, containing just a double: number of time values */
  int * tau_size;

  /* - fifth workspace field, identical to above interpolated sources:
     sources[index_tau] */
  double * sources;

  /** - for a given l, maximum value of k such that we can convolve
      the source with Bessel functions j_l(x) without reaching x_max */
  double q_max_bessel=0.;

  /* a value of index_type */
  int previous_type;

  double l;

  short neglect;

  radial_function_type radial_type;

  double q,k,k_max;

  /** - store the sources in the workspace and define all
      fields in this workspace */
  interpolated_sources = ptw->interpolated_sources;
  tau0_minus_tau = ptw->tau0_minus_tau;
  w_trapz  = ptw->w_trapz;
  tau_size = &(ptw->tau_size);
  sources = ptw->sources;

  /** - loop over all modes. For each mode */

  for (index_md = 0; index_md < ptr->md_size; index_md++) {

    if (use_full_limber == _FALSE_) {
      q = ptr->q[index_q];
      k = ptr->k[index_md][index_q];
      k_max = ppt->k[index_md][ppt->k_size_cl[index_md]-1];
    }
    else {
      q = ptr->q_limber[index_q];
      k = ptr->k_limber[index_md][index_q];
      k_max = ppt->k[index_md][ppt->k_size[index_md]-1];
    }


    /* if we reached q_max for this mode, there is nothing to be done */

    if (k <= k_max) {

      /** - loop over initial conditions. */
      /* For each of them: */

      for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {

        /* initialize the previous type index */
        previous_type=-1;

        /* - loop over types. For each of them: */

        for (index_tt = 0; index_tt < ptr->tt_size[index_md]; index_tt++) {


          /** - define here wich transfer fucntion should be computed
                in the standard way and full limber way. Currently:
                compute all transfer functions in the standard way and
                only the lensing CMB potential in the full limber
                way. */

          if ((use_full_limber == _FALSE_) || (index_tt == ptr->index_tt_lcmb)) {

            /** - check if we must now deal with a new source with a
                new index ppt->index_type. If yes, interpolate it at the
                right values of k. */

            if (tp_of_tt[index_md][index_tt] != previous_type) {

              class_call(transfer_interpolate_sources(ppt,
                                                      ptr,
                                                      k,
                                                      index_md,
                                                      index_ic,
                                                      tp_of_tt[index_md][index_tt],
                                                      pert_sources[index_md][index_ic * ppt->tp_size[index_md] + tp_of_tt[index_md][index_tt]],
                                                      pert_sources_spline[index_md][index_ic * ppt->tp_size[index_md] + tp_of_tt[index_md][index_tt]],
                                                      interpolated_sources),
                         ptr->error_message,
                         ptr->error_message);
            }

            previous_type = tp_of_tt[index_md][index_tt];

            /* the code makes a distinction between "perturbation
               sources" (e.g. gravitational potential) and "transfer
               sources" (e.g. total density fluctuations, obtained
               through the Poisson equation, and observed with a given
               selection function).

               The next routine computes the transfer source given the
               interpolated perturbation source, and copies it in the
               workspace. */

            class_call(transfer_sources(ppr,
                                        pba,
                                        ppt,
                                        ptr,
                                        interpolated_sources,
                                        tau_rec,
                                        k,
                                        index_md,
                                        index_tt,
                                        sources,
                                        window,
                                        tau_size_max,
                                        tau0_minus_tau,
                                        w_trapz,
                                        tau_size),
                       ptr->error_message,
                       ptr->error_message);

            /* now that the array of times tau0_minus_tau is known, we can
               infer the array of radial coordinates r(tau0_minus_tau) as well as a
               few other quantities related by trigonometric functions */

            class_call(transfer_radial_coordinates(ptr,ptw,index_md,index_q),
                       ptr->error_message,
                       ptr->error_message);

            /** - Select radial function type */
            class_call(transfer_select_radial_function(
                                                       ppt,
                                                       ptr,
                                                       index_md,
                                                       index_tt,
                                                       &radial_type),
                       ptr->error_message,
                       ptr->error_message);

            for (index_l = 0; index_l < ptr->l_size[index_md]; index_l++) {

              l = (double)ptr->l[index_l];

              /* neglect transfer function when l is much smaller than k*tau0 */
              class_call(transfer_can_be_neglected(ppr,
                                                   ppt,
                                                   ptr,
                                                   index_md,
                                                   index_ic,
                                                   index_tt,
                                                   (pba->conformal_age-tau_rec)*ptr->angular_rescaling,
                                                   ptr->q[index_q],
                                                   l,
                                                   &neglect),
                         ptr->error_message,
                         ptr->error_message);

              /* for K>0 (closed), transfer functions only defined for l<nu */
              if ((ptw->sgnK == 1) && (ptr->l[index_l] >= (int)(q/sqrt(ptw->K)+0.2))) {
                neglect = _TRUE_;
              }
              /* This would maybe go into transfer_can_be_neglected later: */
              if ((ptw->sgnK != 0) && (index_q < ptr->index_q_flat_approximation) && (index_l>=ptw->HIS.l_size) && (use_full_limber == _FALSE_)) {
                neglect = _TRUE_;
              }
              if (neglect == _TRUE_) {

                if (use_full_limber == _FALSE_) {
                  ptr->transfer[index_md][((index_ic * ptr->tt_size[index_md] + index_tt)
                                           * ptr->l_size[index_md] + index_l)
                                          * ptr->q_size + index_q] = 0.;
                }
                else {
                  ptr->transfer_limber[index_md][((index_ic * ptr->tt_size[index_md] + index_tt)
                                                  * ptr->l_size[index_md] + index_l)
                                                 * ptr->q_size_limber + index_q] = 0.;
                }
              }
              else {

                if (use_full_limber == _FALSE_) {

                  /* for a given l, maximum value of k such that we can
                     convolve the source with Bessel functions j_l(x)
                     without reaching x_max (this is relevant in the flat
                     case when the bessels are computed with the old bessel
                     module. otherwise this condition is guaranteed by the
                     choice of proper xmax when computing bessels) */
                  if (ptw->sgnK == 0) {
                    q_max_bessel = ptw->pBIS->x[ptw->pBIS->x_size-1]/tau0_minus_tau[0];
                  }
                  else {
                    q_max_bessel = ptr->q[ptr->q_size-1];
                  }

                  /* neglect late time CMB sources when l is above threshold */
                  class_call(transfer_late_source_can_be_neglected(ppr,
                                                                   ppt,
                                                                   ptr,
                                                                   index_md,
                                                                   index_tt,
                                                                   l,
                                                                   &(ptw->neglect_late_source)),
                             ptr->error_message,
                             ptr->error_message);
                }

                /* note: if use_full_limber == _TRUE_, q_max_bessel is
                   still equal to zero at this stage, but this is OK
                   because in this case it will never be used, not
                   even inside transfer_compute_for_each_l() */

                /* compute the transfer function for this l */
                class_call(transfer_compute_for_each_l(
                                                       ptw,
                                                       ppr,
                                                       ppt,
                                                       ptr,
                                                       index_q,
                                                       index_md,
                                                       index_ic,
                                                       index_tt,
                                                       index_l,
                                                       l,
                                                       q_max_bessel,
                                                       radial_type,
                                                       use_full_limber
                                                       ),
                           ptr->error_message,
                           ptr->error_message);
              }

            } /* end of loop over l */

          }
          else {
            for (index_l = 0; index_l < ptr->l_size[index_md]; index_l++) {
              if (use_full_limber == _FALSE_) {
                ptr->transfer[index_md][((index_ic * ptr->tt_size[index_md] + index_tt)
                                         * ptr->l_size[index_md] + index_l)
                                        * ptr->q_size + index_q] = 0.;
              }
              else {
                ptr->transfer_limber[index_md][((index_ic * ptr->tt_size[index_md] + index_tt)
                                                * ptr->l_size[index_md] + index_l)
                                               * ptr->q_size_limber + index_q] = 0.;
              }
            }
          }

        } /* end of loop over type */

      } /* end of loop over initial condition */

    }

    else {

      for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {
        for (index_tt = 0; index_tt < ptr->tt_size[index_md]; index_tt++) {
          for (index_l = 0; index_l < ptr->l_size[index_md]; index_l++) {

            if (use_full_limber == _FALSE_) {
              ptr->transfer[index_md][((index_ic * ptr->tt_size[index_md] + index_tt)
                                       * ptr->l_size[index_md] + index_l)
                                      * ptr->q_size + index_q] = 0.;
            }
            else {
              ptr->transfer_limber[index_md][((index_ic * ptr->tt_size[index_md] + index_tt)
                                              * ptr->l_size[index_md] + index_l)
                                             * ptr->q_size_limber + index_q] = 0.;
            }
          }
        }
      }
    }

  } /* end of loop over mode */

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8e8, %rsp            # imm = 0x8E8
movsd %xmm0, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdi, 0x38(%rsp)
cmpl $0x0, 0x8a4(%rcx)
jle 0xae258
movl %r9d, %r14d
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %rbp
movq 0x940(%rsp), %rax
movq 0x80(%rax), %rcx
movq %rcx, 0x58(%rsp)
movq 0x88(%rax), %rcx
movq %rcx, 0xc0(%rsp)
movq 0x90(%rax), %rcx
movq %rcx, 0x60(%rsp)
movq 0x98(%rax), %rcx
movq %rcx, 0xb8(%rsp)
xorl %r15d, %r15d
cmpw $0x0, 0x948(%rsp)
setne %r15b
movl %r15d, %ecx
leaq 0x958(,%r15,8), %rdx
movq %rdx, 0x90(%rsp)
shll $0x5, %r15d
leaq 0x928(%r15), %rdx
movq %rdx, 0x98(%rsp)
leaq 0x930(%r15), %rdx
movq %rdx, 0xa0(%rsp)
shll $0x4, %ecx
addq $0x9b8, %rcx            # imm = 0x9B8
movq %rcx, 0xa8(%rsp)
addq $0x920, %r15            # imm = 0x920
xorpd %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
leaq 0x74(%rax), %rcx
movq %rcx, 0xb0(%rsp)
movslq %r9d, %rcx
addq $0xd0, %rax
movq %rax, 0xc8(%rsp)
movq %rcx, 0x28(%rsp)
leaq (,%rcx,8), %rax
movq %rax, 0x88(%rsp)
xorl %r12d, %r12d
movq 0xa0(%rsp), %rax
movq (%rbx,%rax), %rax
movq (%rax,%r12,8), %rax
movq 0x9d0(%rbp), %rcx
movq (%rcx,%r12,8), %rcx
movq 0xa8(%rsp), %rdx
movq (%rbp,%rdx), %rdx
movslq (%rdx,%r12,4), %rdx
movsd -0x8(%rcx,%rdx,8), %xmm0
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd %xmm1, 0x68(%rsp)
ucomisd %xmm1, %xmm0
jae 0xadd16
movq 0x870(%rbp), %rax
movslq (%rax,%r12,4), %rax
testq %rax, %rax
jle 0xae245
movq 0x8f0(%rbx), %rcx
movl (%rcx,%r12,4), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0xadd09
movq 0x900(%rbx), %rsi
movl (%rsi,%r12,4), %esi
movq %rdx, %rdi
imulq %rcx, %rdi
xorl %r8d, %r8d
testl %esi, %esi
jle 0xadd01
leaq (%rdi,%r8), %r10
imulq %rsi, %r10
cmpw $0x0, 0x948(%rsp)
cmoveq %r10, %r10
movq 0x90(%rsp), %r9
movq (%rbx,%r9), %r11
movq (%rbx,%r15), %r9
movq (%r11,%r12,8), %r11
addq 0x88(%rsp), %r11
imulq %r9, %r10
leaq (%r11,%r10,8), %r10
shlq $0x3, %r9
movq %rsi, %r11
movq $0x0, (%r10)
addq %r9, %r10
decq %r11
jne 0xadcf2
incq %r8
cmpq %rcx, %r8
jne 0xadcae
incq %rdx
cmpq %rax, %rdx
jne 0xadc95
jmp 0xae245
movq 0x870(%rbp), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0xae245
movq 0x98(%rsp), %rax
movq (%rbx,%rax), %rax
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xd0(%rsp)
movq $0x0, 0x10(%rsp)
movq %r13, 0x50(%rsp)
movq %rbp, 0x30(%rsp)
movq 0x8f0(%rbx), %rax
movl (%rax,%r12,4), %edi
testl %edi, %edi
jle 0xae228
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
cmpw $0x0, 0x948(%rsp)
je 0xadd90
movl 0x8bc(%rbx), %eax
cmpq %rax, %r10
jne 0xae113
movq (%r13,%r12,8), %rax
movl (%rax,%r10,4), %eax
cmpl %r9d, %eax
movq %r10, 0x18(%rsp)
je 0xade00
movq 0x928(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x998(%rbp), %rdx
movl (%rdx,%r12,4), %edx
imull 0x10(%rsp), %edx
addl %eax, %edx
movslq %edx, %rax
movq (%rcx,%rax,8), %r9
movq 0x930(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq %rbp, %rdi
movq %rbx, %rsi
movsd 0x68(%rsp), %xmm0
movl %r12d, %edx
pushq 0x58(%rsp)
pushq (%rcx,%rax,8)
callq 0xae344
movq 0x28(%rsp), %r10
addq $0x10, %rsp
testl %eax, %eax
jne 0xae2ff
movq (%r13,%r12,8), %rax
movl (%rax,%r10,4), %eax
movl %eax, 0x24(%rsp)
subq $0x8, %rsp
movq 0x40(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq 0x60(%rsp), %r8
movsd 0x80(%rsp), %xmm0
movsd 0x70(%rsp), %xmm1
movl %r12d, %r9d
pushq 0xb8(%rsp)
pushq 0xc8(%rsp)
pushq 0x78(%rsp)
movl 0x940(%rsp), %eax
pushq %rax
pushq 0x960(%rsp)
pushq 0xf0(%rsp)
pushq %r10
movq %r10, %r13
callq 0xae50b
addq $0x40, %rsp
testl %eax, %eax
jne 0xae2bd
movq %rbx, %rdi
movq 0x940(%rsp), %rsi
movl %r12d, %edx
movl %r14d, %ecx
callq 0xaf3bc
movq %rbp, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %r13d, %ecx
leaq 0x4c(%rsp), %r8
callq 0xaf641
movq 0x900(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0xae202
movl 0x4c(%rsp), %eax
movq %rax, 0xd8(%rsp)
xorl %ebp, %ebp
movq 0x18(%rsp), %r10
movl %r14d, %r13d
movq 0x910(%rbx), %rax
movq 0x928(%rbx), %rcx
movl (%rax,%rbp,4), %r14d
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
movq 0x70(%rsp), %rax
movsd 0x310(%rax), %xmm0
subsd 0x78(%rsp), %xmm0
mulsd 0x918(%rbx), %xmm0
movq 0x28(%rsp), %rax
movsd (%rcx,%rax,8), %xmm1
subq $0x8, %rsp
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rbx, %rdx
movl %r12d, %ecx
movl %r10d, %r9d
movsd %xmm2, 0x88(%rsp)
leaq 0x16(%rsp), %rax
pushq %rax
callq 0xaf7b2
addq $0x10, %rsp
movq 0x940(%rsp), %rdi
cmpl $0x1, 0xc0(%rdi)
jne 0xadf93
movsd 0xb8(%rdi), %xmm0
ucomisd 0x432ff(%rip), %xmm0    # 0xf1258
jb 0xadf61
sqrtsd %xmm0, %xmm0
jmp 0xadf6e
callq 0x82b0
movq 0x940(%rsp), %rdi
movsd 0xd0(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0x43315(%rip), %xmm1    # 0xf1298
cvttsd2si %xmm1, %eax
cmpl %eax, %r14d
jl 0xadf93
movw $0x1, 0xe(%rsp)
movl 0xc0(%rdi), %eax
testl %eax, %eax
movl %r13d, %r14d
movzwl 0x948(%rsp), %r13d
je 0xadfc8
cmpl %r14d, 0x938(%rbx)
jle 0xadfc8
testw %r13w, %r13w
jne 0xadfc8
movslq 0x1c(%rdi), %rcx
cmpq %rcx, %rbp
jl 0xadfc8
movw $0x1, 0xe(%rsp)
cmpw $0x1, 0xe(%rsp)
movq 0x18(%rsp), %r10
jne 0xae027
movq 0x8f0(%rbx), %rax
movq 0x900(%rbx), %rcx
movslq (%rcx,%r12,4), %rcx
movl (%rax,%r12,4), %eax
imull 0x10(%rsp), %eax
addl %r10d, %eax
cltq
imulq %rcx, %rax
addq %rbp, %rax
movq 0x90(%rsp), %rcx
movq (%rbx,%rcx), %rcx
imulq (%rbx,%r15), %rax
shlq $0x3, %rax
addq (%rcx,%r12,8), %rax
movq 0x28(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0xae0ed
testw %r13w, %r13w
jne 0xae09e
testl %eax, %eax
je 0xae047
movq 0x920(%rbx), %rax
movq 0x928(%rbx), %rcx
movsd -0x8(%rcx,%rax,8), %xmm0
jmp 0xae062
movq 0x68(%rdi), %rax
movq 0x38(%rax), %rcx
movslq 0x30(%rax), %rax
movsd -0x8(%rcx,%rax,8), %xmm0
movq 0x60(%rsp), %rax
divsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rbx, %rdx
movl %r12d, %ecx
movl %r10d, %r8d
movsd 0x80(%rsp), %xmm0
movq 0xc8(%rsp), %r9
callq 0xaf9bd
movq 0x18(%rsp), %r10
movq 0x940(%rsp), %rdi
subq $0x8, %rsp
movswl %r13w, %eax
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rcx
movl %r14d, %r8d
movl %r12d, %r9d
movsd 0x88(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
pushq %rax
pushq 0xe8(%rsp)
pushq %rbp
pushq %r10
pushq 0x38(%rsp)
callq 0xafa7e
movq 0x48(%rsp), %r10
addq $0x30, %rsp
testl %eax, %eax
jne 0xae25c
incq %rbp
movq 0x900(%rbx), %rax
movslq (%rax,%r12,4), %rax
cmpq %rax, %rbp
jl 0xadec7
movq 0x50(%rsp), %r13
movq 0x30(%rsp), %rbp
jmp 0xae20c
movq 0x900(%rbx), %rax
movslq (%rax,%r12,4), %r8
testq %r8, %r8
jle 0xae211
movq 0x940(%rbx), %rax
movq 0x960(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
addq 0x88(%rsp), %rcx
leal 0x1(%r8), %edx
andl $-0x2, %edx
movq %r8, %rsi
decq %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (,%rax,8), %rsi
imull 0x10(%rsp), %edi
addl %r10d, %edi
imull %r8d, %edi
movslq %edi, %r8
leaq 0x1(%r8), %rdi
imulq %rsi, %rdi
shlq $0x4, %rax
imulq %r8, %rsi
movdqa 0x43af9(%rip), %xmm1    # 0xf1c80
movdqa %xmm0, %xmm2
movdqa 0x43afd(%rip), %xmm4    # 0xf1c90
pxor %xmm4, %xmm2
movdqa %xmm1, %xmm3
pxor %xmm4, %xmm3
movdqa %xmm3, %xmm4
pcmpgtd %xmm2, %xmm4
pcmpeqd %xmm2, %xmm3
pshufd $0xf5, %xmm3, %xmm3     # xmm3 = xmm3[1,1,3,3]
pand %xmm4, %xmm3
pshufd $0xf5, %xmm4, %xmm2     # xmm2 = xmm4[1,1,3,3]
por %xmm3, %xmm2
movd %xmm2, %r8d
notl %r8d
testb $0x1, %r8b
je 0xae1d3
movq $0x0, (%rcx,%rsi)
pxor 0x73185(%rip), %xmm2    # 0x121360
pextrw $0x4, %xmm2, %r8d
testb $0x1, %r8b
je 0xae1ef
movq $0x0, (%rcx,%rdi)
paddq 0x44589(%rip), %xmm1    # 0xf2780
addq %rax, %rcx
addq $-0x2, %rdx
jne 0xae187
jmp 0xae211
movq 0x18(%rsp), %r10
movq 0x50(%rsp), %r13
movl 0x24(%rsp), %r9d
incq %r10
movq 0x8f0(%rbx), %rax
movslq (%rax,%r12,4), %rdi
cmpq %rdi, %r10
jl 0xadd76
movq 0x10(%rsp), %rcx
incl %ecx
movq 0x870(%rbp), %rax
movq %rcx, 0x10(%rsp)
cmpl (%rax,%r12,4), %ecx
jl 0xadd5a
incq %r12
movslq 0x8a4(%rbx), %rax
cmpq %rax, %r12
jl 0xadc28
xorl %eax, %eax
jmp 0xae2ab
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x43186(%rip), %rsi     # 0xf13f0
leaq 0x741bf(%rip), %rdx     # 0x122430
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x42da7(%rip), %rsi     # 0xf1034
leaq 0x740e3(%rip), %rdx     # 0x122377
movq %rbx, %rdi
movl $0x843, %ecx            # imm = 0x843
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x8e8, %rsp            # imm = 0x8E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x43125(%rip), %rsi     # 0xf13f0
leaq 0x740c1(%rip), %rdx     # 0x122393
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x42d46(%rip), %rsi     # 0xf1034
leaq 0x74082(%rip), %rdx     # 0x122377
movq %rbx, %rdi
movl $0x7d5, %ecx            # imm = 0x7D5
jmp 0xae29c
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x430e3(%rip), %rsi     # 0xf13f0
leaq 0x73f36(%rip), %rdx     # 0x12224a
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x42d04(%rip), %rsi     # 0xf1034
leaq 0x74040(%rip), %rdx     # 0x122377
movq %rbx, %rdi
movl $0x7b6, %ecx            # imm = 0x7B6
jmp 0xae29c