// File: /workspace/github_c_makefile_star2_O2/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 $0x8f8, %rsp            # imm = 0x8F8
movsd %xmm0, 0x78(%rsp)
movq %r8, 0x58(%rsp)
movq %rcx, %rbx
movq %rsi, 0x70(%rsp)
movq %rdi, 0x28(%rsp)
movzwl 0x958(%rsp), %eax
leaq 0x960(%rcx), %r14
leaq 0x940(%rcx), %r13
addq $0x920, %rcx            # imm = 0x920
leaq 0x958(%rbx), %rsi
xorl %edi, %edi
testw %ax, %ax
setne %dil
movq %r14, 0xe8(%rsp)
movq %rsi, 0xb8(%rsp)
cmoveq %rsi, %r14
movq %r13, 0xe0(%rsp)
movq %rcx, 0xc0(%rsp)
cmoveq %rcx, %r13
movl %edi, %eax
shll $0x4, %eax
addq $0x9b8, %rax            # imm = 0x9B8
movq %rax, 0x90(%rsp)
shll $0x5, %edi
leaq 0x928(%rdi), %rax
movq %rax, 0x88(%rsp)
addq $0x930, %rdi            # imm = 0x930
movq %rdi, 0x98(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x950(%rsp), %rax
movq 0x80(%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x88(%rax), %rcx
movq %rcx, 0xb0(%rsp)
movq 0x90(%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x98(%rax), %rcx
movq %rcx, 0xa8(%rsp)
leaq 0x74(%rax), %rcx
movq %rcx, 0xa0(%rsp)
addq $0xd0, %rax
movq %rax, 0xc8(%rsp)
movl %r9d, 0x14(%rsp)
movslq %r9d, %r15
xorl %r12d, %r12d
movq %rdx, 0x8(%rsp)
movslq 0x8a4(%rbx), %rax
cmpq %rax, %r12
jge 0xa5d2c
movq 0x9d0(%rdx), %rax
movq (%rax,%r12,8), %rax
movq %rdx, %rsi
movq 0x90(%rsp), %rcx
movq (%rdx,%rcx), %rcx
movslq (%rcx,%r12,4), %rcx
movq 0x98(%rsp), %rdx
movq (%rbx,%rdx), %rdx
movq (%rdx,%r12,8), %rdx
movsd -0x8(%rax,%rcx,8), %xmm0
movsd (%rdx,%r15,8), %xmm1
movsd %xmm1, 0x60(%rsp)
ucomisd %xmm1, %xmm0
jae 0xa57f4
movq 0x870(%rsi), %rax
movl (%rax,%r12,4), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpl %eax, %ecx
je 0xa5c7e
movq 0x8f0(%rbx), %rdx
movl (%rdx,%r12,4), %edx
xorl %esi, %esi
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
imull %ecx, %edx
cmpl %edi, %esi
je 0xa57f0
movq 0x900(%rbx), %r8
movl (%r8,%r12,4), %r9d
testl %r9d, %r9d
movl $0x0, %r8d
cmovgl %r9d, %r8d
imull %edx, %r9d
movslq %r9d, %r9
subq $0x1, %r8
jb 0xa57ea
movq (%r14), %r10
movq (%r13), %r11
imulq %r9, %r11
shlq $0x3, %r11
addq (%r10,%r12,8), %r11
andq $0x0, (%r11,%r15,8)
incq %r9
jmp 0xa57c7
incl %esi
incl %edx
jmp 0xa57a4
incl %ecx
jmp 0xa5782
movq 0x88(%rsp), %rax
movq (%rbx,%rax), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, 0xd8(%rsp)
xorl %ebp, %ebp
movq %rsi, %rdx
movq 0x870(%rdx), %rax
cmpl (%rax,%r12,4), %ebp
jge 0xa5c83
xorl %r10d, %r10d
pushq $-0x1
popq %rax
movl %eax, 0x24(%rsp)
movq %rbp, 0x38(%rsp)
movq 0x8f0(%rbx), %rax
movslq (%rax,%r12,4), %rcx
cmpq %rcx, %r10
jge 0xa5c72
cmpw $0x0, 0x958(%rsp)
je 0xa5862
movl 0x8bc(%rbx), %eax
cmpq %rax, %r10
jne 0xa5c1f
movq 0x58(%rsp), %rax
movq (%rax,%r12,8), %rax
movl (%rax,%r10,4), %eax
cmpl 0x24(%rsp), %eax
movq %r10, 0x18(%rsp)
je 0xa58e6
movq 0x938(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x8(%rsp), %rdi
movq 0x998(%rdi), %rdx
movl (%rdx,%r12,4), %edx
imull %ebp, %edx
addl %eax, %edx
movslq %edx, %rax
movq (%rcx,%rax,8), %r9
movq 0x940(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq %rbx, %rsi
movsd 0x60(%rsp), %xmm0
movl %r12d, %edx
pushq 0x50(%rsp)
pushq (%rcx,%rax,8)
callq 0xa5d75
popq %rcx
popq %rdx
testl %eax, %eax
jne 0xa5d30
movq 0x58(%rsp), %rax
movq (%rax,%r12,8), %rax
movq 0x18(%rsp), %r10
movl (%rax,%r10,4), %eax
movl %eax, 0x24(%rsp)
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
movq 0x58(%rsp), %r8
movsd 0x80(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movl %r12d, %r9d
pushq 0xa8(%rsp)
pushq 0xb8(%rsp)
pushq 0x80(%rsp)
movl 0x950(%rsp), %eax
pushq %rax
pushq 0x970(%rsp)
pushq 0xe0(%rsp)
pushq %r10
movq %r10, %rbp
callq 0xa5eff
addq $0x40, %rsp
testl %eax, %eax
jne 0xa5cea
movq %rbx, %rdi
movq 0x950(%rsp), %rsi
movl %r12d, %edx
movl 0x14(%rsp), %ecx
callq 0xa6d2a
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %ebp, %ecx
leaq 0x4c(%rsp), %r8
callq 0xa6f8a
movl 0x4c(%rsp), %eax
movq %rax, 0xd0(%rsp)
xorl %r11d, %r11d
movq 0x38(%rsp), %rbp
movq 0x900(%rbx), %rax
movslq (%rax,%r12,4), %rax
cmpq %rax, %r11
jge 0xa5c12
movq 0x910(%rbx), %rax
movq 0x928(%rbx), %rcx
movq %r11, 0x40(%rsp)
movl (%rax,%r11,4), %ebp
cvtsi2sd %ebp, %xmm2
movq 0x70(%rsp), %rax
movsd 0x310(%rax), %xmm0
subsd 0x78(%rsp), %xmm0
mulsd 0x918(%rbx), %xmm0
movsd (%rcx,%r15,8), %xmm1
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movl %r12d, %ecx
movq 0x20(%rsp), %r9
movsd %xmm2, 0x88(%rsp)
leaq 0xe(%rsp), %rax
pushq %rax
callq 0xa70dc
popq %rcx
popq %rdx
movq 0x950(%rsp), %rax
movl 0xc0(%rax), %eax
cmpl $0x1, %eax
jne 0xa5a7f
movq 0x950(%rsp), %rax
movsd 0xb8(%rax), %xmm0
ucomisd 0x3f818(%rip), %xmm0    # 0xe5258
jb 0xa5a48
sqrtsd %xmm0, %xmm0
jmp 0xa5a4d
callq 0x82d0
movsd 0xd8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0x3f836(%rip), %xmm1    # 0xe5298
cvttsd2si %xmm1, %eax
cmpl %eax, %ebp
jl 0xa5a71
movw $0x1, 0x6(%rsp)
movq 0x950(%rsp), %rax
movl 0xc0(%rax), %eax
testl %eax, %eax
movq 0x40(%rsp), %r11
je 0xa5ad3
movl 0x14(%rsp), %ecx
cmpl %ecx, 0x938(%rbx)
jle 0xa5ad3
cmpw $0x0, 0x958(%rsp)
jne 0xa5ad3
movq 0x950(%rsp), %rcx
movslq 0x1c(%rcx), %rcx
cmpq %rcx, %r11
jl 0xa5ad3
movw $0x1, 0x6(%rsp)
movq 0xb8(%rsp), %rcx
movq 0xc0(%rsp), %rdx
movq 0x38(%rsp), %rbp
movq 0x18(%rsp), %r10
jmp 0xa5aeb
cmpw $0x1, 0x6(%rsp)
movq %r14, %rcx
movq %r13, %rdx
movq 0x38(%rsp), %rbp
movq 0x18(%rsp), %r10
jne 0xa5b29
movq 0x8f0(%rbx), %rax
movq 0x900(%rbx), %rsi
movslq (%rsi,%r12,4), %rsi
movl (%rax,%r12,4), %eax
imull %ebp, %eax
addl %r10d, %eax
cltq
imulq %rsi, %rax
addq %r11, %rax
imulq (%rdx), %rax
movq (%rcx), %rcx
shlq $0x3, %rax
addq (%rcx,%r12,8), %rax
andq $0x0, (%rax,%r15,8)
jmp 0xa5c0a
movzwl 0x958(%rsp), %ecx
testw %cx, %cx
jne 0xa5bb4
testl %eax, %eax
je 0xa5b50
movq 0x920(%rbx), %rax
movq 0x928(%rbx), %rcx
movsd -0x8(%rcx,%rax,8), %xmm0
jmp 0xa5b73
movq 0x950(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x38(%rax), %rcx
movslq 0x30(%rax), %rax
movsd -0x8(%rcx,%rax,8), %xmm0
movq 0x68(%rsp), %rax
divsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
movl %r12d, %ecx
movl %r10d, %r8d
movsd 0x80(%rsp), %xmm0
movq 0xc8(%rsp), %r9
callq 0xa72b8
movq 0x18(%rsp), %r10
movzwl 0x958(%rsp), %ecx
movq 0x40(%rsp), %r11
subq $0x8, %rsp
movswl %cx, %eax
movq 0x958(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
movl 0x1c(%rsp), %r8d
movl %r12d, %r9d
movsd 0x88(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
pushq %rax
pushq 0xe0(%rsp)
pushq %r11
pushq %r10
pushq %rbp
callq 0xa7378
movq 0x70(%rsp), %r11
addq $0x30, %rsp
testl %eax, %eax
jne 0xa5c8b
incq %r11
jmp 0xa5996
movq 0x18(%rsp), %r10
incq %r10
jmp 0xa5834
movq 0x900(%rbx), %rax
movl (%rax,%r12,4), %edx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
imull %ebp, %ecx
addl %r10d, %ecx
imull %edx, %ecx
movslq %ecx, %rcx
subq $0x1, %rax
jb 0xa5c17
movq 0xe8(%rsp), %rdx
movq (%rdx), %rdx
movq 0xe0(%rsp), %rsi
movq (%rsi), %rsi
imulq %rcx, %rsi
shlq $0x3, %rsi
addq (%rdx,%r12,8), %rsi
andq $0x0, (%rsi,%r15,8)
incq %rcx
jmp 0xa5c40
incl %ebp
movq 0x8(%rsp), %rdx
jmp 0xa5814
movq 0x8(%rsp), %rdx
incq %r12
jmp 0xa5716
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3f757(%rip), %rsi     # 0xe53f0
leaq 0x70660(%rip), %rdx     # 0x116300
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3f378(%rip), %rsi     # 0xe5034
leaq 0x70584(%rip), %rdx     # 0x116247
movq %rbx, %rdi
movl $0x843, %ecx            # imm = 0x843
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x8f8, %rsp            # imm = 0x8F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3f6f8(%rip), %rsi     # 0xe53f0
leaq 0x70564(%rip), %rdx     # 0x116263
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3f319(%rip), %rsi     # 0xe5034
leaq 0x70525(%rip), %rdx     # 0x116247
movq %rbx, %rdi
movl $0x7d5, %ecx            # imm = 0x7D5
jmp 0xa5ccb
xorl %eax, %eax
jmp 0xa5cd8
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3f6b2(%rip), %rsi     # 0xe53f0
leaq 0x703d5(%rip), %rdx     # 0x11611a
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3f2d3(%rip), %rsi     # 0xe5034
leaq 0x704df(%rip), %rdx     # 0x116247
movq %rbx, %rdi
movl $0x7b6, %ecx            # imm = 0x7B6
jmp 0xa5ccb