// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rbp
movq 0x10f0(%rsp), %r13
movq 0x10d8(%rsp), %rsi
cmpw $0x1, 0xe(%rdx)
jne 0xa611e
movl %r9d, %r15d
cmpl %r9d, 0x848(%r14)
jne 0xa611e
movl 0x10d0(%rsp), %r9d
movb $0x1, %al
cmpw $0x1, 0x2c(%r14)
jne 0xa5f60
cmpl %r9d, 0x8bc(%rbx)
setne %al
cmpw $0x1, 0x3e(%r14)
jne 0xa5f80
movl 0x8c0(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xa5f80
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xa6091
cmpw $0x1, 0x40(%r14)
jne 0xa5fd0
movl 0x8c8(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xa5fa0
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xa6091
movl 0x8cc(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xa5fb8
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xa6091
movl 0x8d0(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xa5fd0
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xa6091
movzwl 0x44(%r14), %ecx
cmpw $0x1, %cx
jne 0xa601f
movl 0x8d8(%rbx), %edx
cmpl %r9d, %edx
jg 0xa5ff3
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xa6091
movl 0x8dc(%rbx), %edx
cmpl %r9d, %edx
jg 0xa600b
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xa6091
movl 0x8e0(%rbx), %edx
cmpl %r9d, %edx
jg 0xa601f
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xa6091
cmpw $0x1, 0x2e(%r14)
jne 0xa603b
movl 0x8c4(%rbx), %edx
cmpl %r9d, %edx
jg 0xa603b
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xa6091
cmpw $0x1, 0x42(%r14)
jne 0xa6057
movl 0x8d4(%rbx), %edx
cmpl %r9d, %edx
jg 0xa6057
addl 0x64(%r14), %edx
cmpl %r9d, %edx
jg 0xa6091
cmpw $0x1, %cx
jne 0xa6593
movl 0x8e4(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xa6075
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jg 0xa6091
movl 0x8e8(%rbx), %ecx
cmpl %r9d, %ecx
jg 0xa6593
addl 0x64(%r14), %ecx
cmpl %r9d, %ecx
jle 0xa6593
movsd 0x310(%rbp), %xmm2
movsd %xmm2, 0x30(%rsp)
movq %r8, 0x78(%rsp)
movsd %xmm1, 0x60(%rsp)
leaq 0x3c(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, %r12
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movsd %xmm0, 0x70(%rsp)
movapd %xmm2, %xmm1
movl %r15d, %r8d
callq 0xa4dec
testl %eax, %eax
je 0xa61f0
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3f309(%rip), %rsi     # 0xe53f0
leaq 0x702c6(%rip), %rdx     # 0x1163b4
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3ef2a(%rip), %rsi     # 0xe5034
leaq 0x702fe(%rip), %rdx     # 0x11640f
movq %rbx, %rdi
movl $0x956, %ecx            # imm = 0x956
jmp 0xa61de
movsd 0x310(%rbp), %xmm2
movsd %xmm2, 0x30(%rsp)
movslq 0x9f8(%r14), %r15
movl %r15d, 0x3c(%rsp)
movq %r15, %rdx
shlq $0x3, %rdx
movq %rsi, %rdi
movq %r8, %rsi
callq 0x82f0
movsd 0x30(%rsp), %xmm1
movl 0x9f8(%r14), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0xa617f
movq 0x9f0(%r14), %rdx
movapd %xmm1, %xmm0
subsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%r13,%rcx,8)
incq %rcx
jmp 0xa615e
addq $0x96a, %rbx            # imm = 0x96A
movq %r13, %rdi
movl %r15d, %esi
movq 0x10f8(%rsp), %rdx
movq %rbx, %rcx
callq 0x19224
cmpl $0x1, %eax
jne 0xa6d08
leaq 0x3f244(%rip), %rsi     # 0xe53f0
leaq 0x7026d(%rip), %rdx     # 0x116420
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3ee65(%rip), %rsi     # 0xe5034
leaq 0x70239(%rip), %rdx     # 0x11640f
movq %rbx, %rdi
movl $0xa3a, %ecx            # imm = 0xA3A
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0xa6d18
movq %r12, 0x50(%rsp)
cmpw $0x1, 0xe(%r14)
jne 0xa6d08
cmpl %r15d, 0x848(%r14)
jne 0xa6d08
cmpw $0x1, 0x2c(%r14)
movl 0x10d0(%rsp), %r10d
movq 0x10d8(%rsp), %r12
jne 0xa661f
cmpl %r10d, 0x8bc(%rbx)
jne 0xa661f
movl 0x9f8(%r14), %eax
movl 0x3c(%rsp), %ecx
movl %eax, %edx
movl %ecx, 0x84(%rsp)
subl %ecx, %edx
movsd 0x30(%rsp), %xmm0
subsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movq %rdx, 0x88(%rsp)
movslq %edx, %r15
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0xa65a8
movq 0x9f0(%r14), %rcx
movsd (%rcx,%r15,8), %xmm1
movsd %xmm1, 0x58(%rsp)
decl %eax
movq 0x88(%rsp), %rcx
addl %r12d, %ecx
xorpd %xmm2, %xmm2
cmpl %eax, %ecx
movsd 0x60(%rsp), %xmm1
je 0xa6522
movl 0x320(%rbp), %eax
cmpl $-0x1, %eax
je 0xa6323
movsd 0x70(%rsp), %xmm4
movsd 0x58(%rsp), %xmm2
subsd %xmm2, %xmm4
movsd 0x30(%rsp), %xmm3
subsd %xmm2, %xmm3
testl %eax, %eax
je 0xa6310
movapd %xmm0, %xmm2
cmpl $0x1, %eax
jne 0xa6522
movsd 0x318(%rbp), %xmm0
ucomisd 0x3ef63(%rip), %xmm0    # 0xe5258
movsd %xmm3, 0x40(%rsp)
movsd %xmm4, 0x48(%rsp)
jb 0xa6447
sqrtsd %xmm0, %xmm1
jmp 0xa6450
divsd %xmm3, %xmm4
divsd 0x68(%rsp), %xmm4
movapd %xmm4, %xmm2
jmp 0xa6522
movsd 0x318(%rbp), %xmm0
movsd 0x42195(%rip), %xmm1    # 0xe84c8
ucomisd %xmm0, %xmm1
xorpd 0x3eef1(%rip), %xmm0    # 0xe5230
jb 0xa6347
sqrtsd %xmm0, %xmm2
jmp 0xa6350
callq 0x82d0
movapd %xmm0, %xmm2
movsd 0x318(%rbp), %xmm0
movsd 0x42168(%rip), %xmm1    # 0xe84c8
ucomisd %xmm0, %xmm1
xorpd 0x3eec4(%rip), %xmm0    # 0xe5230
movsd %xmm2, 0x28(%rsp)
jb 0xa637a
sqrtsd %xmm0, %xmm0
jmp 0xa637f
callq 0x82d0
movsd 0x70(%rsp), %xmm1
subsd 0x58(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8390
movapd %xmm0, %xmm2
movsd 0x318(%rbp), %xmm0
movsd 0x4211c(%rip), %xmm1    # 0xe84c8
ucomisd %xmm0, %xmm1
xorpd 0x3ee78(%rip), %xmm0    # 0xe5230
movsd %xmm2, 0x40(%rsp)
jb 0xa63c6
sqrtsd %xmm0, %xmm0
jmp 0xa63cb
callq 0x82d0
movsd 0x30(%rsp), %xmm1
subsd 0x58(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8390
movapd %xmm0, %xmm3
movsd 0x318(%rbp), %xmm0
movsd 0x420d0(%rip), %xmm1    # 0xe84c8
ucomisd %xmm0, %xmm1
xorpd 0x3ee2c(%rip), %xmm0    # 0xe5230
jb 0xa640c
sqrtsd %xmm0, %xmm0
jmp 0xa641d
movsd %xmm3, 0x48(%rsp)
callq 0x82d0
movsd 0x48(%rsp), %xmm3
movsd 0x28(%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd 0x68(%rsp), %xmm0
callq 0x8390
jmp 0xa6512
callq 0x82d0
movapd %xmm0, %xmm1
movsd 0x318(%rbp), %xmm0
ucomisd 0x3edf8(%rip), %xmm0    # 0xe5258
movsd %xmm1, 0x28(%rsp)
jb 0xa646e
sqrtsd %xmm0, %xmm0
jmp 0xa6473
callq 0x82d0
movsd 0x48(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x80a0
movapd %xmm0, %xmm1
movsd 0x318(%rbp), %xmm0
ucomisd 0x3edbe(%rip), %xmm0    # 0xe5258
movsd %xmm1, 0x48(%rsp)
jb 0xa64a8
sqrtsd %xmm0, %xmm0
jmp 0xa64ad
callq 0x82d0
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x80a0
movapd %xmm0, %xmm3
movsd 0x318(%rbp), %xmm0
ucomisd 0x3ed84(%rip), %xmm0    # 0xe5258
jb 0xa64dc
sqrtsd %xmm0, %xmm0
jmp 0xa64ed
movsd %xmm3, 0x40(%rsp)
callq 0x82d0
movsd 0x40(%rsp), %xmm3
movsd 0x28(%rsp), %xmm1
movsd 0x48(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd 0x68(%rsp), %xmm0
callq 0x80a0
movsd 0x28(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x60(%rsp), %xmm1
movsd %xmm2, 0x28(%rsp)
movq 0x78(%rsp), %rax
movsd (%rax,%r15,8), %xmm0
mulsd %xmm2, %xmm0
mulsd (%rbx), %xmm0
movsd %xmm0, 0x40(%rsp)
movapd %xmm1, %xmm0
divsd 0x10(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
callq 0x8650
mulsd 0x40(%rsp), %xmm0
movq 0x10d8(%rsp), %rax
movsd %xmm0, (%rax,%r12,8)
movsd 0x30(%rsp), %xmm0
subsd 0x58(%rsp), %xmm0
movsd %xmm0, (%r13,%r12,8)
incq %r15
movl 0x9f8(%r14), %eax
incq %r12
movsd 0x28(%rsp), %xmm0
jmp 0xa6271
movsd 0x310(%rbp), %xmm2
testb %al, %al
je 0xa6099
jmp 0xa6126
leaq 0x96a(%rbx), %r15
movq %r13, %rdi
movl 0x84(%rsp), %esi
movq 0x10f8(%rsp), %rdx
movq %r15, %rcx
callq 0x19224
movl 0x10d0(%rsp), %r10d
cmpl $0x1, %eax
movq 0x10d8(%rsp), %r12
jne 0xa661f
leaq 0x3ee0b(%rip), %rsi     # 0xe53f0
leaq 0x6fe34(%rip), %rdx     # 0x116420
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3ea2c(%rip), %rsi     # 0xe5034
leaq 0x6fe00(%rip), %rdx     # 0x11640f
movq %r15, %rdi
movl $0x99a, %ecx            # imm = 0x99A
movq %rbx, %r8
jmp 0xa61e1
movzwl 0x3e(%r14), %ecx
cmpw $0x1, %cx
jne 0xa6645
movl 0x8c0(%rbx), %edx
cmpl %r10d, %edx
jg 0xa6645
movl 0x64(%r14), %eax
leal (%rax,%rdx), %esi
cmpl %r10d, %esi
jg 0xa66f8
cmpw $0x1, 0x40(%r14)
jne 0xa6693
movl 0x8c8(%rbx), %edx
cmpl %r10d, %edx
jg 0xa6667
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r10d, %edx
jg 0xa66ec
movl 0x8cc(%rbx), %edx
cmpl %r10d, %edx
jg 0xa667d
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r10d, %edx
jg 0xa66ec
movl 0x8d0(%rbx), %edx
cmpl %r10d, %edx
jg 0xa6693
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r10d, %edx
jg 0xa66ec
xorl %r9d, %r9d
cmpw $0x1, 0x44(%r14)
jne 0xa6a2b
movl 0x8d8(%rbx), %edx
cmpl %r10d, %edx
jg 0xa66b8
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r10d, %edx
jg 0xa66ec
movl 0x8dc(%rbx), %edx
cmpl %r10d, %edx
jg 0xa66ce
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r10d, %edx
jg 0xa66ec
movl 0x8e0(%rbx), %edx
cmpl %r10d, %edx
jg 0xa6a2b
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl %r10d, %edx
jle 0xa6a2b
cmpw $0x1, %cx
jne 0xa66ff
movl 0x8c0(%rbx), %edx
movl %r10d, %ecx
subl %edx, %ecx
jge 0xa6704
xorl %r12d, %r12d
jmp 0xa6710
addl %eax, %edx
xorl %r12d, %r12d
cmpl %r10d, %edx
cmovgl %ecx, %r12d
cmpw $0x1, 0x40(%r14)
jne 0xa6767
movl 0x8c8(%rbx), %ecx
movl 0x8cc(%rbx), %edx
movl %r10d, %esi
subl %ecx, %esi
leal (%rax,%rcx), %edi
cmpl %r10d, %edi
cmovlel %r12d, %esi
cmpl %ecx, %r10d
cmovll %r12d, %esi
movl %r10d, %r12d
subl %edx, %r12d
leal (%rax,%rdx), %ecx
cmpl %r10d, %ecx
cmovlel %esi, %r12d
cmpl %edx, %r10d
cmovll %esi, %r12d
movl 0x8d0(%rbx), %edx
movl %r10d, %ecx
subl %edx, %ecx
jl 0xa6767
addl %eax, %edx
cmpl %r10d, %edx
cmovgl %ecx, %r12d
cmpw $0x1, 0x44(%r14)
jne 0xa67be
movl 0x8d8(%rbx), %ecx
movl 0x8dc(%rbx), %edx
movl %r10d, %esi
subl %ecx, %esi
leal (%rax,%rcx), %edi
cmpl %r10d, %edi
cmovlel %r12d, %esi
cmpl %ecx, %r10d
cmovll %r12d, %esi
movl %r10d, %r12d
subl %edx, %r12d
leal (%rax,%rdx), %ecx
cmpl %r10d, %ecx
cmovlel %esi, %r12d
cmpl %edx, %r10d
cmovll %esi, %r12d
movl 0x8e0(%rbx), %edx
movl %r10d, %ecx
subl %edx, %ecx
jl 0xa67be
addl %edx, %eax
cmpl %r10d, %eax
cmovgl %ecx, %r12d
movq 0x50(%rsp), %rdi
movl 0x3c(%rsp), %r15d
movl %r15d, (%rsp)
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %r12d, %r8d
movq %r13, %r9
callq 0xa766d
testl %eax, %eax
je 0xa6829
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3ebfe(%rip), %rsi     # 0xe53f0
leaq 0x6fc79(%rip), %rdx     # 0x116472
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3e81f(%rip), %rsi     # 0xe5034
leaq 0x6fbf3(%rip), %rdx     # 0x11640f
movq %rbx, %rdi
movl $0x9ac, %ecx            # imm = 0x9AC
jmp 0xa61de
movl %r12d, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%r13), %xmm1
movq 0x9f0(%r14), %rax
movslq 0x9f8(%r14), %rcx
ucomisd -0x8(%rax,%rcx,8), %xmm1
jbe 0xa68b5
leaq 0x6fc66(%rip), %rsi     # 0x1164c1
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x3e80e(%rip), %rsi     # 0xe5082
leaq 0x6fcc2(%rip), %rdx     # 0x11653d
leaq 0x890(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3e796(%rip), %rsi     # 0xe5034
leaq 0x6fb6a(%rip), %rdx     # 0x11640f
movq %rbx, %rdi
movl $0x9b0, %ecx            # imm = 0x9B0
movq %r15, %r8
jmp 0xa61e1
movq 0x10d8(%rsp), %r12
movq %r12, 0x18(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movl %r15d, (%rsp)
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r9
callq 0xa7842
testl %eax, %eax
je 0xa6927
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3eb00(%rip), %rsi     # 0xe53f0
leaq 0x6fc84(%rip), %rdx     # 0x11657b
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3e721(%rip), %rsi     # 0xe5034
leaq 0x6faf5(%rip), %rdx     # 0x11640f
movq %rbx, %rdi
movl $0x9bf, %ecx            # imm = 0x9BF
jmp 0xa61de
leaq 0x96a(%rbx), %rcx
movq %r13, %rdi
movl %r15d, %esi
movq 0x10f8(%rsp), %rdx
movq %rcx, 0x58(%rsp)
callq 0x19224
cmpl $0x1, %eax
jne 0xa698e
leaq 0x3ea9e(%rip), %rsi     # 0xe53f0
leaq 0x6fac7(%rip), %rdx     # 0x116420
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq 0x58(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3e6ba(%rip), %rsi     # 0xe5034
leaq 0x6fa8e(%rip), %rdx     # 0x11640f
movq %r14, %rdi
movl $0x9c7, %ecx            # imm = 0x9C7
jmp 0xa6617
movl 0x10e8(%rsp), %eax
movl 0x10d0(%rsp), %r10d
imull %r10d, %eax
movsd 0x3e8b7(%rip), %xmm0    # 0xe5260
movsd 0x60(%rsp), %xmm2
divsd %xmm2, %xmm0
movapd %xmm0, %xmm1
divsd %xmm2, %xmm1
movslq %eax, %rcx
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
movq 0x10e0(%rsp), %rdx
leaq (%rdx,%rcx,8), %rcx
movl 0x28(%rsp), %r9d
cmpq %rax, %r15
je 0xa6a2b
movsd (%rcx,%rax,8), %xmm2
cmpw $0x1, 0x40(%r14)
jne 0xa6a1a
movl 0x8cc(%rbx), %edx
cmpl %r10d, %edx
jg 0xa6a02
addl 0x64(%r14), %edx
cmpl %r10d, %edx
jle 0xa6a02
mulsd %xmm1, %xmm2
movl 0x8d0(%rbx), %edx
cmpl %r10d, %edx
jg 0xa6a1a
addl 0x64(%r14), %edx
cmpl %r10d, %edx
jle 0xa6a1a
mulsd %xmm0, %xmm2
mulsd (%r12,%rax,8), %xmm2
movsd %xmm2, (%r12,%rax,8)
incq %rax
jmp 0xa69d8
movzwl 0x2e(%r14), %ecx
cmpw $0x1, %cx
jne 0xa6a51
movl 0x8c4(%rbx), %edx
cmpl %r10d, %edx
jg 0xa6a51
movl 0x64(%r14), %eax
leal (%rax,%rdx), %esi
cmpl %r10d, %esi
jg 0xa6adb
cmpw $0x1, 0x42(%r14)
jne 0xa6a77
movl 0x8d4(%rbx), %edx
cmpl 0x10d0(%rsp), %edx
jg 0xa6a77
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl 0x10d0(%rsp), %edx
jg 0xa6ac7
cmpw $0x1, 0x44(%r14)
jne 0xa6d08
movl 0x8e4(%rbx), %edx
cmpl 0x10d0(%rsp), %edx
jg 0xa6aa1
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl 0x10d0(%rsp), %edx
jg 0xa6ac7
movl 0x8e8(%rbx), %edx
cmpl 0x10d0(%rsp), %edx
jg 0xa6d08
movl 0x64(%r14), %eax
addl %eax, %edx
cmpl 0x10d0(%rsp), %edx
jle 0xa6d08
cmpw $0x1, %cx
jne 0xa6aed
movl 0x8c4(%rbx), %edx
movl 0x10d0(%rsp), %r10d
movl %r10d, %ecx
subl %edx, %ecx
jl 0xa6af5
addl %eax, %edx
cmpl %r10d, %edx
cmovgl %ecx, %r9d
jmp 0xa6af5
movl 0x10d0(%rsp), %r10d
cmpw $0x1, 0x42(%r14)
jne 0xa6b1b
movl 0x8d4(%rbx), %edx
movl %r10d, %ecx
subl %edx, %ecx
movsd 0x30(%rsp), %xmm0
jl 0xa6b21
addl %eax, %edx
cmpl %r10d, %edx
cmovgl %ecx, %r9d
jmp 0xa6b21
movsd 0x30(%rsp), %xmm0
cmpw $0x1, 0x44(%r14)
jne 0xa6b5b
movl 0x8e4(%rbx), %edx
movl 0x8e8(%rbx), %ecx
movl %r10d, %esi
subl %edx, %esi
leal (%rax,%rdx), %edi
cmpl %r10d, %edi
cmovlel %r9d, %esi
cmpl %edx, %r10d
cmovgel %esi, %r9d
movl %r10d, %edx
subl %ecx, %edx
jl 0xa6b5b
addl %ecx, %eax
cmpl %r10d, %eax
cmovgl %edx, %r9d
movq 0x50(%rsp), %rdi
movl 0x3c(%rsp), %r15d
movl %r15d, (%rsp)
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %r9d, %r8d
movq %r13, %r9
callq 0xa799b
testl %eax, %eax
je 0xa6bc6
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3e861(%rip), %rsi     # 0xe53f0
leaq 0x6fa60(%rip), %rdx     # 0x1165f6
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3e482(%rip), %rsi     # 0xe5034
leaq 0x6f856(%rip), %rdx     # 0x11640f
movq %rbx, %rdi
movl $0x9f3, %ecx            # imm = 0x9F3
jmp 0xa61de
movq %r12, 0x18(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movl %r15d, (%rsp)
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r9
movsd 0x30(%rsp), %xmm0
callq 0xa7842
testl %eax, %eax
je 0xa6c36
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x3e7f1(%rip), %rsi     # 0xe53f0
leaq 0x6f975(%rip), %rdx     # 0x11657b
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3e412(%rip), %rsi     # 0xe5034
leaq 0x6f7e6(%rip), %rdx     # 0x11640f
movq %rbx, %rdi
movl $0xa02, %ecx            # imm = 0xA02
jmp 0xa61de
movq %r12, %rbp
leaq 0x96a(%rbx), %r12
movq %r13, %rdi
movl %r15d, %esi
movq 0x10f8(%rsp), %rdx
movq %r12, %rcx
callq 0x19224
cmpl $0x1, %eax
jne 0xa6c99
leaq 0x3e78e(%rip), %rsi     # 0xe53f0
leaq 0x6f7b7(%rip), %rdx     # 0x116420
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3e3af(%rip), %rsi     # 0xe5034
leaq 0x6f783(%rip), %rdx     # 0x11640f
movq %r12, %rdi
movl $0xa0a, %ecx            # imm = 0xA0A
jmp 0xa6617
movl 0x10e8(%rsp), %eax
imull 0x10d0(%rsp), %eax
movslq %eax, %rcx
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
movq 0x10e0(%rsp), %rdx
leaq (%rdx,%rcx,8), %rcx
movq %rbp, %rsi
cmpq %rax, %r15
je 0xa6d08
movsd (%rcx,%rax,8), %xmm0
mulsd (%rsi,%rax,8), %xmm0
movsd %xmm0, (%rsi,%rax,8)
cmpw $0x1, 0x44(%r14)
movl 0x10d0(%rsp), %edi
jne 0xa6d03
movl 0x8e8(%rbx), %edx
cmpl %edi, %edx
jg 0xa6d03
addl 0x64(%r14), %edx
cmpl %edi, %edx
jle 0xa6d03
mulsd 0x60(%rsp), %xmm0
movsd %xmm0, (%rsi,%rax,8)
incq %rax
jmp 0xa6cc3
movq 0x1100(%rsp), %rax
movl 0x3c(%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