// File: /workspace/github_c_makefile_star2_O1/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 $0x1088, %rsp           # imm = 0x1088
movl %r9d, %r13d
movq %rdx, %r14
movl 0x10c0(%rsp), %ebx
cmpw $0x1, 0xe(%rdx)
jne 0xae555
cmpl %r13d, 0x848(%r14)
jne 0xae555
cmpw $0x1, 0x2c(%r14)
jne 0xaeb11
xorl %eax, %eax
cmpl %ebx, 0x8bc(%rcx)
sete %al
jmp 0xaeb13
xorl %eax, %eax
movq 0x10e8(%rsp), %r15
movq 0x10e0(%rsp), %rbp
movq 0x10c8(%rsp), %r10
movsd 0x310(%rsi), %xmm2
testw %ax, %ax
movsd %xmm2, 0x38(%rsp)
je 0xae608
movq %r8, 0x60(%rsp)
movsd %xmm1, 0x50(%rsp)
leaq 0x44(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, %r12
movq %rsi, %r15
movq %r14, %rdx
movsd %xmm0, 0x58(%rsp)
movapd %xmm2, %xmm1
movq %rcx, %rbp
movl %r13d, %r8d
movl %ebx, %r9d
callq 0xad2d2
testl %eax, %eax
je 0xae6cc
addq $0x96a, %rbp            # imm = 0x96A
leaq 0x42e1f(%rip), %rsi     # 0xf13f0
leaq 0x73f0c(%rip), %rdx     # 0x1224e4
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x42a40(%rip), %rsi     # 0xf1034
leaq 0x73f44(%rip), %rdx     # 0x12253f
movq %rbp, %rdi
movl $0x956, %ecx            # imm = 0x956
jmp 0xae6b8
movq %rcx, %rbx
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 0xae65b
movq 0x9f0(%r14), %rcx
xorl %edx, %edx
movapd %xmm1, %xmm0
subsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rbp,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xae644
movq %rbx, %rcx
addq $0x96a, %rcx            # imm = 0x96A
movq %rbp, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %rcx, %rbx
callq 0x1b3f1
cmpl $0x1, %eax
jne 0xaf39a
leaq 0x42d6a(%rip), %rsi     # 0xf13f0
leaq 0x73ec3(%rip), %rdx     # 0x122550
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4298b(%rip), %rsi     # 0xf1034
leaq 0x73e8f(%rip), %rdx     # 0x12253f
movq %rbx, %rdi
movl $0xa3a, %ecx            # imm = 0xA3A
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0xaf3aa
movq %r12, 0x78(%rsp)
movq %r15, 0x28(%rsp)
cmpw $0x1, 0xe(%r14)
jne 0xaf39a
movq %r14, %r9
cmpl %r13d, 0x848(%r14)
jne 0xaf39a
cmpw $0x1, 0x2c(%r9)
movq %rbp, %r11
movq 0x60(%rsp), %r12
jne 0xaec64
cmpl %ebx, 0x8bc(%r11)
jne 0xaec64
movl 0x44(%rsp), %r14d
testl %r14d, %r14d
movsd 0x38(%rsp), %xmm2
jle 0xaea90
movl 0x9f8(%r9), %eax
movl %eax, %ecx
subl %r14d, %ecx
movapd %xmm2, %xmm0
subsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movslq %ecx, %r13
movq 0x10e0(%rsp), %r15
movq 0x10c8(%rsp), %r12
xorpd %xmm0, %xmm0
movq %r9, %rbx
movq 0x9f0(%r9), %rcx
movsd (%rcx,%r13,8), %xmm1
movsd %xmm1, 0x30(%rsp)
decl %eax
xorpd %xmm4, %xmm4
cmpl %eax, %r13d
movsd 0x50(%rsp), %xmm1
je 0xaea13
movq 0x28(%rsp), %rcx
movl 0x320(%rcx), %eax
cmpl $-0x1, %eax
je 0xae7f4
testl %eax, %eax
je 0xae7cd
movapd %xmm0, %xmm4
cmpl $0x1, %eax
jne 0xaea13
movq 0x28(%rsp), %rax
movsd 0x318(%rax), %xmm0
ucomisd 0x42a9d(%rip), %xmm0    # 0xf1258
jb 0xae922
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0xae930
movsd 0x58(%rsp), %xmm4
movsd 0x30(%rsp), %xmm3
subsd %xmm3, %xmm4
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
divsd %xmm0, %xmm4
divsd 0x70(%rsp), %xmm4
jmp 0xaea13
movsd 0x318(%rcx), %xmm0
movsd 0x45cf4(%rip), %xmm1    # 0xf44f8
ucomisd %xmm0, %xmm1
xorpd 0x42a20(%rip), %xmm0    # 0xf1230
jb 0xae81b
xorps %xmm2, %xmm2
sqrtsd %xmm0, %xmm2
jmp 0xae829
callq 0x82b0
movq 0x28(%rsp), %rcx
movapd %xmm0, %xmm2
movsd 0x318(%rcx), %xmm0
movsd 0x45cbf(%rip), %xmm1    # 0xf44f8
ucomisd %xmm0, %xmm1
xorpd 0x429eb(%rip), %xmm0    # 0xf1230
movsd %xmm2, 0x20(%rsp)
jb 0xae853
sqrtsd %xmm0, %xmm0
jmp 0xae858
callq 0x82b0
movsd 0x58(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8370
movsd %xmm0, 0x48(%rsp)
movq 0x28(%rsp), %rax
movsd 0x318(%rax), %xmm0
movsd 0x45c6c(%rip), %xmm1    # 0xf44f8
ucomisd %xmm0, %xmm1
xorpd 0x42998(%rip), %xmm0    # 0xf1230
jb 0xae8a0
sqrtsd %xmm0, %xmm0
jmp 0xae8a5
callq 0x82b0
movsd 0x38(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8370
movapd %xmm0, %xmm2
movq 0x28(%rsp), %rax
movsd 0x318(%rax), %xmm0
movsd 0x45c21(%rip), %xmm1    # 0xf44f8
ucomisd %xmm0, %xmm1
xorpd 0x4294d(%rip), %xmm0    # 0xf1230
jb 0xae8eb
sqrtsd %xmm0, %xmm0
jmp 0xae8fc
movsd %xmm2, 0x68(%rsp)
callq 0x82b0
movsd 0x68(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0x20(%rsp)
mulsd 0x70(%rsp), %xmm0
callq 0x8370
jmp 0xaea00
callq 0x82b0
movq 0x28(%rsp), %rax
movapd %xmm0, %xmm1
movsd 0x318(%rax), %xmm0
ucomisd 0x42918(%rip), %xmm0    # 0xf1258
movsd %xmm1, 0x20(%rsp)
jb 0xae94e
sqrtsd %xmm0, %xmm0
jmp 0xae953
callq 0x82b0
movsd 0x58(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x80a0
movsd %xmm0, 0x48(%rsp)
movq 0x28(%rsp), %rax
movsd 0x318(%rax), %xmm0
ucomisd 0x428d1(%rip), %xmm0    # 0xf1258
jb 0xae98f
sqrtsd %xmm0, %xmm0
jmp 0xae994
callq 0x82b0
movsd 0x38(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x80a0
movapd %xmm0, %xmm2
movq 0x28(%rsp), %rax
movsd 0x318(%rax), %xmm0
ucomisd 0x42892(%rip), %xmm0    # 0xf1258
jb 0xae9ce
sqrtsd %xmm0, %xmm0
jmp 0xae9df
movsd %xmm2, 0x68(%rsp)
callq 0x82b0
movsd 0x68(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0x20(%rsp)
mulsd 0x70(%rsp), %xmm0
callq 0x80a0
movsd 0x20(%rsp), %xmm4
divsd %xmm0, %xmm4
movsd 0x50(%rsp), %xmm1
movq %rbp, %r11
movsd %xmm4, 0x20(%rsp)
movq 0x60(%rsp), %rax
movsd (%rax,%r13,8), %xmm0
mulsd %xmm4, %xmm0
mulsd (%r11), %xmm0
movsd %xmm0, 0x48(%rsp)
movapd %xmm1, %xmm0
divsd 0x10(%r11), %xmm0
movsd 0x8(%r11), %xmm1
callq 0x8620
movq %rbp, %r11
movsd 0x38(%rsp), %xmm2
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, (%r12)
movapd %xmm2, %xmm0
subsd 0x30(%rsp), %xmm0
movsd %xmm0, (%r15)
incq %r13
movq %rbx, %r9
movslq 0x9f8(%rbx), %rax
addq $0x8, %r12
addq $0x8, %r15
movsd 0x20(%rsp), %xmm0
cmpq %rax, %r13
jl 0xae75a
leaq 0x96a(%r11), %r13
movq 0x10e0(%rsp), %rdi
movl %r14d, %esi
movq 0x10e8(%rsp), %rdx
movq %r13, %rcx
movq %r9, %rbx
callq 0x1b3f1
movq %rbx, %r9
movq %rbp, %r11
cmpl $0x1, %eax
movl 0x10c0(%rsp), %ebx
movq 0x60(%rsp), %r12
jne 0xaec64
leaq 0x42919(%rip), %rsi     # 0xf13f0
leaq 0x73a72(%rip), %rdx     # 0x122550
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4253a(%rip), %rsi     # 0xf1034
leaq 0x73a3e(%rip), %rdx     # 0x12253f
movq %r13, %rdi
movl $0x99a, %ecx            # imm = 0x99A
movq %rbx, %r8
jmp 0xae6bb
xorl %eax, %eax
cmpw $0x1, 0x3e(%r14)
jne 0xaeb31
movl 0x8c0(%rcx), %edx
cmpl %ebx, %edx
jg 0xaeb31
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
movzwl 0x40(%r14), %r10d
cmpw $0x1, %r10w
jne 0xaeb8d
movl 0x8c8(%rcx), %edx
cmpl %ebx, %edx
jg 0xaeb53
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, %r10w
jne 0xaeb8d
movl 0x8cc(%rcx), %edx
cmpl %ebx, %edx
jg 0xaeb70
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, %r10w
jne 0xaeb8d
movl 0x8d0(%rcx), %edx
cmpl %ebx, %edx
jg 0xaeb8d
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
movzwl 0x44(%r14), %r10d
cmpw $0x1, %r10w
jne 0xaebe5
movl 0x8d8(%rcx), %edx
cmpl %ebx, %edx
jg 0xaebaf
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, %r10w
jne 0xaebe5
movl 0x8dc(%rcx), %edx
cmpl %ebx, %edx
jg 0xaebcc
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, %r10w
jne 0xaebe5
movl 0x8e0(%rcx), %edx
cmpl %ebx, %edx
jg 0xaebe5
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, 0x2e(%r14)
jne 0xaebff
movl 0x8c4(%rcx), %edx
cmpl %ebx, %edx
jg 0xaebff
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, 0x42(%r14)
jne 0xaec19
movl 0x8d4(%rcx), %edx
cmpl %ebx, %edx
jg 0xaec19
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, %r10w
jne 0xae557
movl 0x8e4(%rcx), %edx
cmpl %ebx, %edx
jg 0xaec36
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jg 0xaec5b
cmpw $0x1, %r10w
jne 0xae557
movl 0x8e8(%rcx), %edx
cmpl %ebx, %edx
jg 0xae557
addl 0x64(%r14), %edx
cmpl %ebx, %edx
jle 0xae557
movw $0x1, %ax
jmp 0xae557
movzwl 0x3e(%r9), %eax
cmpw $0x1, %ax
jne 0xaec86
movl 0x8c0(%r11), %ecx
cmpl %ebx, %ecx
jg 0xaec86
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
jg 0xaed45
movzwl 0x40(%r9), %ecx
cmpw $0x1, %cx
jne 0xaecde
movl 0x8c8(%r11), %edx
cmpl %ebx, %edx
jg 0xaeca8
addl 0x64(%r9), %edx
cmpl %ebx, %edx
jg 0xaed45
cmpw $0x1, %cx
jne 0xaecde
movl 0x8cc(%r11), %edx
cmpl %ebx, %edx
jg 0xaecc5
addl 0x64(%r9), %edx
cmpl %ebx, %edx
jg 0xaed45
cmpw $0x1, %cx
jne 0xaecde
movl 0x8d0(%r11), %ecx
cmpl %ebx, %ecx
jg 0xaecde
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
jg 0xaed45
movzwl 0x44(%r9), %ecx
xorl %r8d, %r8d
cmpw $0x1, %cx
jne 0xaf0c3
movl 0x8d8(%r11), %edx
cmpl %ebx, %edx
jg 0xaed03
addl 0x64(%r9), %edx
cmpl %ebx, %edx
jg 0xaed45
cmpw $0x1, %cx
jne 0xaf0c3
movl 0x8dc(%r11), %edx
cmpl %ebx, %edx
jg 0xaed20
addl 0x64(%r9), %edx
cmpl %ebx, %edx
jg 0xaed45
cmpw $0x1, %cx
jne 0xaf0c3
movl 0x8e0(%r11), %ecx
cmpl %ebx, %ecx
jg 0xaf0c3
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
jle 0xaf0c3
xorl %r8d, %r8d
cmpw $0x1, %ax
jne 0xaed68
movl 0x8c0(%r11), %ecx
movl %ebx, %eax
subl %ecx, %eax
jl 0xaed68
addl 0x64(%r9), %ecx
xorl %r8d, %r8d
cmpl %ebx, %ecx
cmovgl %eax, %r8d
movzwl 0x40(%r9), %eax
cmpw $0x1, %ax
movq 0x28(%rsp), %rsi
movq 0x78(%rsp), %rdi
jne 0xaed94
movl 0x8c8(%r11), %edx
movl %ebx, %ecx
subl %edx, %ecx
jl 0xaed94
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %ecx, %r8d
cmpw $0x1, %ax
jne 0xaedb1
movl 0x8cc(%r11), %edx
movl %ebx, %ecx
subl %edx, %ecx
jl 0xaedb1
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %ecx, %r8d
cmpw $0x1, %ax
jne 0xaedce
movl 0x8d0(%r11), %ecx
movl %ebx, %eax
subl %ecx, %eax
jl 0xaedce
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
cmovgl %eax, %r8d
movzwl 0x44(%r9), %eax
cmpw $0x1, %ax
jne 0xaedf0
movl 0x8d8(%r11), %edx
movl %ebx, %ecx
subl %edx, %ecx
jl 0xaedf0
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %ecx, %r8d
cmpw $0x1, %ax
jne 0xaee0d
movl 0x8dc(%r11), %edx
movl %ebx, %ecx
subl %edx, %ecx
jl 0xaee0d
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %ecx, %r8d
cmpw $0x1, %ax
jne 0xaee2a
movl 0x8e0(%r11), %ecx
movl %ebx, %eax
subl %ecx, %eax
jl 0xaee2a
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
cmovgl %eax, %r8d
movl 0x44(%rsp), %r13d
movl %r13d, (%rsp)
movq %r9, %rdx
movq %r11, %rcx
movq %r11, %rbx
movq %r9, %r15
movq 0x10e0(%rsp), %r14
movq %r14, %r9
movl %r8d, %r12d
callq 0xafd5f
testl %eax, %eax
je 0xaee9b
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x4258c(%rip), %rsi     # 0xf13f0
leaq 0x73737(%rip), %rdx     # 0x1225a2
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x421ad(%rip), %rsi     # 0xf1034
leaq 0x736b1(%rip), %rdx     # 0x12253f
movq %rbx, %rdi
movl $0x9ac, %ecx            # imm = 0x9AC
jmp 0xae6b8
movl %r12d, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%r14), %xmm1
movq 0x9f0(%r15), %rax
movslq 0x9f8(%r15), %rcx
ucomisd -0x8(%rax,%rcx,8), %xmm1
jbe 0xaef26
leaq 0x73725(%rip), %rsi     # 0x1225f1
leaq 0x80(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x4219d(%rip), %rsi     # 0xf1082
leaq 0x73781(%rip), %rdx     # 0x12266d
leaq 0x880(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x96a, %rbp            # imm = 0x96A
leaq 0x42125(%rip), %rsi     # 0xf1034
leaq 0x73629(%rip), %rdx     # 0x12253f
movq %rbp, %rdi
movl $0x9b0, %ecx            # imm = 0x9B0
movq %r15, %r8
jmp 0xae6bb
movq 0x10c8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %r12
movq %r12, 0x10(%rsp)
movl %r13d, (%rsp)
movq %r15, %rdx
movq %rbp, %rbx
movq %rbp, %rcx
movq %r14, %r9
callq 0xaff4a
testl %eax, %eax
je 0xaef9b
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x4248c(%rip), %rsi     # 0xf13f0
leaq 0x73740(%rip), %rdx     # 0x1226ab
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x420ad(%rip), %rsi     # 0xf1034
leaq 0x735b1(%rip), %rdx     # 0x12253f
movq %rbx, %rdi
movl $0x9bf, %ecx            # imm = 0x9BF
jmp 0xae6b8
movq %r15, 0x30(%rsp)
leaq 0x96a(%rbx), %r15
movq %r14, %rdi
movl %r13d, %esi
movq 0x10e8(%rsp), %rdx
movq %r15, %rcx
callq 0x1b3f1
cmpl $0x1, %eax
jne 0xaf000
leaq 0x42427(%rip), %rsi     # 0xf13f0
leaq 0x73580(%rip), %rdx     # 0x122550
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x42048(%rip), %rsi     # 0xf1034
leaq 0x7354c(%rip), %rdx     # 0x12253f
movq %r15, %rdi
movl $0x9c7, %ecx            # imm = 0x9C7
jmp 0xaeb09
testl %r13d, %r13d
jle 0xaf0b2
movl 0x10d8(%rsp), %ecx
movl 0x10c0(%rsp), %ebx
imull %ebx, %ecx
movq 0x30(%rsp), %r9
movzwl 0x40(%r9), %eax
movsd 0x42234(%rip), %xmm0    # 0xf1260
movsd 0x50(%rsp), %xmm2
divsd %xmm2, %xmm0
movapd %xmm0, %xmm1
divsd %xmm2, %xmm1
movslq %ecx, %rcx
movq 0x10d0(%rsp), %rdx
leaq (%rdx,%rcx,8), %rcx
xorl %edx, %edx
movq 0x10c8(%rsp), %rdi
movq %rbp, %r11
movl 0x20(%rsp), %r8d
movsd (%rcx,%rdx,8), %xmm2
cmpw $0x1, %ax
jne 0xaf081
movl 0x8cc(%r11), %esi
cmpl %ebx, %esi
jg 0xaf081
addl 0x64(%r9), %esi
cmpl %ebx, %esi
jle 0xaf081
mulsd %xmm1, %xmm2
cmpw $0x1, %ax
jne 0xaf09e
movl 0x8d0(%r11), %esi
cmpl %ebx, %esi
jg 0xaf09e
addl 0x64(%r9), %esi
cmpl %ebx, %esi
jle 0xaf09e
mulsd %xmm0, %xmm2
mulsd (%rdi,%rdx,8), %xmm2
movsd %xmm2, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0xaf05f
jmp 0xaf0c3
movl 0x10c0(%rsp), %ebx
movq 0x30(%rsp), %r9
movl 0x20(%rsp), %r8d
movzwl 0x2e(%r9), %eax
cmpw $0x1, %ax
jne 0xaf0e0
movl 0x8c4(%rbp), %ecx
cmpl %ebx, %ecx
jg 0xaf0e0
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
jg 0xaf13f
cmpw $0x1, 0x42(%r9)
jne 0xaf0fa
movl 0x8d4(%rbp), %ecx
cmpl %ebx, %ecx
jg 0xaf0fa
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
jg 0xaf13f
movzwl 0x44(%r9), %ecx
cmpw $0x1, %cx
jne 0xaf39a
movl 0x8e4(%rbp), %edx
cmpl %ebx, %edx
jg 0xaf11b
addl 0x64(%r9), %edx
cmpl %ebx, %edx
jg 0xaf13f
cmpw $0x1, %cx
jne 0xaf39a
movl 0x8e8(%rbp), %ecx
cmpl %ebx, %ecx
jg 0xaf39a
addl 0x64(%r9), %ecx
cmpl %ebx, %ecx
jle 0xaf39a
cmpw $0x1, %ax
jne 0xaf170
movq %rbp, %rcx
movl 0x8c4(%rbp), %edx
movl %ebx, %eax
subl %edx, %eax
movq 0x28(%rsp), %rsi
movq 0x78(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
jl 0xaf183
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %eax, %r8d
jmp 0xaf183
movq 0x28(%rsp), %rsi
movq 0x78(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movq %rbp, %rcx
cmpw $0x1, 0x42(%r9)
jne 0xaf1a1
movl 0x8d4(%rcx), %edx
movl %ebx, %eax
subl %edx, %eax
jl 0xaf1a1
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %eax, %r8d
movzwl 0x44(%r9), %eax
cmpw $0x1, %ax
jne 0xaf1c4
movl 0x8e4(%rcx), %edx
movl %ebx, %r10d
subl %edx, %r10d
jl 0xaf1c4
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %r10d, %r8d
cmpw $0x1, %ax
jne 0xaf1e0
movl 0x8e8(%rcx), %edx
movl %ebx, %eax
subl %edx, %eax
jl 0xaf1e0
addl 0x64(%r9), %edx
cmpl %ebx, %edx
cmovgl %eax, %r8d
movl 0x44(%rsp), %r13d
movl %r13d, (%rsp)
movq %r9, %rdx
movq %rcx, %rbx
movq %r9, %r15
movq 0x10e0(%rsp), %r14
movq %r14, %r9
callq 0xb00a0
testl %eax, %eax
je 0xaf24b
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x421dc(%rip), %rsi     # 0xf13f0
leaq 0x7350b(%rip), %rdx     # 0x122726
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x41dfd(%rip), %rsi     # 0xf1034
leaq 0x73301(%rip), %rdx     # 0x12253f
movq %rbx, %rdi
movl $0x9f3, %ecx            # imm = 0x9F3
jmp 0xae6b8
movq 0x10c8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movl %r13d, (%rsp)
movq %r15, %rdx
movq %rbx, %rcx
movq %r14, %r9
movsd 0x38(%rsp), %xmm0
callq 0xaff4a
testl %eax, %eax
je 0xaf2be
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x42169(%rip), %rsi     # 0xf13f0
leaq 0x7341d(%rip), %rdx     # 0x1226ab
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x41d8a(%rip), %rsi     # 0xf1034
leaq 0x7328e(%rip), %rdx     # 0x12253f
movq %rbx, %rdi
movl $0xa02, %ecx            # imm = 0xA02
jmp 0xae6b8
movq %r15, 0x30(%rsp)
leaq 0x96a(%rbx), %r15
movq %r14, %rdi
movl %r13d, %esi
movq 0x10e8(%rsp), %rdx
movq %r15, %rcx
callq 0x1b3f1
cmpl $0x1, %eax
jne 0xaf323
leaq 0x42104(%rip), %rsi     # 0xf13f0
leaq 0x7325d(%rip), %rdx     # 0x122550
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x41d25(%rip), %rsi     # 0xf1034
leaq 0x73229(%rip), %rdx     # 0x12253f
movq %r15, %rdi
movl $0xa0a, %ecx            # imm = 0xA0A
jmp 0xaeb09
testl %r13d, %r13d
movl 0x10c0(%rsp), %r12d
movq 0x30(%rsp), %r8
movq 0x10d0(%rsp), %rdx
movl 0x10d8(%rsp), %ecx
jle 0xaf39a
imull %r12d, %ecx
movzwl 0x44(%r8), %eax
movslq %ecx, %rcx
leaq (%rdx,%rcx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10c8(%rsp), %rdi
mulsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rdi,%rdx,8)
cmpw $0x1, %ax
jne 0xaf392
movl 0x8e8(%rbp), %esi
cmpl %r12d, %esi
jg 0xaf392
addl 0x64(%r8), %esi
cmpl %r12d, %esi
jle 0xaf392
mulsd 0x50(%rsp), %xmm0
movsd %xmm0, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0xaf356
movq 0x10f0(%rsp), %rax
movl 0x44(%rsp), %ecx
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x1088, %rsp           # imm = 0x1088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq