LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_perturbation_sources_free
int transfer_perturbation_sources_free(
                                       struct perturbations * ppt,
                                       struct fourier * pfo,
                                       struct transfer * ptr,
                                       double *** sources
                                       ) {
  int index_md;
  int index_ic;
  int index_tp;

  for (index_md = 0; index_md < ptr->md_size; index_md++) {
    for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {
      for (index_tp = 0; index_tp < ppt->tp_size[index_md]; index_tp++) {
        if ((pfo->method != nl_none) && (_scalars_) &&
            (((ppt->has_source_delta_m == _TRUE_) && (index_tp == ppt->index_tp_delta_m)) ||
             ((ppt->has_source_theta_m == _TRUE_) && (index_tp == ppt->index_tp_theta_m)) ||
             ((ppt->has_source_delta_cb == _TRUE_) && (index_tp == ppt->index_tp_delta_cb)) ||
             ((ppt->has_source_theta_cb == _TRUE_) && (index_tp == ppt->index_tp_theta_cb)) ||
             ((ppt->has_source_phi == _TRUE_) && (index_tp == ppt->index_tp_phi)) ||
             ((ppt->has_source_phi_prime == _TRUE_) && (index_tp == ppt->index_tp_phi_prime)) ||
             ((ppt->has_source_phi_plus_psi == _TRUE_) && (index_tp == ppt->index_tp_phi_plus_psi)) ||
             ((ppt->has_source_psi == _TRUE_) && (index_tp == ppt->index_tp_psi)))) {

          free(sources[index_md][index_ic * ppt->tp_size[index_md] + index_tp]);
        }
      }
    }
    free(sources[index_md]);
  }
  free(sources);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq (%rsp), %rax
movslq 0x8a4(%rax), %rax
cmpq %rax, %r13
jge 0xa3097
xorl %ebp, %ebp
movq 0x870(%r12), %rax
cmpl (%rax,%r13,4), %ebp
jge 0xa3086
xorl %r14d, %r14d
movq 0x998(%r12), %rax
movl (%rax,%r13,4), %eax
cmpl %eax, %r14d
jge 0xa307f
cmpl $0x0, (%r15)
je 0xa3077
cmpw $0x1, 0xe(%r12)
jne 0xa3077
movl 0x848(%r12), %ecx
cmpq %rcx, %r13
jne 0xa3077
cmpw $0x1, 0x87c(%r12)
jne 0xa2fc4
cmpl 0x8d8(%r12), %r14d
je 0xa3062
cmpw $0x1, 0x898(%r12)
jne 0xa2fde
cmpl 0x934(%r12), %r14d
je 0xa3062
cmpw $0x1, 0x87e(%r12)
jne 0xa2ff4
cmpl 0x8dc(%r12), %r14d
je 0xa3062
cmpw $0x1, 0x89a(%r12)
jne 0xa300a
cmpl 0x938(%r12), %r14d
je 0xa3062
cmpw $0x1, 0x8b4(%r12)
jne 0xa3020
cmpl 0x970(%r12), %r14d
je 0xa3062
cmpw $0x1, 0x8b6(%r12)
jne 0xa3036
cmpl 0x974(%r12), %r14d
je 0xa3062
cmpw $0x1, 0x8b8(%r12)
jne 0xa304c
cmpl 0x978(%r12), %r14d
je 0xa3062
cmpw $0x1, 0x8ba(%r12)
jne 0xa3077
cmpl 0x97c(%r12), %r14d
jne 0xa3077
movq (%rbx,%r13,8), %rcx
imull %ebp, %eax
addl %r14d, %eax
cltq
movq (%rcx,%rax,8), %rdi
callq 0x8430
incl %r14d
jmp 0xa2f6d
incl %ebp
jmp 0xa2f58
movq (%rbx,%r13,8), %rdi
callq 0x8430
incq %r13
jmp 0xa2f42
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_free_source_correspondence
int transfer_free_source_correspondence(
                                        struct transfer * ptr,
                                        int ** tp_of_tt
                                        ) {

  int index_md;

  for (index_md = 0; index_md < ptr->md_size; index_md++) {
    free(tp_of_tt[index_md]);
  }
  free(tp_of_tt);

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x8a4(%r14), %rax
cmpq %rax, %r15
jge 0xa30d8
movq (%rbx,%r15,8), %rdi
callq 0x8430
incq %r15
jmp 0xa30be
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_free
int transfer_free(
                  struct transfer * ptr
                  ) {

  int index_md;

  if (ptr->has_cls == _TRUE_) {

    for (index_md = 0; index_md < ptr->md_size; index_md++) {
      free(ptr->l_size_tt[index_md]);
      free(ptr->transfer[index_md]);
      free(ptr->k[index_md]);
      if (ptr->do_lcmb_full_limber == _TRUE_) {
        free(ptr->transfer_limber[index_md]);
        free(ptr->k_limber[index_md]);
      }
    }

    free(ptr->tt_size);
    free(ptr->l_size_tt);
    free(ptr->l_size);
    free(ptr->l);
    free(ptr->q);
    free(ptr->k);
    free(ptr->transfer);
    if (ptr->do_lcmb_full_limber == _TRUE_) {
      free(ptr->q_limber);
      free(ptr->k_limber);
      free(ptr->transfer_limber);
    }

    if (ptr->nz_size > 0) {
      free(ptr->nz_z);
      free(ptr->nz_nz);
      free(ptr->nz_ddnz);
    }

    if (ptr->nz_evo_size > 0) {
      free(ptr->nz_evo_z);
      free(ptr->nz_evo_nz);
      free(ptr->nz_evo_dlog_nz);
      free(ptr->nz_evo_dd_dlog_nz);
    }
  }

  ptr->is_allocated = _FALSE_;

  return _SUCCESS_;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x1, 0x8a0(%rdi)
jne 0xa3253
xorl %r14d, %r14d
movslq 0x8a4(%rbx), %rax
cmpq %rax, %r14
jge 0xa316b
movq 0x8f8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x958(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x930(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
cmpw $0x1, 0x93c(%rbx)
jne 0xa3166
movq 0x960(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x950(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
incq %r14
jmp 0xa3100
movq 0x8f0(%rbx), %rdi
callq 0x8430
movq 0x8f8(%rbx), %rdi
callq 0x8430
movq 0x900(%rbx), %rdi
callq 0x8430
movq 0x910(%rbx), %rdi
callq 0x8430
movq 0x928(%rbx), %rdi
callq 0x8430
movq 0x930(%rbx), %rdi
callq 0x8430
movq 0x958(%rbx), %rdi
callq 0x8430
cmpw $0x1, 0x93c(%rbx)
jne 0xa31ed
movq 0x948(%rbx), %rdi
callq 0x8430
movq 0x950(%rbx), %rdi
callq 0x8430
movq 0x960(%rbx), %rdi
callq 0x8430
cmpl $0x0, 0x75c(%rbx)
jle 0xa321a
movq 0x760(%rbx), %rdi
callq 0x8430
movq 0x768(%rbx), %rdi
callq 0x8430
movq 0x770(%rbx), %rdi
callq 0x8430
cmpl $0x0, 0x87c(%rbx)
jle 0xa3253
movq 0x880(%rbx), %rdi
callq 0x8430
movq 0x888(%rbx), %rdi
callq 0x8430
movq 0x890(%rbx), %rdi
callq 0x8430
movq 0x898(%rbx), %rdi
callq 0x8430
andw $0x0, 0x116a(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_lensing_sampling
int transfer_lensing_sampling(
                              struct precision * ppr,
                              struct background * pba,
                              struct perturbations * ppt,
                              struct transfer * ptr,
                              int bin,
                              double tau0,
                              double * tau0_minus_tau,
                              int tau_size) {

  /* running index on time */
  int index_tau;

  /* minimum and maximal value of time in new sampled interval */
  double tau_min,tau_mean,tau_max;

  /* time interval for this bin */
  class_call(transfer_selection_times(ppr,
                                      pba,
                                      ppt,
                                      ptr,
                                      bin,
                                      &tau_min,
                                      &tau_mean,
                                      &tau_max),
             ptr->error_message,
             ptr->error_message);

  for (index_tau=0; index_tau<tau_size; index_tau++) {
    //tau0_minus_tau[index_tau]=pba->conformal_age-tau_min-((double)index_tau)/((double)tau_size-1.)*(tau0-tau_min);
    tau0_minus_tau[index_tau]=((double)(tau_size-1-index_tau))/((double)(tau_size-1))*(tau0-tau_min);
  }

  return _SUCCESS_;

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r9, %rbx
movsd %xmm0, (%rsp)
movq %rcx, %r14
leaq 0x10(%rsp), %rax
leaq 0x18(%rsp), %rcx
leaq 0x8(%rsp), %r9
pushq %rax
pushq %rcx
callq 0xa53d0
popq %rcx
popq %rdx
testl %eax, %eax
je 0xa7a21
addq $0x96a, %r14            # imm = 0x96A
leaq 0x3da16(%rip), %rsi     # 0xe53f0
leaq 0x6e6cf(%rip), %rdx     # 0x1160b0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3d63a(%rip), %rsi     # 0xe5034
leaq 0x6ee53(%rip), %rdx     # 0x116854
movq %r14, %rdi
movl $0xb6d, %ecx            # imm = 0xB6D
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r14
retq
movl 0x840(%rsp), %ecx
leal -0x1(%rcx), %edx
cvtsi2sd %edx, %xmm0
movsd (%rsp), %xmm2
subsd 0x8(%rsp), %xmm2
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xa7a16
cvtsi2sd %edx, %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
movsd %xmm1, (%rbx,%rsi,8)
incq %rsi
decl %edx
jmp 0xa7a43
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_dNdz_analytic
int transfer_dNdz_analytic(
                           struct transfer * ptr,
                           double z,
                           double * dNdz,
                           double * dln_dNdz_dz) {

  /* Implement here your favorite analytic ansatz for the selection
     function. Typical function for photometric sample: dN/dz =
     (z/z0)^alpha exp[-(z/z0)^beta]. Then: dln(dN/dz)/dz = (alpha -
     beta*(z/z0)^beta)/z. In principle, one is free to use different
     ansatz for the selection function and the evolution
     function. Since the selection function uses only dN/dz, while the
     evolution uses only dln(dN/dz)/dz, it is possible to use
     different functions for dN/dz and dln(dN/dz)/dz */

  double z0,alpha,beta;

  //Euclid IST dNdz, do not change this!
  z0 = 0.9/pow(2.,1./2.);
  alpha = 2.0;
  beta = 1.5;

  *dNdz = pow(z/z0,alpha) * exp(-pow(z/z0,beta));

  *dln_dNdz_dz = (alpha - pow(z/z0,beta)*beta)/z;

  return _SUCCESS_;

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd %xmm0, 0x10(%rsp)
divsd 0x6d448(%rip), %xmm0    # 0x1151f0
movsd %xmm0, 0x8(%rsp)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x401c5(%rip), %xmm1    # 0xe7f88
callq 0x8650
xorpd 0x3d460(%rip), %xmm0    # 0xe5230
callq 0x86a0
mulsd (%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
movsd 0x4019b(%rip), %xmm1    # 0xe7f88
callq 0x8650
mulsd 0x4018e(%rip), %xmm0    # 0xe7f88
movsd 0x3dede(%rip), %xmm1    # 0xe5ce0
subsd %xmm0, %xmm1
divsd 0x10(%rsp), %xmm1
movsd %xmm1, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_workspace_free
int transfer_workspace_free(
                            struct transfer * ptr,
                            struct transfer_workspace *ptw
                            ) {

  if (ptw->HIS_allocated==_TRUE_){
    //Free HIS structure:
    class_call(hyperspherical_HIS_free(&(ptw->HIS),ptr->error_message),
               ptr->error_message,
               ptr->error_message);
  }
  free(ptw->interpolated_sources);
  free(ptw->sources);
  free(ptw->tau0_minus_tau);
  free(ptw->w_trapz);
  free(ptw->chi);
  free(ptw->cscKgen);
  free(ptw->cotKgen);

  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, %rbx
cmpl $0x1, 0x60(%rsi)
jne 0xab3b3
movq %rdi, %r14
addq $0x96a, %r14            # imm = 0x96A
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0c
cmpl $0x1, %eax
jne 0xab3b3
leaq 0x3a079(%rip), %rsi     # 0xe53f0
leaq 0x6c467(%rip), %rdx     # 0x1177e5
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x39c9f(%rip), %rsi     # 0xe5034
leaq 0x6c481(%rip), %rdx     # 0x11781d
movq %r14, %rdi
movl $0x11c1, %ecx           # imm = 0x11C1
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0xab409
movq 0x80(%rbx), %rdi
callq 0x8430
movq 0x88(%rbx), %rdi
callq 0x8430
movq 0x90(%rbx), %rdi
callq 0x8430
movq 0x98(%rbx), %rdi
callq 0x8430
movq 0xa0(%rbx), %rdi
callq 0x8430
movq 0xa8(%rbx), %rdi
callq 0x8430
movq 0xb0(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_free
int harmonic_free(
                  struct harmonic * phr
                  ) {

  int index_md;

  if (phr->md_size > 0) {
    if (phr->ct_size > 0) {

      for (index_md = 0; index_md < phr->md_size; index_md++) {
        free(phr->l_max_ct[index_md]);
        free(phr->cl[index_md]);
        free(phr->ddcl[index_md]);
      }
      free(phr->l);
      free(phr->l_size);
      free(phr->l_max_ct);
      free(phr->l_max);
      free(phr->cl);
      free(phr->ddcl);
    }

    for (index_md=0; index_md < phr->md_size; index_md++)
      free(phr->is_non_zero[index_md]);

    free(phr->is_non_zero);
    free(phr->ic_size);
    free(phr->ic_ic_size);

  }
  phr->is_allocated = _FALSE_;

  return _SUCCESS_;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0xae595
cmpl $0x0, 0x9c(%rbx)
jle 0xae560
xorl %r14d, %r14d
cltq
cmpq %rax, %r14
jge 0xae518
movq 0xb8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0xd0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0xd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
incq %r14
movl 0x10(%rbx), %eax
jmp 0xae4d9
movq 0xb0(%rbx), %rdi
callq 0x8430
movq 0xa0(%rbx), %rdi
callq 0x8430
movq 0xb8(%rbx), %rdi
callq 0x8430
movq 0xc0(%rbx), %rdi
callq 0x8430
movq 0xd0(%rbx), %rdi
callq 0x8430
movq 0xd8(%rbx), %rdi
callq 0x8430
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
movq 0x28(%rbx), %rdi
cmpq %rax, %r14
jge 0xae57e
movq (%rdi,%r14,8), %rdi
callq 0x8430
incq %r14
jmp 0xae563
callq 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq 0x20(%rbx), %rdi
callq 0x8430
andw $0x0, 0x8ea(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_at_z
int harmonic_pk_at_z(
                     struct background * pba,
                     struct harmonic * phr,
                     enum linear_or_logarithmic mode,
                     double z,
                     double * output_tot,    /* array with argument output_tot[index_k] (must be already allocated) */
                     double * output_ic,     /* array with argument output_tot[index_k * phr->ic_ic_size[index_md] + index_ic1_ic2] (must be already allocated only if more than one initial condition) */
                     double * output_cb_tot, /* same as output_tot for the baryon+CDM only */
                     double * output_cb_ic   /* same as output_ic  for the baryon+CDM only */
                     ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_at_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_z() instead.\n");

  class_call(fourier_pks_at_z(
                              pba,
                              phr->pfo,
                              mode,
                              pk_linear,
                              z,
                              output_tot,
                              output_ic,
                              output_cb_tot,
                              output_cb_ic
                              ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r9, 0x8(%rsp)
movq %r8, %r15
movq %rcx, %r12
movsd %xmm0, (%rsp)
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x93601(%rip), %rax     # 0x142fb0
movq (%rax), %rcx
leaq 0x6917e(%rip), %rdi     # 0x118b37
pushq $0x1
popq %rdx
movl $0x97, %esi
callq 0x8700
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
movq %r14, %rdi
movl %r13d, %edx
xorl %ecx, %ecx
movsd (%rsp), %xmm0
movq %r12, %r8
movq %r15, %r9
pushq 0x850(%rsp)
pushq 0x10(%rsp)
callq 0x98d3f
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0xafa4c
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0x359e4(%rip), %rsi     # 0xe53f0
leaq 0x691bc(%rip), %rdx     # 0x118bcf
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0xea, %rbx
leaq 0x35604(%rip), %rsi     # 0xe5034
leaq 0x69202(%rip), %rdx     # 0x118c39
movq %rbx, %rdi
movl $0x571, %ecx            # imm = 0x571
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_at_k_and_z
int harmonic_pk_at_k_and_z(
                           struct background * pba,
                           struct primordial * ppm,
                           struct harmonic * phr,
                           double k,
                           double z,
                           double * pk_tot,    /* pointer to a single number (must be already allocated) */
                           double * pk_ic,     /* array of argument pk_ic[index_ic1_ic2]
                                                  (must be already allocated only if several initial conditions) */
                           double * pk_cb_tot, /* same as pk_tot for baryon+CDM part only */
                           double * pk_cb_ic   /* same as pk_ic  for baryon+CDM part only */
                           ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_at_k_and_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_linear_at_k_and_z() instead.\n");

  class_call(fourier_pks_at_k_and_z(pba,
                                    ppm,
                                    phr->pfo,
                                    pk_linear,
                                    k,
                                    z,
                                    pk_tot,
                                    pk_ic,
                                    pk_cb_tot,
                                    pk_cb_ic),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r9, 0x18(%rsp)
movq %r8, %r15
movq %rcx, %r12
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq 0x93518(%rip), %rax     # 0x142fb0
movq (%rax), %rcx
leaq 0x691a8(%rip), %rdi     # 0x118c4a
pushq $0x1
popq %rdx
movl $0xaa, %esi
callq 0x8700
movq 0xe0(%rbx), %rdx
xorl %ebp, %ebp
movq %r14, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r12, %r8
movq %r15, %r9
pushq 0x860(%rsp)
pushq 0x20(%rsp)
callq 0x998db
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0xafb3c
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0x358f4(%rip), %rsi     # 0xe53f0
leaq 0x691f2(%rip), %rdx     # 0x118cf5
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0xea, %rbx
leaq 0x35514(%rip), %rsi     # 0xe5034
leaq 0x6922e(%rip), %rdx     # 0x118d55
movq %rbx, %rdi
movl $0x5a2, %ecx            # imm = 0x5A2
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_nl_at_z
int harmonic_pk_nl_at_z(
                        struct background * pba,
                        struct harmonic * phr,
                        enum linear_or_logarithmic mode,
                        double z,
                        double * output_tot,   /* array with argument output_tot[index_k] (must be already allocated) */
                        double * output_cb_tot
                        ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_nl_at_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_z() instead.\n");

  class_call(fourier_pks_at_z(pba,
                              phr->pfo,
                              mode,
                              pk_nonlinear,
                              z,
                              output_tot,
                              NULL,
                              output_cb_tot,
                              NULL
                              ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r8, %r14
movq %rcx, %r15
movsd %xmm0, 0x18(%rsp)
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r13
movq 0x93433(%rip), %rax     # 0x142fb0
movq (%rax), %rcx
leaq 0x691e5(%rip), %rdi     # 0x118d6c
pushq $0x1
popq %rdx
movl $0x9a, %esi
callq 0x8700
movq 0xe0(%rbx), %rsi
movq %r14, (%rsp)
andq $0x0, 0x8(%rsp)
xorl %r14d, %r14d
pushq $0x1
popq %rbp
movq %r13, %rdi
movl %r12d, %edx
movl %ebp, %ecx
movsd 0x18(%rsp), %xmm0
movq %r15, %r8
xorl %r9d, %r9d
callq 0x98d3f
cmpl $0x1, %eax
jne 0xafc1c
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0x35814(%rip), %rsi     # 0xe53f0
leaq 0x69224(%rip), %rdx     # 0x118e07
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0xea, %rbx
leaq 0x35434(%rip), %rsi     # 0xe5034
leaq 0x69263(%rip), %rdx     # 0x118e6a
movq %rbx, %rdi
movl $0x5cb, %ecx            # imm = 0x5CB
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
movl %ebp, %r14d
movl %r14d, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_nl_at_k_and_z
int harmonic_pk_nl_at_k_and_z(
                              struct background * pba,
                              struct primordial * ppm,
                              struct harmonic * phr,
                              double k,
                              double z,
                              double * pk_tot,   /* pointer to a single number (must be already allocated) */
                              double * pk_cb_tot /* same as pk_tot for baryon+CDM only */
                              ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_nl_at_k_and_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_k_and_z() instead.\n");

  class_call(fourier_pks_at_k_and_z(pba,
                                    ppm,
                                    phr->pfo,
                                    pk_nonlinear,
                                    k,
                                    z,
                                    pk_tot,
                                    NULL,
                                    pk_cb_tot,
                                    NULL
                                    ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r8, %r15
movq %rcx, %r14
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq 0x9334c(%rip), %rax     # 0x142fb0
movq (%rax), %rcx
leaq 0x69210(%rip), %rdi     # 0x118e7e
pushq $0x1
popq %rdx
movl $0xa6, %esi
callq 0x8700
movq 0xe0(%rbx), %rdx
andq $0x0, 0x8(%rsp)
movq %r15, (%rsp)
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %ecx
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %r14, %r8
xorl %r9d, %r9d
callq 0x998db
cmpl $0x1, %eax
jne 0xafd09
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0x35727(%rip), %rsi     # 0xe53f0
leaq 0x69255(%rip), %rdx     # 0x118f25
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0xea, %rbx
leaq 0x35347(%rip), %rsi     # 0xe5034
leaq 0x69294(%rip), %rdx     # 0x118f88
movq %rbx, %rdi
movl $0x5f8, %ecx            # imm = 0x5F8
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
movl %ebp, %r15d
movl %r15d, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_fast_pk_at_kvec_and_zvec
int harmonic_fast_pk_at_kvec_and_zvec(
                                      struct background * pba,
                                      struct harmonic * phr,
                                      double * kvec,
                                      int kvec_size,
                                      double * zvec,
                                      int zvec_size,
                                      double * pk_tot_out, // pk_tot_out[index_zvec*kvec_size+index_kvec],
                                                           // already allocated
                                                           //(or NULL if user knows there is no _m output)
                                      double * pk_cb_tot_out, // idem
                                      int nonlinear
                                      ) {
  enum pk_outputs pk_output;

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_fast_pks_at_kvec_and_zvec() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_kvec_and_zvec() instead.\n");

  if (nonlinear == _TRUE_)
    pk_output = pk_nonlinear;
  else
    pk_output = pk_linear;

  class_call(fourier_pks_at_kvec_and_zvec(
                                          pba,
                                          phr->pfo,
                                          pk_output,
                                          kvec,
                                          kvec_size,
                                          zvec,
                                          zvec_size,
                                          pk_tot_out,
                                          pk_cb_tot_out),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movl %r9d, %r15d
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movq 0x93269(%rip), %rax     # 0x142fb0
movq (%rax), %rcx
leaq 0x69251(%rip), %rdi     # 0x118fa2
pushq $0x1
popq %rdx
movl $0xb5, %esi
callq 0x8700
xorl %edx, %edx
cmpl $0x1, 0x870(%rsp)
sete %dl
movq 0xe0(%rbx), %rsi
movaps 0x860(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movl %r15d, (%rsp)
movq %r13, %rdi
movq %r12, %rcx
movl %ebp, %r8d
movq %r14, %r9
callq 0x99a23
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0xafdf0
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0x35640(%rip), %rsi     # 0xe53f0
leaq 0x692a1(%rip), %rdx     # 0x119058
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0xea, %rbx
leaq 0x35260(%rip), %rsi     # 0xe5034
leaq 0x692f2(%rip), %rdx     # 0x1190cd
movq %rbx, %rdi
movl $0x632, %ecx            # imm = 0x632
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_sigma
int harmonic_sigma(
                   struct background * pba,
                   struct primordial * ppm,
                   struct harmonic * phr,
                   double R,
                   double z,
                   double * sigma
                   ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_sigma() which is deprecated since v2.8. It will soon be removed. Use fourier_sigmas_at_z() instead.\n");

  if (phr->pfo->has_pk_m) {

    class_call(fourier_sigma_at_z(pba,
                                  phr->pfo,
                                  R,
                                  z,
                                  phr->pfo->index_pk_m,
                                  80., // hardcoded, yes, but the function is deprecated...
                                  sigma),
               phr->pfo->error_message,
               phr->error_message);

  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rcx, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rdi, %r15
movq 0x93186(%rip), %rax     # 0x142fb0
movq (%rax), %rcx
leaq 0x692bb(%rip), %rdi     # 0x1190ef
pushq $0x1
popq %rdx
movl $0x99, %esi
callq 0x8700
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
cmpw $0x0, 0x50(%rsi)
je 0xafeca
movl 0x54(%rsi), %edx
movsd 0x6848c(%rip), %xmm2    # 0x1182e8
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rcx
callq 0x9ea24
cmpl $0x1, %eax
jne 0xafeca
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0x35566(%rip), %rsi     # 0xe53f0
leaq 0x692f8(%rip), %rdx     # 0x119189
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0xea, %rbx
leaq 0x35186(%rip), %rsi     # 0xe5034
leaq 0x6931e(%rip), %rdx     # 0x1191d3
movq %rbx, %rdi
movl $0x65b, %ecx            # imm = 0x65B
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_sigma_cb
int harmonic_sigma_cb(
                      struct background * pba,
                      struct primordial * ppm,
                      struct harmonic * phr,
                      double R,
                      double z,
                      double * sigma_cb
                      ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_sigma_cb() which is deprecated since v2.8. It will soon be removed. Use fourier_sigmas_at_z() instead.\n");

  if (phr->pfo->has_pk_cb) {

    class_call(fourier_sigma_at_z(pba,
                                  phr->pfo,
                                  R,
                                  z,
                                  phr->pfo->index_pk_cb,
                                  80., // hardcoded, yes, but the function is deprecated...
                                  sigma_cb),
               phr->pfo->error_message,
               phr->error_message);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rcx, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rdi, %r15
movq 0x930ae(%rip), %rax     # 0x142fb0
movq (%rax), %rcx
leaq 0x692d6(%rip), %rdi     # 0x1191e2
pushq $0x1
popq %rdx
movl $0x9c, %esi
callq 0x8700
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
cmpw $0x0, 0x52(%rsi)
je 0xaffa2
movl 0x58(%rsi), %edx
movsd 0x683b4(%rip), %xmm2    # 0x1182e8
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rcx
callq 0x9ea24
cmpl $0x1, %eax
jne 0xaffa2
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0x3548e(%rip), %rsi     # 0xe53f0
leaq 0x69316(%rip), %rdx     # 0x11927f
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0xea, %rbx
leaq 0x350ae(%rip), %rsi     # 0xe5034
leaq 0x69340(%rip), %rdx     # 0x1192cd
movq %rbx, %rdi
movl $0x686, %ecx            # imm = 0x686
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_cl_at_l
int lensing_cl_at_l(
                    struct lensing * ple,
                    int l,
                    double * cl_lensed    /* array with argument cl_lensed[index_ct] (must be already allocated) */
                    ) {
  int last_index;
  int index_lt;

  class_test(l > ple->l_lensed_max,
             ple->error_message,
             "you asked for lensed Cls at l=%d, they were computed only up to l=%d, you should increase l_max_scalars or decrease the precision parameter delta_l_max",l,ple->l_lensed_max);

  class_call(array_interpolate_spline(ple->l,
                                      ple->l_size,
                                      ple->cl_lens,
                                      ple->ddcl_lens,
                                      ple->lt_size,
                                      l,
                                      &last_index,
                                      cl_lensed,
                                      ple->lt_size,
                                      ple->error_message),
             ple->error_message,
             ple->error_message);

  /* set to zero for the types such that l<l_max */
  for (index_lt=0; index_lt<ple->lt_size; index_lt++)
    if ((int)l > ple->l_max_lt[index_lt])
      cl_lensed[index_lt]=0.;

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %esi, %ebp
movq %rdi, %rbx
movl 0x5c(%rdi), %ecx
cmpl %esi, %ecx
jge 0xb09f6
leaq 0x6b8eb(%rip), %rsi     # 0x11c28f
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2e014
leaq 0x346c3(%rip), %rsi     # 0xe5082
leaq 0x6b961(%rip), %rdx     # 0x11c327
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x92, %rbx
leaq 0x34650(%rip), %rsi     # 0xe5034
leaq 0x6b952(%rip), %rdx     # 0x11c33d
pushq $0x32
popq %rcx
movq %rbx, %rdi
movq %r15, %r8
jmp 0xb0a71
movq %rdx, %r14
movq 0x70(%rbx), %rdi
movl 0x54(%rbx), %r8d
movl 0x60(%rbx), %esi
movq 0x78(%rbx), %rdx
movq 0x80(%rbx), %rcx
cvtsi2sd %ebp, %xmm0
leaq 0x92(%rbx), %r15
subq $0x8, %rsp
leaq 0x8(%rsp), %r9
pushq %r15
pushq %r8
pushq %r14
callq 0x1604b
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0xb0a89
leaq 0x349b2(%rip), %rsi     # 0xe53f0
leaq 0x6b908(%rip), %rdx     # 0x11c34d
leaq 0x800(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x345d3(%rip), %rsi     # 0xe5034
leaq 0x6b8d5(%rip), %rdx     # 0x11c33d
pushq $0x3f
popq %rcx
movq %r15, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x54(%rbx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xb0a7b
movq 0x68(%rbx), %rsi
cmpl %ebp, (%rsi,%rdx,4)
jge 0xb0aa8
andq $0x0, (%r14,%rdx,8)
incq %rdx
jmp 0xb0a95
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_addback_cl_tt
int lensing_addback_cl_tt(
                          struct lensing * ple,
                          double *cl_tt) {
  int index_l, l;

  for (index_l=0; index_l<ple->l_size; index_l++) {
    l = (int)ple->l[index_l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_tt] += cl_tt[l];
  }
  return _SUCCESS_;

}

// Assembly:
movslq 0x60(%rdi), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xb909d
movq 0x70(%rdi), %rdx
cvttsd2si (%rdx,%rcx,8), %edx
movq 0x78(%rdi), %r8
movslq %edx, %rdx
movsd (%rsi,%rdx,8), %xmm0
movslq 0x54(%rdi), %rdx
movslq %ecx, %r9
imulq %rdx, %r9
movslq 0x2c(%rdi), %rdx
addq %r9, %rdx
addsd (%r8,%rdx,8), %xmm0
movsd %xmm0, (%r8,%rdx,8)
incq %rcx
jmp 0xb9060
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_addback_cl_te
int lensing_addback_cl_te(
                          struct lensing * ple,
                          double *cl_te) {
  int index_l, l;

  for (index_l=0; index_l<ple->l_size; index_l++) {
    l = (int)ple->l[index_l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_te] += cl_te[l];
  }
  return _SUCCESS_;

}

// Assembly:
movslq 0x60(%rdi), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xb9469
movq 0x70(%rdi), %rdx
cvttsd2si (%rdx,%rcx,8), %edx
movq 0x78(%rdi), %r8
movslq %edx, %rdx
movsd (%rsi,%rdx,8), %xmm0
movslq 0x54(%rdi), %rdx
movslq %ecx, %r9
imulq %rdx, %r9
movslq 0x34(%rdi), %rdx
addq %r9, %rdx
addsd (%r8,%rdx,8), %xmm0
movsd %xmm0, (%r8,%rdx,8)
incq %rcx
jmp 0xb942c
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_addback_cl_ee_bb
int lensing_addback_cl_ee_bb(
                             struct lensing * ple,
                             double * cl_ee,
                             double * cl_bb) {

  int index_l, l;

  for (index_l=0; index_l<ple->l_size; index_l++) {
    l = (int)ple->l[index_l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_ee] += cl_ee[l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_bb] += cl_bb[l];
  }
  return _SUCCESS_;

}

// Assembly:
movslq 0x60(%rdi), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xb9872
movq 0x70(%rdi), %r8
cvttsd2si (%r8,%rcx,8), %r8d
movq 0x78(%rdi), %r9
movslq %r8d, %r8
movsd (%rsi,%r8,8), %xmm0
movslq 0x54(%rdi), %r10
movslq %ecx, %r11
imulq %r10, %r11
movslq 0x30(%rdi), %r10
addq %r11, %r10
addsd (%r9,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
movsd (%rdx,%r8,8), %xmm0
movslq 0x38(%rdi), %r8
movslq %r11d, %r10
addq %r8, %r10
addsd (%r9,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %rcx
jmp 0xb9817
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_constants
int distortions_constants(struct precision * ppr,
                          struct background * pba,
                          struct thermodynamics * pth,
                          struct distortions * psd){

  /** Define unit conventions */
  psd->x_to_nu = (_k_B_*pba->T_cmb/_h_P_)/1e9;                    // [GHz]
  psd->DI_units = 2.*pow(_k_B_*pba->T_cmb,3.)/pow(_h_P_*_c_,2.);  // [W/(m^2 Hz sr)]

  /** Define transition redshifts z_muy and z_th */
  psd->z_muy = 5.e4;
  psd->z_th = 1.98e6*
    pow((1.-pth->YHe/2.)/0.8767,-2./5.)*
    pow(pba->Omega0_b*pow(pba->h,2.)/0.02225,-2./5.)*
    pow(pba->T_cmb/2.726,1./5.);

  class_sprintf(psd->sd_PCA_file_generator,"%s/%s",ppr->sd_external_path,"generate_PCA_files.py");
  class_sprintf(psd->sd_detector_list_file,"%s/%s",ppr->sd_external_path,"detectors_list.dat");

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movsd 0x18(%rsi), %xmm0
mulsd 0x29a08(%rip), %xmm0    # 0xe9b00
movq %rdx, %r12
movapd %xmm0, %xmm1
divsd 0x5cbb9(%rip), %xmm1    # 0x11ccc0
movq %rdi, %r14
divsd 0x29a36(%rip), %xmm1    # 0xe9b48
movsd %xmm1, 0x380(%rcx)
movsd 0x26626(%rip), %xmm1    # 0xe6748
callq 0x8650
addsd %xmm0, %xmm0
divsd 0x5cb95(%rip), %xmm0    # 0x11ccc8
movsd %xmm0, 0x388(%rbx)
movabsq $0x40e86a0000000000, %rax # imm = 0x40E86A0000000000
movq %rax, 0x310(%rbx)
movsd (%r12), %xmm0
mulsd 0x282de(%rip), %xmm0    # 0xe8438
addsd 0x250fe(%rip), %xmm0    # 0xe5260
divsd 0x5cb66(%rip), %xmm0    # 0x11ccd0
movsd 0x5cb66(%rip), %xmm1    # 0x11ccd8
callq 0x8650
mulsd 0x5cb61(%rip), %xmm0    # 0x11cce0
movsd %xmm0, (%rsp)
movsd 0x8(%r15), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x20(%r15), %xmm0
divsd 0x5cb4c(%rip), %xmm0    # 0x11cce8
movsd 0x5cb34(%rip), %xmm1    # 0x11ccd8
callq 0x8650
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%r15), %xmm0
divsd 0x5cb2f(%rip), %xmm0    # 0x11ccf0
movsd 0x250cf(%rip), %xmm1    # 0xe5298
callq 0x8650
mulsd (%rsp), %xmm0
movsd %xmm0, 0x318(%rbx)
addq $0x928, %r14            # imm = 0x928
leaq 0x5cdc8(%rip), %r15     # 0x11cfb1
leaq 0x5cdc7(%rip), %r12     # 0x11cfb7
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x8580
leaq 0x6f4(%rbx), %rdi
incl %eax
movslq %eax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x8580
leaq 0x5cda6(%rip), %r12     # 0x11cfcd
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x8580
addq $0x958, %rbx            # imm = 0x958
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x8580
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_free
int distortions_free(struct distortions * psd) {

  /** Define local variables */
  int index_type;

  if (psd->has_distortions == _TRUE_) {
    /** Delete lists */
    free(psd->z);
    free(psd->z_weights);
    free(psd->x);
    free(psd->x_weights);

    /** Delete noise file */
    if (psd->has_detector_file == _TRUE_) {
      free(psd->delta_Ic_array);
    }

    /** Delete branching ratios */
    for (index_type=0;index_type<psd->type_size;++index_type){
      free(psd->br_table[index_type]);
    }
    free(psd->br_table);

    /** Delete heating functions */
    free(psd->dQrho_dz_tot);

    /** Delete distortion shapes */
    for (index_type=0;index_type<psd->type_size;++index_type){
      free(psd->sd_shape_table[index_type]);
      free(psd->sd_table[index_type]);
    }
    free(psd->sd_shape_table);
    free(psd->sd_table);

    /** Delete distortion amplitudes */
    free(psd->sd_parameter_table);

    /** Delete total distortion */
    free(psd->DI);
  }
  psd->is_allocated = _FALSE_;

  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0xcd0(%rdi)
jne 0xc2978
movq 0x340(%rbx), %rdi
callq 0x8430
movq 0x348(%rbx), %rdi
callq 0x8430
movq 0x370(%rbx), %rdi
callq 0x8430
movq 0x378(%rbx), %rdi
callq 0x8430
cmpl $0x1, 0xcdc(%rbx)
jne 0xc28e6
movq 0xcc8(%rbx), %rdi
callq 0x8430
xorl %r14d, %r14d
movslq 0xbf0(%rbx), %rax
movq 0xbc0(%rbx), %rdi
cmpq %rax, %r14
jge 0xc290a
movq (%rdi,%r14,8), %rdi
callq 0x8430
incq %r14
jmp 0xc28e9
callq 0x8430
movq 0xc00(%rbx), %rdi
callq 0x8430
xorl %r14d, %r14d
movslq 0xbf0(%rbx), %rax
movq 0xbd0(%rbx), %rdi
cmpq %rax, %r14
jge 0xc294f
movq (%rdi,%r14,8), %rdi
callq 0x8430
movq 0xbd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
incq %r14
jmp 0xc291e
callq 0x8430
movq 0xbd8(%rbx), %rdi
callq 0x8430
movq 0xbc8(%rbx), %rdi
callq 0x8430
movq 0xc10(%rbx), %rdi
callq 0x8430
andw $0x0, 0x1e02(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_free_br_data
int distortions_free_br_data(struct distortions * psd){

  free(psd->br_exact_z);
  free(psd->f_g_exact);
  free(psd->ddf_g_exact);
  free(psd->f_y_exact);
  free(psd->ddf_y_exact);
  free(psd->f_mu_exact);
  free(psd->ddf_mu_exact);
  free(psd->E_vec);
  free(psd->ddE_vec);

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xc18(%rdi), %rdi
callq 0x8430
movq 0xc28(%rbx), %rdi
callq 0x8430
movq 0xc30(%rbx), %rdi
callq 0x8430
movq 0xc38(%rbx), %rdi
callq 0x8430
movq 0xc40(%rbx), %rdi
callq 0x8430
movq 0xc48(%rbx), %rdi
callq 0x8430
movq 0xc50(%rbx), %rdi
callq 0x8430
movq 0xc58(%rbx), %rdi
callq 0x8430
movq 0xc60(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_free_sd_data
int distortions_free_sd_data(struct distortions * psd){

  free(psd->PCA_nu);
  free(psd->PCA_G_T);
  free(psd->ddPCA_G_T);
  free(psd->PCA_Y_SZ);
  free(psd->ddPCA_Y_SZ);
  free(psd->PCA_M_mu);
  free(psd->ddPCA_M_mu);
  free(psd->S_vec);
  free(psd->ddS_vec);

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xc70(%rdi), %rdi
callq 0x8430
movq 0xc80(%rbx), %rdi
callq 0x8430
movq 0xc88(%rbx), %rdi
callq 0x8430
movq 0xc90(%rbx), %rdi
callq 0x8430
movq 0xc98(%rbx), %rdi
callq 0x8430
movq 0xca0(%rbx), %rdi
callq 0x8430
movq 0xca8(%rbx), %rdi
callq 0x8430
movq 0xcb0(%rbx), %rdi
callq 0x8430
movq 0xcb8(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_output_heat_titles
int distortions_output_heat_titles(struct distortions * psd,
                                   char titles[_MAXTITLESTRINGLENGTH_]){

  class_store_columntitle(titles,"Redshift z",_TRUE_);
  class_store_columntitle(titles,"Heat  [-]",_TRUE_);
  class_store_columntitle(titles,"LHeat [-]",_TRUE_);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x8190
movabsq $0x7466696873646552, %rcx # imm = 0x7466696873646552
movq %rcx, (%rbx,%rax)
movl $0x7a2074, 0x7(%rbx,%rax) # imm = 0x7A2074
movq %rbx, %rdi
callq 0x8190
movw $0x9, %bp
movw %bp, (%rbx,%rax)
movq %rbx, %rdi
callq 0x8190
movabsq $0x2d5b202074616548, %rcx # imm = 0x2D5B202074616548
movq %rcx, (%rbx,%rax)
movw $0x5d, %r14w
movw %r14w, 0x8(%rbx,%rax)
movq %rbx, %rdi
callq 0x8190
movw %bp, (%rbx,%rax)
movq %rbx, %rdi
callq 0x8190
movabsq $0x2d5b20746165484c, %rcx # imm = 0x2D5B20746165484C
movq %rcx, (%rbx,%rax)
movw %r14w, 0x8(%rbx,%rax)
movq %rbx, %rdi
callq 0x8190
movw %bp, (%rbx,%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_output_heat_data
int distortions_output_heat_data(struct distortions * psd,
                                 int number_of_titles,
                                 double * data){
  int storeidx;
  double * dataptr;
  int index_z;

  for (index_z=0; index_z<psd->z_size; index_z++) {
    dataptr = data + index_z*number_of_titles;
    storeidx = 0;
    class_store_double(dataptr, psd->z[index_z], _TRUE_, storeidx);
    class_store_double(dataptr, psd->dQrho_dz_tot[index_z], _TRUE_, storeidx);
    class_store_double(dataptr, psd->dQrho_dz_tot[index_z]*(1.+psd->z[index_z]), _TRUE_, storeidx);
  }

  return _SUCCESS_;
}

// Assembly:
movslq 0x330(%rdi), %rax
movslq %esi, %rcx
addq $0x10, %rdx
shlq $0x3, %rcx
xorl %esi, %esi
movsd 0x1f203(%rip), %xmm0    # 0xe5260
cmpq %rax, %rsi
jge 0xc60a0
movq 0x340(%rdi), %r8
movsd (%r8,%rsi,8), %xmm1
movsd %xmm1, -0x10(%rdx)
movq 0xc00(%rdi), %r9
movsd (%r9,%rsi,8), %xmm1
movsd %xmm1, -0x8(%rdx)
movsd (%r8,%rsi,8), %xmm2
addsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rdx)
incq %rsi
addq %rcx, %rdx
jmp 0xc605d
xorl %eax, %eax
retq