// File: /workspace/github_c_makefile_star2_O3/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 $0x908, %rsp            # imm = 0x908
movsd %xmm0, 0x98(%rsp)
movq %r8, %r13
movq %rsi, 0x90(%rsp)
movq %rdi, 0x40(%rsp)
movl 0x8a4(%rcx), %r8d
testl %r8d, %r8d
jle 0xab28b
movl %r9d, %r14d
movq %rcx, %rbx
movq %rdx, %r11
movq 0x960(%rsp), %rax
addq $0x960, %rcx            # imm = 0x960
leaq 0x940(%rbx), %rdx
leaq 0x920(%rbx), %rsi
leaq 0x958(%rbx), %rdi
cmpw $0x0, 0x968(%rsp)
movq %rcx, 0x88(%rsp)
movq %rdi, 0xd0(%rsp)
cmoveq %rdi, %rcx
movq %rcx, 0xf8(%rsp)
movl $0x0, %edi
setne %dil
movq %rdx, 0x80(%rsp)
movq %rsi, 0xd8(%rsp)
cmoveq %rsi, %rdx
movq %rdx, 0xf0(%rsp)
movl %edi, %ecx
shll $0x4, %ecx
addq $0x9b8, %rcx            # imm = 0x9B8
movq %rcx, 0xa8(%rsp)
shll $0x5, %edi
leaq 0x928(%rdi), %rcx
movq %rcx, 0xa0(%rsp)
addq $0x930, %rdi            # imm = 0x930
xorpd %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x80(%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x88(%rax), %rcx
movq %rcx, 0xc0(%rsp)
movq 0x90(%rax), %rcx
movq %rcx, 0x70(%rsp)
movq 0x98(%rax), %rcx
movq %rcx, 0xb8(%rsp)
leaq 0x74(%rax), %rcx
movq %rcx, 0xb0(%rsp)
addq $0xd0, %rax
movq %rax, 0xc8(%rsp)
movslq %r9d, %rax
movq %rax, 0x28(%rsp)
leaq (,%rax,8), %r15
xorl %r12d, %r12d
movq %r11, 0x20(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x870(%r11), %rdx
movq 0x9d0(%r11), %rax
movq (%rax,%r12,8), %rax
movq 0xa8(%rsp), %rcx
movq (%r11,%rcx), %rcx
movslq (%rcx,%r12,4), %rcx
movq (%rbx,%rdi), %rsi
movq (%rsi,%r12,8), %rsi
movsd -0x8(%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movsd (%rsi,%rax,8), %xmm1
movsd %xmm1, 0x78(%rsp)
ucomisd %xmm1, %xmm0
movl (%rdx,%r12,4), %ecx
jae 0xaacd3
testl %ecx, %ecx
jle 0xab27c
movl %r8d, 0x10(%rsp)
movl %r14d, 0x38(%rsp)
movq 0x8f0(%rbx), %rax
movl (%rax,%r12,4), %edx
leaq (,%rdx,8), %rax
movq %rax, 0x18(%rsp)
xorl %edi, %edi
xorl %r8d, %r8d
testl %edx, %edx
jle 0xaacad
movq 0x900(%rbx), %rax
movl (%rax,%r12,4), %esi
movq %rdi, %r10
imulq %rsi, %r10
leaq (,%rsi,8), %r11
xorl %r14d, %r14d
testl %esi, %esi
jle 0xaaca2
movq 0xf8(%rsp), %rax
movq (%rax), %r9
movq 0xf0(%rsp), %rax
movq (%rax), %rax
movq (%r9,%r12,8), %r9
addq %r15, %r9
movq %rax, %rbp
imulq %r10, %rbp
addq %r9, %rbp
shlq $0x3, %rax
movq %rsi, %r9
movq $0x0, (%rbp)
addq %rax, %rbp
decq %r9
jne 0xaac92
incq %r14
addq %r11, %r10
cmpq %rdx, %r14
jne 0xaac60
incq %r8
addq 0x18(%rsp), %rdi
cmpq %rcx, %r8
jne 0xaac3f
movl 0x38(%rsp), %r14d
movq 0x20(%rsp), %r11
movq 0x58(%rsp), %rdi
movl 0x10(%rsp), %r8d
jmp 0xab27c
testl %ecx, %ecx
jle 0xab27c
movq 0xa0(%rsp), %rax
movq (%rbx,%rax), %rax
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xe8(%rsp)
movq 0x8f0(%rbx), %rax
movq $0x0, 0x10(%rsp)
movq %r13, 0x60(%rsp)
movl (%rax,%r12,4), %edi
testl %edi, %edi
jle 0xab25a
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
xorl %r10d, %r10d
cmpw $0x0, 0x968(%rsp)
je 0xaad40
movl 0x8bc(%rbx), %eax
cmpq %rax, %r10
jne 0xab13d
movq (%r13,%r12,8), %rax
movl (%rax,%r10,4), %eax
cmpl 0x34(%rsp), %eax
movq %r10, 0x18(%rsp)
je 0xaadc4
movq 0x948(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x998(%r11), %rdx
movl (%rdx,%r12,4), %edx
imull 0x10(%rsp), %edx
addl %eax, %edx
movslq %edx, %rax
movq (%rcx,%rax,8), %r9
movq 0x950(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq %r11, %rbp
movq %r11, %rdi
movq %rbx, %rsi
movsd 0x78(%rsp), %xmm0
movl %r12d, %edx
pushq 0x68(%rsp)
pushq (%rcx,%rax,8)
callq 0xab377
addq $0x10, %rsp
testl %eax, %eax
jne 0xab332
movq (%r13,%r12,8), %rax
movq 0x18(%rsp), %r10
movl (%rax,%r10,4), %eax
movl %eax, 0x34(%rsp)
movq %rbp, %r11
subq $0x8, %rsp
movq 0x48(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq %r11, %rdx
movq %rbx, %rcx
movq 0x70(%rsp), %r8
movsd 0xa0(%rsp), %xmm0
movsd 0x80(%rsp), %xmm1
movl %r12d, %r9d
pushq 0xb8(%rsp)
pushq 0xc8(%rsp)
pushq 0x88(%rsp)
movl 0x960(%rsp), %eax
pushq %rax
pushq 0x980(%rsp)
pushq 0xf0(%rsp)
pushq %r10
movq %r10, %r13
movq %r11, %rbp
callq 0xab53e
addq $0x40, %rsp
testl %eax, %eax
jne 0xab2f0
movq %rbx, %rdi
movq 0x960(%rsp), %rsi
movl %r12d, %edx
movl %r14d, %ecx
callq 0xac37c
movq %rbp, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %r13d, %ecx
leaq 0x54(%rsp), %r8
callq 0xac601
movq 0x900(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0xab22f
movl 0x54(%rsp), %eax
movq %rax, 0xe0(%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 0x90(%rsp), %rax
movsd 0x310(%rax), %xmm0
subsd 0x98(%rsp), %xmm0
mulsd 0x918(%rbx), %xmm0
movq 0x28(%rsp), %rax
movsd (%rcx,%rax,8), %xmm1
subq $0x8, %rsp
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rbx, %rdx
movl %r12d, %ecx
movl %r10d, %r9d
movsd %xmm2, 0x40(%rsp)
leaq 0x16(%rsp), %rax
pushq %rax
callq 0xac756
addq $0x10, %rsp
movq 0x960(%rsp), %rax
movl 0xc0(%rax), %eax
cmpl $0x1, %eax
jne 0xaaf69
movq 0x960(%rsp), %rax
movsd 0xb8(%rax), %xmm0
ucomisd 0x4332f(%rip), %xmm0    # 0xee258
jb 0xaaf31
sqrtsd %xmm0, %xmm0
jmp 0xaaf36
callq 0x82b0
movsd 0xe8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0x4334d(%rip), %xmm1    # 0xee298
cvttsd2si %xmm1, %eax
cmpl %eax, %r14d
jl 0xaaf5b
movw $0x1, 0xe(%rsp)
movq 0x960(%rsp), %rax
movl 0xc0(%rax), %eax
testl %eax, %eax
movl %r13d, %r14d
movzwl 0x968(%rsp), %r13d
movq 0x18(%rsp), %r10
je 0xaafb5
cmpl %r14d, 0x938(%rbx)
jle 0xaafb5
testw %r13w, %r13w
jne 0xaafb5
movq 0x960(%rsp), %rcx
movslq 0x1c(%rcx), %rcx
cmpq %rcx, %rbp
jl 0xaafb5
movw $0x1, 0xe(%rsp)
movq 0x8f0(%rbx), %rcx
movq 0x900(%rbx), %rax
jmp 0xab023
cmpw $0x1, 0xe(%rsp)
jne 0xaafff
movq 0x8f0(%rbx), %rcx
movq 0x900(%rbx), %rax
testw %r13w, %r13w
je 0xab023
movq 0x88(%rsp), %rdx
movq (%rdx), %rdx
movl (%rax,%r12,4), %eax
movl (%rcx,%r12,4), %ecx
imull 0x10(%rsp), %ecx
addl %r10d, %ecx
imull %eax, %ecx
movslq %ecx, %rcx
addq %rbp, %rcx
movq 0x80(%rsp), %rsi
jmp 0xab04f
testw %r13w, %r13w
jne 0xab0c1
testl %eax, %eax
je 0xab06d
movq 0x920(%rbx), %rax
movq 0x928(%rbx), %rcx
movsd -0x8(%rcx,%rax,8), %xmm0
jmp 0xab090
movq 0xd0(%rsp), %rdx
movq (%rdx), %rdx
movl (%rax,%r12,4), %eax
movl (%rcx,%r12,4), %ecx
imull 0x10(%rsp), %ecx
addl %r10d, %ecx
imull %eax, %ecx
movslq %ecx, %rcx
addq %rbp, %rcx
movq 0xd8(%rsp), %rsi
imulq (%rsi), %rcx
shlq $0x3, %rcx
addq (%rdx,%r12,8), %rcx
movq 0x28(%rsp), %rdx
movq $0x0, (%rcx,%rdx,8)
jmp 0xab120
movq 0x960(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x38(%rax), %rcx
movslq 0x30(%rax), %rax
movsd -0x8(%rcx,%rax,8), %xmm0
movq 0x70(%rsp), %rax
divsd (%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
movl %r12d, %ecx
movl %r10d, %r8d
movsd 0x38(%rsp), %xmm0
movq 0xc8(%rsp), %r9
callq 0xac933
movq 0x18(%rsp), %r10
subq $0x8, %rsp
movswl %r13w, %eax
movq 0x968(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rcx
movl %r14d, %r8d
movl %r12d, %r9d
movsd 0x40(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
pushq %rax
pushq 0xf0(%rsp)
pushq %rbp
pushq %r10
pushq 0x38(%rsp)
callq 0xac9f4
addq $0x30, %rsp
testl %eax, %eax
jne 0xab28f
movq 0x900(%rbx), %rax
movl (%rax,%r12,4), %eax
movq 0x18(%rsp), %r10
incq %rbp
cltq
cmpq %rax, %rbp
jl 0xaae8a
movq 0x60(%rsp), %r13
movq 0x20(%rsp), %r11
jmp 0xab23c
movq 0x900(%rbx), %rax
movslq (%rax,%r12,4), %r8
testq %r8, %r8
jle 0xab23c
movq 0x88(%rsp), %rax
movq (%rax), %rcx
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq (%rcx,%r12,8), %rcx
addq %r15, %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 0x43acc(%rip), %xmm1    # 0xeec80
movdqa %xmm0, %xmm2
movdqa 0x43ad0(%rip), %xmm4    # 0xeec90
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 0xab200
movq $0x0, (%rcx,%rsi)
pxor 0x73198(%rip), %xmm2    # 0x11e3a0
pextrw $0x4, %xmm2, %r8d
testb $0x1, %r8b
je 0xab21c
movq $0x0, (%rcx,%rdi)
paddq 0x4456c(%rip), %xmm1    # 0xef790
addq %rax, %rcx
addq $-0x2, %rdx
jne 0xab1b4
jmp 0xab23c
movq 0x18(%rsp), %r10
movq 0x60(%rsp), %r13
movq %rbp, %r11
incq %r10
movq 0x8f0(%rbx), %rax
movslq (%rax,%r12,4), %rdi
cmpq %rdi, %r10
jl 0xaad26
movq 0x870(%r11), %rdx
movq 0x10(%rsp), %rcx
incl %ecx
movq %rcx, 0x10(%rsp)
cmpl (%rdx,%r12,4), %ecx
jl 0xaad0f
movl 0x8a4(%rbx), %r8d
movq 0x58(%rsp), %rdi
incq %r12
movslq %r8d, %rax
cmpq %rax, %r12
jl 0xaabc2
xorl %eax, %eax
jmp 0xab2de
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x43153(%rip), %rsi     # 0xee3f0
leaq 0x741cc(%rip), %rdx     # 0x11f470
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x42d74(%rip), %rsi     # 0xee034
leaq 0x740f0(%rip), %rdx     # 0x11f3b7
movq %rbx, %rdi
movl $0x843, %ecx            # imm = 0x843
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x908, %rsp            # imm = 0x908
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x430f2(%rip), %rsi     # 0xee3f0
leaq 0x740ce(%rip), %rdx     # 0x11f3d3
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x42d13(%rip), %rsi     # 0xee034
leaq 0x7408f(%rip), %rdx     # 0x11f3b7
movq %rbx, %rdi
movl $0x7d5, %ecx            # imm = 0x7D5
jmp 0xab2cf
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x430b0(%rip), %rsi     # 0xee3f0
leaq 0x73f43(%rip), %rdx     # 0x11f28a
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x42cd1(%rip), %rsi     # 0xee034
leaq 0x7404d(%rip), %rdx     # 0x11f3b7
movq %rbx, %rdi
movl $0x7b6, %ecx            # imm = 0x7B6
jmp 0xab2cf