// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_sources
int transfer_sources(
                     struct precision * ppr,
                     struct background * pba,
                     struct perturbations * ppt,
                     struct transfer * ptr,
                     double * interpolated_sources,
                     double tau_rec,
                     double k,
                     int index_md,
                     int index_tt,
                     double * sources,
                     double * window,
                     int tau_size_max,
                     double * tau0_minus_tau,
                     double * w_trapz,
                     int * tau_size_out
                     )  {

  /** Summary: */

  /** - define local variables */

  /* index running on time */
  int index_tau;

  /* bin for computation of cl_density */
  int bin=0;

  /* number of tau values */
  int tau_size;

  /* minimum tau index kept in transfer sources */
  int index_tau_min;

  /* conformal time */
  double tau, tau0;

  /* rescaling factor depending on the background at a given time */
  double rescaling=0.;

  /* flag: is there any difference between the perturbation and transfer source? */
  short redefine_source;

  /** - in which cases are perturbation and transfer sources are different?
      I.e., in which case do we need to multiply the sources by some
      background and/or window function, and eventually to resample it,
      or redefine its time limits? */

  redefine_source = _FALSE_;

  if (_scalars_) {

    /* cmb lensing potential */
    if ((ppt->has_cl_cmb_lensing_potential == _TRUE_) && (index_tt == ptr->index_tt_lcmb))
      redefine_source = _TRUE_;

    /* number count Cl's */
    if (_nonintegrated_ncl_ || _integrated_ncl_)
      redefine_source = _TRUE_;

  }

  /* conformal time today */
  tau0 = pba->conformal_age;

  /** - case where we need to redefine by a window function (or any
      function of the background and of k) */
  if (redefine_source == _TRUE_) {

    class_call(transfer_source_tau_size(ppr,
                                        pba,
                                        ppt,
                                        ptr,
                                        tau_rec,
                                        tau0,
                                        index_md,
                                        index_tt,
                                        &tau_size),
               ptr->error_message,
               ptr->error_message);

    if (_scalars_) {

      /* lensing source: throw away times before recombination, and multiply psi by window function */

      if ((ppt->has_cl_cmb_lensing_potential == _TRUE_) && (index_tt == ptr->index_tt_lcmb)) {

        /* first time step after removing early times */
        index_tau_min =  ppt->tau_size - tau_size;

        /* loop over time and rescale */
        for (index_tau = index_tau_min; index_tau < ppt->tau_size; index_tau++) {

          /* conformal time */
          tau = ppt->tau_sampling[index_tau];

          /* lensing source =  - W(tau) (phi(k,tau) + psi(k,tau)) Heaviside(tau-tau_rec)
             with
             psi,phi = metric perturbation in newtonian gauge (phi+psi = Phi_A-Phi_H of Bardeen)
             W = (tau-tau_rec)/(tau_0-tau)/(tau_0-tau_rec)
             H(x) = Heaviside
             (in tau = tau_0, set source = 0 to avoid division by zero;
             regulated anyway by Bessel).
          */

          if (index_tau == ppt->tau_size-1) {
            rescaling=0.;
          }
          else {
            switch (pba->sgnK){
            case 1:
              rescaling = sqrt(pba->K)
                *sin((tau_rec-tau)*sqrt(pba->K))
                /sin((tau0-tau)*sqrt(pba->K))
                /sin((tau0-tau_rec)*sqrt(pba->K));
              break;
            case 0:
              rescaling = (tau_rec-tau)/(tau0-tau)/(tau0-tau_rec);
              break;
            case -1:
              rescaling = sqrt(-pba->K)
                *sinh((tau_rec-tau)*sqrt(-pba->K))
                /sinh((tau0-tau)*sqrt(-pba->K))
                /sinh((tau0-tau_rec)*sqrt(-pba->K));
              break;
            }
            // Note: until 2.4.3 there was a bug here: the curvature effects had been omitted.
          }

          /* copy from input array to output array */
          sources[index_tau-index_tau_min] =
            interpolated_sources[index_tau]
            * rescaling
            * ptr->lcmb_rescale
            * pow(k/ptr->lcmb_pivot,ptr->lcmb_tilt);

          /* store value of (tau0-tau) */
          tau0_minus_tau[index_tau-index_tau_min] = tau0 - tau;

        }

        /* Compute trapezoidal weights for integration over tau */
        class_call(array_trapezoidal_mweights(tau0_minus_tau,
                                              tau_size,
                                              w_trapz,
                                              ptr->error_message),
                   ptr->error_message,
                   ptr->error_message);
      }

      /* Non-integrated contributions to dCl/nCl need selection time sampling*/

      if (_nonintegrated_ncl_) {

        _get_bin_nonintegrated_ncl_(index_tt)

          /* redefine the time sampling */
          class_call(transfer_selection_sampling(ppr,
                                                 pba,
                                                 ppt,
                                                 ptr,
                                                 bin,
                                                 tau0_minus_tau,
                                                 tau_size),
                     ptr->error_message,
                     ptr->error_message);

        class_test(tau0 - tau0_minus_tau[0] > ppt->tau_sampling[ppt->tau_size-1],
                   ptr->error_message,
                   "this should not happen, there was probably a rounding error, if this error occurred, then this must be coded more carefully");

        /* resample the source at those times */
        class_call(transfer_source_resample(ppr,
                                            pba,
                                            ppt,
                                            ptr,
                                            bin,
                                            tau0_minus_tau,
                                            tau_size,
                                            index_md,
                                            tau0,
                                            interpolated_sources,
                                            sources),
                   ptr->error_message,
                   ptr->error_message);

        /* Compute trapezoidal weights for integration over tau */
        class_call(array_trapezoidal_mweights(tau0_minus_tau,
                                              tau_size,
                                              w_trapz,
                                              ptr->error_message),
                   ptr->error_message,
                   ptr->error_message);

        /* loop over time and rescale */
        for (index_tau = 0; index_tau < tau_size; index_tau++) {

          /* matter density source =  [- (dz/dtau) W(z)] * delta_m(k,tau)
             = W(tau) delta_m(k,tau)
             with
             delta_m = total matter perturbation (defined in gauge-independent way, see arXiv 1307.1459)
             W(z) = redshift space selection function = dN/dz
             W(tau) = same wrt conformal time = dN/dtau
             (in tau = tau_0, set source = 0 to avoid division by zero;
             regulated anyway by Bessel).
          */

          rescaling = window[index_tt*tau_size_max+index_tau];

          if (_index_tt_in_range_(ptr->index_tt_d0,      ppt->selection_num, ppt->has_nc_rsd))
            rescaling *= 1./k/k; // Factor from original ClassGAL paper ( arXiv 1307.1459 )

          if (_index_tt_in_range_(ptr->index_tt_d1,      ppt->selection_num, ppt->has_nc_rsd))
            rescaling *= 1./k; // Factor from original ClassGAL paper ( arXiv 1307.1459 )

          sources[index_tau] *= rescaling;
        }
      }
      /* End normal contributions */

      /* Integrated contributions to dCl/nCl/sCl need integrated selection time sampling */

      if (_integrated_ncl_) {

        _get_bin_integrated_ncl_(index_tt)

          /* redefine the time sampling */
          class_call(transfer_lensing_sampling(ppr,
                                               pba,
                                               ppt,
                                               ptr,
                                               bin,
                                               tau0,
                                               tau0_minus_tau,
                                               tau_size),
                     ptr->error_message,
                     ptr->error_message);

        /* resample the source at those times */
        class_call(transfer_source_resample(ppr,
                                            pba,
                                            ppt,
                                            ptr,
                                            bin,
                                            tau0_minus_tau,
                                            tau_size,
                                            index_md,
                                            tau0,
                                            interpolated_sources,
                                            sources),
                   ptr->error_message,
                   ptr->error_message);

        /* Compute trapezoidal weights for integration over tau */
        class_call(array_trapezoidal_mweights(tau0_minus_tau,
                                              tau_size,
                                              w_trapz,
                                              ptr->error_message),
                   ptr->error_message,
                   ptr->error_message);

        /* loop over time and rescale */
        for (index_tau = 0; index_tau < tau_size; index_tau++) {

          /* lensing source =  - W(tau) (phi(k,tau) + psi(k,tau)) Heaviside(tau-tau_rec)
             with
             psi,phi = metric perturbation in newtonian gauge (phi+psi = Phi_A-Phi_H of Bardeen)
             W = (tau-tau_rec)/(tau_0-tau)/(tau_0-tau_rec)
             H(x) = Heaviside
             (in tau = tau_0, set source = 0 to avoid division by zero;
             regulated anyway by Bessel).
          */

          /* copy from input array to output array */
          sources[index_tau] *= window[index_tt*tau_size_max+index_tau];

          if (_index_tt_in_range_(ptr->index_tt_nc_g5, ppt->selection_num, ppt->has_nc_gr))
            sources[index_tau] *= k; // Factor from chi derivative of d/dchi j_ell(k*chi)= d/d(kchi) j_ell(k chi) * k = k * j_ell'(kchi)
        }
      }
      /* End integrated contributions */
    }
  }

  /** - case where we do not need to redefine */

  else {

    /* number of sampled time values */
    tau_size = ppt->tau_size;

    /* plain copy from input array to output array */
    memcpy(sources,
           interpolated_sources,
           ppt->tau_size*sizeof(double));

    /* store values of (tau0-tau) */
    for (index_tau=0; index_tau < ppt->tau_size; index_tau++) {
      tau0_minus_tau[index_tau] = tau0 - ppt->tau_sampling[index_tau];
    }

    /* Compute trapezoidal weights for integration over tau */
    class_call(array_trapezoidal_mweights(tau0_minus_tau,
                                          tau_size,
                                          w_trapz,
                                          ptr->error_message),
               ptr->error_message,
               ptr->error_message);
  }

  /** - return tau_size value that will be stored in the workspace (the
      workspace wants a double) */

  *tau_size_out = tau_size;

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1098, %rsp           # imm = 0x1098
movq %rcx, %rbx
movq %rdx, %r14
movq 0x10f0(%rsp), %r13
movq 0x10d8(%rsp), %r10
cmpw $0x1, 0xe(%rdx)
jne 0xab75a
movl %r9d, %ebp
cmpl %r9d, 0x848(%r14)
jne 0xab75a
movl 0x10d0(%rsp), %r9d
movb $0x1, %al
cmpw $0x1, 0x2c(%r14)
jne 0xab59c
cmpl %r9d, 0x8bc(%rbx)
setne %al
cmpw $0x1, 0x3e(%r14)
jne 0xab5bc
movl 0x8c0(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xab5bc
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xab6cd
cmpw $0x1, 0x40(%r14)
jne 0xab60c
movl 0x8c8(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xab5dc
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xab6cd
movl 0x8cc(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xab5f4
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xab6cd
movl 0x8d0(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xab60c
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xab6cd
movzwl 0x44(%r14), %ecx
cmpw $0x1, %cx
jne 0xab65b
movl 0x8d8(%rbx), %edx
cmpl %r9d, %edx
jg 0xab62f
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xab6cd
movl 0x8dc(%rbx), %edx
cmpl %r9d, %edx
jg 0xab647
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xab6cd
movl 0x8e0(%rbx), %edx
cmpl %r9d, %edx
jg 0xab65b
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xab6cd
cmpw $0x1, 0x2e(%r14)
jne 0xab677
movl 0x8c4(%rbx), %edx
cmpl %r9d, %edx
jg 0xab677
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xab6cd
cmpw $0x1, 0x42(%r14)
jne 0xab693
movl 0x8d4(%rbx), %edx
cmpl %r9d, %edx
jg 0xab693
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xab6cd
cmpw $0x1, %cx
jne 0xabc84
movl 0x8e4(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xab6b1
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xab6cd
movl 0x8e8(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xabc84
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jle 0xabc84
movsd 0x310(%rsi), %xmm2
movsd %xmm2, 0x38(%rsp)
movq %r8, 0x68(%rsp)
movsd %xmm1, 0x60(%rsp)
leaq 0x44(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, %r12
movq %r14, %rdx
movq %rbx, %rcx
movsd %xmm0, 0x78(%rsp)
movapd %xmm2, %xmm1
movl %ebp, %r8d
movq %rsi, %r15
callq 0xaa264
testl %eax, %eax
je 0xab82c
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x42ccd(%rip), %rsi     # 0xee3f0
leaq 0x73dfa(%rip), %rdx     # 0x11f524
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x428ee(%rip), %rsi     # 0xee034
leaq 0x73e32(%rip), %rdx     # 0x11f57f
movq %rbx, %rdi
movl $0x956, %ecx            # imm = 0x956
jmp 0xab818
movsd 0x310(%rsi), %xmm2
movsd %xmm2, 0x38(%rsp)
movslq 0x9f8(%r14), %r12
movl %r12d, 0x44(%rsp)
movq %r12, %rdx
shlq $0x3, %rdx
movq %r10, %rdi
movq %r8, %rsi
callq 0x82d0
movsd 0x38(%rsp), %xmm1
movslq 0x9f8(%r14), %rax
testq %rax, %rax
jle 0xab7b9
movq 0x9f0(%r14), %rcx
xorl %edx, %edx
movapd %xmm1, %xmm0
subsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%r13,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xab7a1
addq $0x96a, %rbx            # imm = 0x96A
movq %r13, %rdi
movl %r12d, %esi
movq 0x10f8(%rsp), %rdx
movq %rbx, %rcx
callq 0x1b4a6
cmpl $0x1, %eax
jne 0xac35a
leaq 0x42c0a(%rip), %rsi     # 0xee3f0
leaq 0x73da3(%rip), %rdx     # 0x11f590
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4282b(%rip), %rsi     # 0xee034
leaq 0x73d6f(%rip), %rdx     # 0x11f57f
movq %rbx, %rdi
movl $0xa3a, %ecx            # imm = 0xA3A
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0xac36a
movl 0x10d0(%rsp), %eax
movq %r12, 0x50(%rsp)
movq %r15, 0x30(%rsp)
cmpw $0x1, 0xe(%r14)
jne 0xac35a
cmpl %ebp, 0x848(%r14)
jne 0xac35a
cmpw $0x1, 0x2c(%r14)
movq 0x10d8(%rsp), %r15
movl %eax, %r12d
jne 0xabc99
cmpl %r12d, 0x8bc(%rbx)
jne 0xabc99
movl 0x44(%rsp), %eax
movl %eax, 0x74(%rsp)
testl %eax, %eax
movsd 0x38(%rsp), %xmm2
jle 0xabc10
movl 0x9f8(%r14), %eax
movl %eax, %ecx
subl 0x74(%rsp), %ecx
movapd %xmm2, %xmm0
subsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x88(%rsp)
movslq %ecx, %rbp
movq %r13, %r15
movq 0x10d8(%rsp), %r12
xorpd %xmm0, %xmm0
movq 0x9f0(%r14), %rcx
movsd (%rcx,%rbp,8), %xmm1
movsd %xmm1, 0x58(%rsp)
decl %eax
xorpd %xmm4, %xmm4
cmpl %eax, %ebp
movsd 0x60(%rsp), %xmm1
movq 0x68(%rsp), %rcx
je 0xabba2
movq 0x30(%rsp), %rdx
movl 0x320(%rdx), %eax
cmpl $-0x1, %eax
je 0xab95f
testl %eax, %eax
je 0xab935
movapd %xmm0, %xmm4
cmpl $0x1, %eax
jne 0xabba2
movq 0x30(%rsp), %rax
movsd 0x318(%rax), %xmm0
ucomisd 0x42935(%rip), %xmm0    # 0xee258
jb 0xaba9e
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0xabaac
movsd 0x78(%rsp), %xmm4
movsd 0x58(%rsp), %xmm3
subsd %xmm3, %xmm4
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
divsd %xmm0, %xmm4
divsd 0x88(%rsp), %xmm4
jmp 0xabba2
movsd 0x318(%rdx), %xmm0
movsd 0x45b99(%rip), %xmm1    # 0xf1508
ucomisd %xmm0, %xmm1
xorpd 0x428b5(%rip), %xmm0    # 0xee230
jb 0xab986
xorps %xmm2, %xmm2
sqrtsd %xmm0, %xmm2
jmp 0xab994
callq 0x82b0
movq 0x30(%rsp), %rdx
movapd %xmm0, %xmm2
movsd 0x318(%rdx), %xmm0
movsd 0x45b64(%rip), %xmm1    # 0xf1508
ucomisd %xmm0, %xmm1
xorpd 0x42880(%rip), %xmm0    # 0xee230
movsd %xmm2, 0x28(%rsp)
jb 0xab9be
sqrtsd %xmm0, %xmm0
jmp 0xab9c3
callq 0x82b0
movsd 0x78(%rsp), %xmm1
subsd 0x58(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8370
movapd %xmm0, %xmm2
movq 0x30(%rsp), %rax
movsd 0x318(%rax), %xmm0
movsd 0x45b13(%rip), %xmm1    # 0xf1508
ucomisd %xmm0, %xmm1
xorpd 0x4282f(%rip), %xmm0    # 0xee230
movsd %xmm2, 0x48(%rsp)
jb 0xaba0f
sqrtsd %xmm0, %xmm0
jmp 0xaba14
callq 0x82b0
movsd 0x38(%rsp), %xmm1
subsd 0x58(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8370
movapd %xmm0, %xmm3
movq 0x30(%rsp), %rax
movsd 0x318(%rax), %xmm0
movsd 0x45ac2(%rip), %xmm1    # 0xf1508
ucomisd %xmm0, %xmm1
xorpd 0x427de(%rip), %xmm0    # 0xee230
jb 0xaba5a
sqrtsd %xmm0, %xmm0
jmp 0xaba71
movsd %xmm3, 0x80(%rsp)
callq 0x82b0
movsd 0x80(%rsp), %xmm3
movsd 0x28(%rsp), %xmm1
movsd 0x48(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd 0x88(%rsp), %xmm0
callq 0x8370
jmp 0xabb8d
callq 0x82b0
movq 0x30(%rsp), %rax
movapd %xmm0, %xmm1
movsd 0x318(%rax), %xmm0
ucomisd 0x4279c(%rip), %xmm0    # 0xee258
movsd %xmm1, 0x28(%rsp)
jb 0xabaca
sqrtsd %xmm0, %xmm0
jmp 0xabacf
callq 0x82b0
movsd 0x78(%rsp), %xmm1
subsd 0x58(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x80a0
movapd %xmm0, %xmm1
movq 0x30(%rsp), %rax
movsd 0x318(%rax), %xmm0
ucomisd 0x42757(%rip), %xmm0    # 0xee258
movsd %xmm1, 0x48(%rsp)
jb 0xabb0f
sqrtsd %xmm0, %xmm0
jmp 0xabb14
callq 0x82b0
movsd 0x38(%rsp), %xmm1
subsd 0x58(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x80a0
movapd %xmm0, %xmm3
movq 0x30(%rsp), %rax
movsd 0x318(%rax), %xmm0
ucomisd 0x42712(%rip), %xmm0    # 0xee258
jb 0xabb4e
sqrtsd %xmm0, %xmm0
jmp 0xabb65
movsd %xmm3, 0x80(%rsp)
callq 0x82b0
movsd 0x80(%rsp), %xmm3
movsd 0x28(%rsp), %xmm1
movsd 0x48(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd 0x88(%rsp), %xmm0
callq 0x80a0
movsd 0x28(%rsp), %xmm4
divsd %xmm0, %xmm4
movsd 0x60(%rsp), %xmm1
movq 0x68(%rsp), %rcx
movsd %xmm4, 0x28(%rsp)
movsd (%rcx,%rbp,8), %xmm0
mulsd %xmm4, %xmm0
mulsd (%rbx), %xmm0
movsd %xmm0, 0x48(%rsp)
movapd %xmm1, %xmm0
divsd 0x10(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
callq 0x8620
movsd 0x38(%rsp), %xmm2
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, (%r12)
movapd %xmm2, %xmm0
subsd 0x58(%rsp), %xmm0
movsd %xmm0, (%r15)
incq %rbp
movslq 0x9f8(%r14), %rax
addq $0x8, %r12
addq $0x8, %r15
movsd 0x28(%rsp), %xmm0
cmpq %rax, %rbp
jl 0xab8c2
leaq 0x96a(%rbx), %rbp
movq %r13, %rdi
movl 0x74(%rsp), %esi
movq 0x10f8(%rsp), %rdx
movq %rbp, %rcx
callq 0x1b4a6
cmpl $0x1, %eax
movq 0x10d8(%rsp), %r15
movl 0x10d0(%rsp), %r12d
jne 0xabc99
leaq 0x427a6(%rip), %rsi     # 0xee3f0
leaq 0x7393f(%rip), %rdx     # 0x11f590
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x423c7(%rip), %rsi     # 0xee034
leaq 0x7390b(%rip), %rdx     # 0x11f57f
movq %rbp, %rdi
movl $0x99a, %ecx            # imm = 0x99A
movq %rbx, %r8
jmp 0xab81b
movsd 0x310(%rsi), %xmm2
testb %al, %al
je 0xab6d5
jmp 0xab762
movzwl 0x3e(%r14), %ecx
cmpw $0x1, %cx
movq 0x30(%rsp), %rsi
jne 0xabcc4
movl 0x8c0(%rbx), %edx
cmpl %r12d, %edx
jg 0xabcc4
movl 0x64(%r14), %eax
leal (%rax,%rdx), %edi
cmpl %r12d, %edi
jg 0xabd77
cmpw $0x1, 0x40(%r14)
jne 0xabd12
movl 0x8c8(%rbx), %edx
cmpl %r12d, %edx
jg 0xabce6
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jg 0xabd6b
movl 0x8cc(%rbx), %edx
cmpl %r12d, %edx
jg 0xabcfc
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jg 0xabd6b
movl 0x8d0(%rbx), %edx
cmpl %r12d, %edx
jg 0xabd12
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jg 0xabd6b
xorl %r8d, %r8d
cmpw $0x1, 0x44(%r14)
jne 0xac0b1
movl 0x8d8(%rbx), %edx
cmpl %r12d, %edx
jg 0xabd37
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jg 0xabd6b
movl 0x8dc(%rbx), %edx
cmpl %r12d, %edx
jg 0xabd4d
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jg 0xabd6b
movl 0x8e0(%rbx), %edx
cmpl %r12d, %edx
jg 0xac0b1
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jle 0xac0b1
cmpw $0x1, %cx
jne 0xabd7e
movl 0x8c0(%rbx), %edx
movl %r12d, %ecx
subl %edx, %ecx
jge 0xabd83
xorl %r8d, %r8d
jmp 0xabd8f
addl %eax, %edx
xorl %r8d, %r8d
cmpl %r12d, %edx
cmovgl %ecx, %r8d
cmpw $0x1, 0x40(%r14)
jne 0xabde7
movl 0x8c8(%rbx), %ecx
movl 0x8cc(%rbx), %edx
movl %r12d, %r9d
subl %ecx, %r9d
leal (%rax,%rcx), %edi
cmpl %r12d, %edi
cmovlel %r8d, %r9d
cmpl %ecx, %r12d
cmovll %r8d, %r9d
movl %r12d, %r8d
subl %edx, %r8d
leal (%rax,%rdx), %ecx
cmpl %r12d, %ecx
cmovlel %r9d, %r8d
cmpl %edx, %r12d
cmovll %r9d, %r8d
movl 0x8d0(%rbx), %edx
movl %r12d, %ecx
subl %edx, %ecx
jl 0xabde7
addl %eax, %edx
cmpl %r12d, %edx
cmovgl %ecx, %r8d
cmpw $0x1, 0x44(%r14)
jne 0xabe3f
movl 0x8d8(%rbx), %ecx
movl 0x8dc(%rbx), %edx
movl %r12d, %r9d
subl %ecx, %r9d
leal (%rax,%rcx), %edi
cmpl %r12d, %edi
cmovlel %r8d, %r9d
cmpl %ecx, %r12d
cmovll %r8d, %r9d
movl %r12d, %r8d
subl %edx, %r8d
leal (%rax,%rdx), %ecx
cmpl %r12d, %ecx
cmovlel %r9d, %r8d
cmpl %edx, %r12d
cmovll %r9d, %r8d
movl 0x8e0(%rbx), %edx
movl %r12d, %ecx
subl %edx, %ecx
jl 0xabe3f
addl %edx, %eax
cmpl %r12d, %eax
cmovgl %ecx, %r8d
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %ebp
movl %ebp, (%rsp)
movq %r14, %rdx
movq %rbx, %rcx
movl %r8d, %r12d
movq %r13, %r9
callq 0xaccf9
testl %eax, %eax
je 0xabea5
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x42582(%rip), %rsi     # 0xee3f0
leaq 0x7376d(%rip), %rdx     # 0x11f5e2
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x421a3(%rip), %rsi     # 0xee034
leaq 0x736e7(%rip), %rdx     # 0x11f57f
movq %rbx, %rdi
movl $0x9ac, %ecx            # imm = 0x9AC
jmp 0xab818
movl %r12d, 0x28(%rsp)
movsd 0x38(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%r13), %xmm1
movq 0x9f0(%r14), %rax
movslq 0x9f8(%r14), %rcx
ucomisd -0x8(%rax,%rcx,8), %xmm1
jbe 0xabf31
leaq 0x7375a(%rip), %rsi     # 0x11f631
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x42192(%rip), %rsi     # 0xee082
leaq 0x737b6(%rip), %rdx     # 0x11f6ad
leaq 0x890(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x4211a(%rip), %rsi     # 0xee034
leaq 0x7365e(%rip), %rdx     # 0x11f57f
movq %rbx, %rdi
movl $0x9b0, %ecx            # imm = 0x9B0
movq %r15, %r8
jmp 0xab81b
movq %r15, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movl %ebp, (%rsp)
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r9
callq 0xacee7
testl %eax, %eax
je 0xabf9a
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x4248d(%rip), %rsi     # 0xee3f0
leaq 0x73781(%rip), %rdx     # 0x11f6eb
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x420ae(%rip), %rsi     # 0xee034
leaq 0x735f2(%rip), %rdx     # 0x11f57f
movq %rbx, %rdi
movl $0x9bf, %ecx            # imm = 0x9BF
jmp 0xab818
leaq 0x96a(%rbx), %r12
movq %r13, %rdi
movl %ebp, %esi
movq 0x10f8(%rsp), %rdx
movq %r12, %rcx
callq 0x1b4a6
cmpl $0x1, %eax
jne 0xabff9
leaq 0x4242e(%rip), %rsi     # 0xee3f0
leaq 0x735c7(%rip), %rdx     # 0x11f590
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4204f(%rip), %rsi     # 0xee034
leaq 0x73593(%rip), %rdx     # 0x11f57f
movq %r12, %rdi
movl $0x9c7, %ecx            # imm = 0x9C7
jmp 0xabc7c
testl %ebp, %ebp
jle 0xac09f
movl 0x10e8(%rsp), %ecx
movl 0x10d0(%rsp), %r12d
imull %r12d, %ecx
movzwl 0x40(%r14), %eax
movsd 0x4223f(%rip), %xmm0    # 0xee260
movsd 0x60(%rsp), %xmm2
divsd %xmm2, %xmm0
movapd %xmm0, %xmm1
divsd %xmm2, %xmm1
movslq %ecx, %rcx
movq 0x10e0(%rsp), %r9
leaq (%r9,%rcx,8), %rcx
xorl %edx, %edx
movq 0x30(%rsp), %rsi
movl 0x28(%rsp), %r8d
movsd (%rcx,%rdx,8), %xmm2
cmpw $0x1, %ax
jne 0xac089
movl 0x8cc(%rbx), %edi
cmpl %r12d, %edi
jg 0xac071
addl 0x64(%r14), %edi
cmpl %r12d, %edi
jle 0xac071
mulsd %xmm1, %xmm2
movl 0x8d0(%rbx), %edi
cmpl %r12d, %edi
jg 0xac089
addl 0x64(%r14), %edi
cmpl %r12d, %edi
jle 0xac089
mulsd %xmm0, %xmm2
mulsd (%r15,%rdx,8), %xmm2
movsd %xmm2, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0xac04e
jmp 0xac0b1
movq 0x30(%rsp), %rsi
movl 0x10d0(%rsp), %r12d
movl 0x28(%rsp), %r8d
movzwl 0x2e(%r14), %ecx
cmpw $0x1, %cx
jne 0xac0d3
movl 0x8c4(%rbx), %edx
cmpl %r12d, %edx
jg 0xac0d3
movl 0x64(%r14), %eax
leal (%rax,%rdx), %edi
cmpl %r12d, %edi
jg 0xac142
cmpw $0x1, 0x42(%r14)
jne 0xac0f1
movl 0x8d4(%rbx), %edx
cmpl %r12d, %edx
jg 0xac0f1
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jg 0xac131
cmpw $0x1, 0x44(%r14)
jne 0xac35a
movl 0x8e4(%rbx), %edx
cmpl %r12d, %edx
jg 0xac113
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jg 0xac131
movl 0x8e8(%rbx), %edx
cmpl %r12d, %edx
jg 0xac35a
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r12d, %edx
jle 0xac35a
cmpw $0x1, %cx
jne 0xac154
movl 0x8c4(%rbx), %edx
movq 0x30(%rsp), %rsi
movl %r12d, %ecx
subl %edx, %ecx
jl 0xac159
addl %eax, %edx
cmpl %r12d, %edx
cmovgl %ecx, %r8d
jmp 0xac159
movq 0x30(%rsp), %rsi
movsd 0x38(%rsp), %xmm0
cmpw $0x1, 0x42(%r14)
jne 0xac17d
movl 0x8d4(%rbx), %edx
movl %r12d, %ecx
subl %edx, %ecx
jl 0xac17d
addl %eax, %edx
cmpl %r12d, %edx
cmovgl %ecx, %r8d
cmpw $0x1, 0x44(%r14)
jne 0xac1b8
movl 0x8e4(%rbx), %edx
movl 0x8e8(%rbx), %ecx
movl %r12d, %r9d
subl %edx, %r9d
leal (%rax,%rdx), %edi
cmpl %r12d, %edi
cmovlel %r8d, %r9d
cmpl %edx, %r12d
cmovgel %r9d, %r8d
movl %r12d, %edx
subl %ecx, %edx
jl 0xac1b8
addl %ecx, %eax
cmpl %r12d, %eax
cmovgl %edx, %r8d
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %ebp
movl %ebp, (%rsp)
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r9
callq 0xad03d
testl %eax, %eax
je 0xac21b
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x4220c(%rip), %rsi     # 0xee3f0
leaq 0x7357b(%rip), %rdx     # 0x11f766
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x41e2d(%rip), %rsi     # 0xee034
leaq 0x73371(%rip), %rdx     # 0x11f57f
movq %rbx, %rdi
movl $0x9f3, %ecx            # imm = 0x9F3
jmp 0xab818
movq %r15, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movl %ebp, (%rsp)
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r9
movsd 0x38(%rsp), %xmm0
callq 0xacee7
testl %eax, %eax
je 0xac28a
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x4219d(%rip), %rsi     # 0xee3f0
leaq 0x73491(%rip), %rdx     # 0x11f6eb
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x41dbe(%rip), %rsi     # 0xee034
leaq 0x73302(%rip), %rdx     # 0x11f57f
movq %rbx, %rdi
movl $0xa02, %ecx            # imm = 0xA02
jmp 0xab818
leaq 0x96a(%rbx), %r12
movq %r13, %rdi
movl %ebp, %esi
movq 0x10f8(%rsp), %rdx
movq %r12, %rcx
callq 0x1b4a6
cmpl $0x1, %eax
jne 0xac2e9
leaq 0x4213e(%rip), %rsi     # 0xee3f0
leaq 0x732d7(%rip), %rdx     # 0x11f590
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x41d5f(%rip), %rsi     # 0xee034
leaq 0x732a3(%rip), %rdx     # 0x11f57f
movq %r12, %rdi
movl $0xa0a, %ecx            # imm = 0xA0A
jmp 0xabc7c
testl %ebp, %ebp
movq 0x10d8(%rsp), %rdi
movl 0x10d0(%rsp), %r8d
movq 0x10e0(%rsp), %r15
movl 0x10e8(%rsp), %ecx
jle 0xac35a
imull %r8d, %ecx
movzwl 0x44(%r14), %eax
movslq %ecx, %rcx
leaq (%r15,%rcx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
mulsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rdi,%rdx,8)
cmpw $0x1, %ax
jne 0xac352
movl 0x8e8(%rbx), %esi
cmpl %r8d, %esi
jg 0xac352
addl 0x64(%r14), %esi
cmpl %r8d, %esi
jle 0xac352
mulsd 0x60(%rsp), %xmm0
movsd %xmm0, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0xac31e
movq 0x1100(%rsp), %rax
movl 0x44(%rsp), %ecx
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x1098, %rsp           # imm = 0x1098
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq