LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_hubble
int primordial_inflation_hubble(
                                struct primordial * ppm,
                                double phi,
                                double * H,
                                double * dH,
                                double * ddH,
                                double * dddH
                                ) {

  *H =    ppm->H0 + phi*ppm->H1 + pow(phi,2)/2.*ppm->H2 + pow(phi,3)/6.*ppm->H3 + pow(phi,4)/24.*ppm->H4;
  *dH =   ppm->H1 + phi*ppm->H2 + pow(phi,2)/2.*ppm->H3 + pow(phi,3)/6.*ppm->H4;
  *ddH =  ppm->H2 + phi*ppm->H3 + pow(phi,2)/2.*ppm->H4;
  *dddH = ppm->H3 + phi*ppm->H4;

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
movsd 0x1e0(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x1d8(%rdi), %xmm1
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
mulsd %xmm0, %xmm2
mulsd 0x5625d(%rip), %xmm2    # 0xeecd0
movsd %xmm2, 0x18(%rsp)
movq %rsi, %r13
movsd 0x1e8(%rdi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rsp)
movsd 0x56be6(%rip), %xmm1    # 0xef680
callq 0x8620
divsd 0x56bc9(%rip), %xmm0    # 0xef670
mulsd 0x1f0(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x58974(%rip), %xmm1    # 0xf1438
movsd 0x10(%rsp), %xmm0
callq 0x8620
divsd 0x56c19(%rip), %xmm0    # 0xef6f0
mulsd 0x1f8(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r13)
movsd 0x1e8(%r14), %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm1
addsd 0x1e0(%r14), %xmm1
movsd 0x1f0(%r14), %xmm2
mulsd 0x18(%rsp), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x56b57(%rip), %xmm1    # 0xef680
callq 0x8620
divsd 0x56b3a(%rip), %xmm0    # 0xef670
mulsd 0x1f8(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r12)
movsd 0x1f0(%r14), %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd 0x1e8(%r14), %xmm0
movsd 0x18(%rsp), %xmm1
mulsd 0x1f8(%r14), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r15)
movapd %xmm2, %xmm0
mulsd 0x1f8(%r14), %xmm0
addsd 0x1f0(%r14), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_check_hubble
int primordial_inflation_check_hubble(
                                      struct primordial * ppm,
                                      double phi,
                                      double * H,
                                      double * dH,
                                      double * ddH,
                                      double * dddH
                                      ) {

  class_call(primordial_inflation_hubble(ppm,
                                         phi,
                                         H,dH,ddH,dddH),
             ppm->error_message,
             ppm->error_message);

  class_test(*H < 0.,
             ppm->error_message,
             "this H(phi) is not physical. H = %e",
             *H);

  class_test(*dH > 0.,
             ppm->error_message,
             "this H(phi) is not decreasing with growing phi. dH/dphi = %e",
             *dH);

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x98a30
movsd (%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9a0a9
leaq 0x804a5(%rip), %rsi     # 0x11a4ff
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x5400f(%rip), %rsi     # 0xee082
leaq 0x804a9(%rip), %rdx     # 0x11a523
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x53f9c(%rip), %rsi     # 0xee034
leaq 0x8043e(%rip), %rdx     # 0x11a4dd
movq %rbx, %rdi
movl $0x99f, %ecx            # imm = 0x99F
jmp 0x9a10a
movsd (%r14), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jbe 0x9a119
leaq 0x8046e(%rip), %rsi     # 0x11a52b
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x53fac(%rip), %rsi     # 0xee082
leaq 0x8048b(%rip), %rdx     # 0x11a568
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x53f39(%rip), %rsi     # 0xee034
leaq 0x803db(%rip), %rdx     # 0x11a4dd
movq %rbx, %rdi
movl $0x9a4, %ecx            # imm = 0x9A4
movq %r15, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_check_potential
int primordial_inflation_check_potential(
                                         struct primordial * ppm,
                                         double phi,
                                         double * V,
                                         double * dV,
                                         double * ddV
                                         ) {

  class_call(primordial_inflation_potential(ppm,phi,V,dV,ddV),
             ppm->error_message,
             ppm->error_message);

  class_test(*V <= 0.,
             ppm->error_message,
             "This potential becomes negative at phi=%g, before the end of observable inflation. It  cannot be treated by this code",
             phi);

  class_test(*dV >= 0.,
             ppm->error_message,
             "All the code is written for the case dV/dphi<0. Here, in phi=%g, we have dV/dphi=%g. This potential cannot be treated by this code",
             phi,*dV);

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
callq 0x9841a
testl %eax, %eax
je 0x9b450
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x52fd7(%rip), %rsi     # 0xee3f0
leaq 0x7ef5b(%rip), %rdx     # 0x11a37b
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x52bfb(%rip), %rsi     # 0xee034
leaq 0x7ef6c(%rip), %rdx     # 0x11a3ac
movq %rbx, %rdi
movl $0x96d, %ecx            # imm = 0x96D
movq %r14, %r8
jmp 0x9b523
movsd 0x8(%rsp), %xmm0
xorpd %xmm2, %xmm2
ucomisd (%r15), %xmm2
jae 0x9b4ca
movsd (%r14), %xmm1
xorl %eax, %eax
ucomisd %xmm2, %xmm1
jb 0x9b52f
leaq 0x7efd7(%rip), %rsi     # 0x11a450
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x52bf3(%rip), %rsi     # 0xee082
leaq 0x7f03d(%rip), %rdx     # 0x11a4d3
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x52b7b(%rip), %rsi     # 0xee034
leaq 0x7eeec(%rip), %rdx     # 0x11a3ac
movq %rbx, %rdi
movl $0x977, %ecx            # imm = 0x977
jmp 0x9b520
leaq 0x7ef00(%rip), %rsi     # 0x11a3d1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0x52b9b(%rip), %rsi     # 0xee082
leaq 0x7ef59(%rip), %rdx     # 0x11a447
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x52b23(%rip), %rsi     # 0xee034
leaq 0x7ee94(%rip), %rdx     # 0x11a3ac
movq %rbx, %rdi
movl $0x972, %ecx            # imm = 0x972
movq %r15, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_get_epsilon
int primordial_inflation_get_epsilon(
                                     struct primordial * ppm,
                                     double phi,
                                     double * epsilon
                                     ) {

  double V,dV,ddV;
  double H,dH,ddH,dddH;

  switch (ppm->primordial_spec_type) {

  case inflation_V:
  case inflation_V_end:

    class_call(primordial_inflation_potential(ppm,
                                              phi,
                                              &V,&dV,&ddV),
               ppm->error_message,
               ppm->error_message);

    *epsilon = 1./16./_PI_*pow(dV/V,2);
    //*eta = 1./8./pi*(ddV/V)
    break;

  case inflation_H:

    class_call(primordial_inflation_hubble(ppm,
                                           phi,
                                           &H,&dH,&ddH,&dddH),
               ppm->error_message,
               ppm->error_message);

    *epsilon = 1./4./_PI_*pow(dH/H,2);
    break;

  default:
    class_stop(ppm->error_message,"ppm->primordial_spec_type=%d different from possible relevant cases",ppm->primordial_spec_type);
    break;
  }

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rdi), %edx
cmpl $0x4, %edx
je 0x9c6af
cmpl $0x3, %edx
je 0x9c714
cmpl $0x2, %edx
jne 0x9c750
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x9841a
testl %eax, %eax
je 0x9c7b0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x51d16(%rip), %rsi     # 0xee3f0
leaq 0x7de90(%rip), %rdx     # 0x11a571
leaq 0x810(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x51937(%rip), %rsi     # 0xee034
leaq 0x7dea3(%rip), %rdx     # 0x11a5a7
movq %rbx, %rdi
movl $0x9c5, %ecx            # imm = 0x9C5
movq %r14, %r8
jmp 0x9c7a2
leaq 0x810(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x98a30
movsd (%r12), %xmm0
divsd (%r15), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x7bd32(%rip), %xmm0    # 0x118480
jmp 0x9c7c7
leaq 0x7ce04(%rip), %rsi     # 0x11955b
leaq 0x810(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x51e15(%rip), %rsi     # 0xee585
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x518a4(%rip), %rsi     # 0xee034
leaq 0x7de10(%rip), %rdx     # 0x11a5a7
movq %rbx, %rdi
movl $0x9d7, %ecx            # imm = 0x9D7
movq %r15, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0x9c7ce
movsd (%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x7bd41(%rip), %xmm0    # 0x118508
movsd %xmm0, (%r14)
xorl %eax, %eax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_output_data
int primordial_output_data(struct perturbations * ppt,
                           struct primordial * ppm,
                           int number_of_titles,
                           double *data){

  int index_k, storeidx;
  double *dataptr;

  for (index_k=0; index_k<ppm->lnk_size; index_k++) {
    dataptr = data + index_k*number_of_titles;
    storeidx = 0;

    class_store_double(dataptr, exp(ppm->lnk[index_k]), _TRUE_,storeidx);
    class_store_double(dataptr, exp(ppm->lnpk[ppt->index_md_scalars][index_k]), _TRUE_,storeidx);
    class_store_double(dataptr, exp(ppm->lnpk[ppt->index_md_tensors][index_k]), ppt->has_tensors,storeidx);
  }


  return _SUCCESS_;

}

// Assembly:
cmpl $0x0, 0x290(%rsi)
jle 0x9c923
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %r12
addq $0x10, %rbx
shlq $0x3, %r12
xorl %r13d, %r13d
movq 0x298(%r14), %rax
movsd (%rax,%r13,8), %xmm0
callq 0x8670
movsd %xmm0, -0x10(%rbx)
movq 0x2a0(%r14), %rax
movslq 0x848(%r15), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%r13,8), %xmm0
callq 0x8670
movsd %xmm0, -0x8(%rbx)
cmpw $0x1, 0x12(%r15)
jne 0x9c908
movq 0x2a0(%r14), %rax
movslq 0x84c(%r15), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%r13,8), %xmm0
callq 0x8670
movsd %xmm0, (%rbx)
incq %r13
movslq 0x290(%r14), %rax
addq %r12, %rbx
cmpq %rax, %r13
jl 0x9c8a6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/fourier.c
// Function: fourier_wnw_split
int fourier_wnw_split(
                      struct precision *ppr,
                      struct background *pba,
                      struct primordial * ppm,
                      struct fourier *pfo
                      ) {

  class_call(hmcode_wnw_split(ppr,pba,ppm,pfo),
             pfo->error_message,
             pfo->error_message);

  if (pfo->ln_tau_size > 1) {
    /** - spline the nowiggle spectrum with respect to time */
    class_call(array_spline_table_lines(pfo->ln_tau,
                                        pfo->ln_tau_size,
                                        pfo->ln_pk_l_nw_extra,
                                        pfo->k_size_extra,
                                        pfo->ddln_pk_l_nw_extra,
                                        _SPLINE_EST_DERIV_,
                                        pfo->error_message),
               pfo->error_message,
               pfo->error_message);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rcx, %rbx
callq 0xe4101
cmpl $0x1, %eax
jne 0xa30f2
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b33e(%rip), %rsi     # 0xee3f0
leaq 0x7ae0f(%rip), %rdx     # 0x11dec8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4af62(%rip), %rsi     # 0xee034
leaq 0x7ae11(%rip), %rdx     # 0x11deea
movq %rbx, %rdi
movl $0xa44, %ecx            # imm = 0xA44
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %ebp
jmp 0xa3170
movl 0x90(%rbx), %esi
xorl %ebp, %ebp
cmpl $0x2, %esi
jl 0xa3170
movq 0x88(%rbx), %rdi
movq 0x130(%rbx), %rdx
movl 0x104(%rbx), %ecx
movq 0x138(%rbx), %r8
addq $0x192, %rbx            # imm = 0x192
movq %rbx, (%rsp)
movl $0x1, %r9d
callq 0x142a8
cmpl $0x1, %eax
jne 0xa3170
leaq 0x4b2b4(%rip), %rsi     # 0xee3f0
leaq 0x7adb9(%rip), %rdx     # 0x11defc
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4aed8(%rip), %rsi     # 0xee034
leaq 0x7ad87(%rip), %rdx     # 0x11deea
movq %rbx, %rdi
movl $0xa50, %ecx            # imm = 0xA50
jmp 0xa30e1
movl %ebp, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/fourier.c
// Function: fourier_get_tau_list
int fourier_get_tau_list(
                         struct perturbations * ppt,
                         struct fourier * pfo
                         ) {

  int index_tau;

  /** -> for linear calculations: only late times are considered, given the value z_max_pk inferred from the ionput */
  pfo->ln_tau_size = ppt->ln_tau_size;

  if (ppt->ln_tau_size > 1) {

    class_alloc(pfo->ln_tau,pfo->ln_tau_size*sizeof(double),pfo->error_message);

    for (index_tau=0; index_tau<pfo->ln_tau_size;index_tau++) {
      pfo->ln_tau[index_tau] = ppt->ln_tau[index_tau];
    }
  }

  /** -> for non-linear calculations: we wills store a correction factor for all times */
  if (pfo->method > nl_none) {

    pfo->tau_size = ppt->tau_size;

    class_alloc(pfo->tau,pfo->tau_size*sizeof(double),pfo->error_message);

    for (index_tau=0; index_tau<pfo->tau_size; index_tau++) {
      pfo->tau[index_tau] = ppt->tau_sampling[index_tau];
    }
  }
  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, %rbx
movq %rdi, %r14
movslq 0xa60(%rdi), %r15
movl %r15d, 0x90(%rsi)
cmpq $0x2, %r15
jl 0xa382f
leaq (,%r15,8), %rdi
callq 0x8460
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0xa38cf
movq 0xa58(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0xa381d
xorl %r15d, %r15d
cmpl $0x0, (%rbx)
je 0xa391e
movslq 0x9f8(%r14), %r12
movl %r12d, 0x140(%rbx)
leaq (,%r12,8), %rdi
callq 0x8460
movq %rax, 0x148(%rbx)
testq %rax, %rax
je 0xa388e
testl %r12d, %r12d
jle 0xa391e
movq 0x9f0(%r14), %rcx
xorl %r15d, %r15d
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0xa3877
jmp 0xa391e
shll $0x3, %r12d
leaq 0x4a76b(%rip), %rsi     # 0xee004
leaq 0x7a30c(%rip), %rdx     # 0x11dbac
movq %rsp, %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4a776(%rip), %rsi     # 0xee034
leaq 0x7a2d2(%rip), %rdx     # 0x11db97
movq %rbx, %rdi
movl $0x8b8, %ecx            # imm = 0x8B8
jmp 0xa390e
shll $0x3, %r15d
leaq 0x4a72a(%rip), %rsi     # 0xee004
leaq 0x7a2aa(%rip), %rdx     # 0x11db8b
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x192, %rbx            # imm = 0x192
leaq 0x4a735(%rip), %rsi     # 0xee034
leaq 0x7a291(%rip), %rdx     # 0x11db97
movq %rbx, %rdi
movl $0x8ac, %ecx            # imm = 0x8AC
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %r15d
movl %r15d, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_source_tau_size_max
int transfer_source_tau_size_max(
                                 struct precision * ppr,
                                 struct background * pba,
                                 struct perturbations * ppt,
                                 struct transfer * ptr,
                                 double tau_rec,
                                 double tau0,
                                 int * tau_size_max
                                 ) {

  int index_md;
  int index_tt;
  int tau_size_tt=0;

  *tau_size_max = 0;

  for (index_md = 0; index_md < ptr->md_size; index_md++) {

    for (index_tt = 0; index_tt < ptr->tt_size[index_md]; index_tt++) {

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

      *tau_size_max = MAX(*tau_size_max,tau_size_tt);
    }
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rcx, %rbx
movq %rdx, 0x18(%rsp)
xorl %eax, %eax
movl %eax, 0x14(%rsp)
movl %eax, (%r8)
movl 0x8a4(%rcx), %ecx
testl %ecx, %ecx
jle 0xa5bc6
movq %r8, %r14
movq %rsi, %r12
movq %rdi, %r13
movq 0x8f0(%rbx), %rax
xorl %ebp, %ebp
cmpl $0x0, (%rax,%rbp,4)
jle 0xa5b6b
xorl %r15d, %r15d
leaq 0x14(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rcx
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movl %ebp, %r8d
movl %r15d, %r9d
callq 0xaa264
testl %eax, %eax
jne 0xa5b7a
movl (%r14), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, (%r14)
incl %r15d
movq 0x8f0(%rbx), %rax
cmpl (%rax,%rbp,4), %r15d
jl 0xa5b14
movl 0x8a4(%rbx), %ecx
incq %rbp
movslq %ecx, %rdx
cmpq %rdx, %rbp
jl 0xa5b0b
xorl %eax, %eax
jmp 0xa5bc6
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x48868(%rip), %rsi     # 0xee3f0
leaq 0x79616(%rip), %rdx     # 0x11f1a5
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4848c(%rip), %rsi     # 0xee034
leaq 0x79654(%rip), %rdx     # 0x11f203
movq %rbx, %rdi
movl $0x66a, %ecx            # imm = 0x66A
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_perturbation_sources_spline_free
int transfer_perturbation_sources_spline_free(
                                              struct perturbations * ppt,
                                              struct transfer * ptr,
                                              double *** sources_spline
                                              ) {
  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++) {
        free(sources_spline[index_md][index_ic * ppt->tp_size[index_md] + index_tp]);
      }
    }
    free(sources_spline[index_md]);
  }
  free(sources_spline);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpl $0x0, 0x8a4(%rsi)
jle 0xa8194
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq 0x870(%r15), %rcx
cmpl $0x0, (%rcx,%r12,4)
jle 0xa817c
movq 0x998(%r15), %rax
xorl %ebp, %ebp
movl (%rax,%r12,4), %edx
testl %edx, %edx
jle 0xa8174
xorl %r13d, %r13d
movq (%rbx,%r12,8), %rax
imull %ebp, %edx
movslq %edx, %rcx
addq %r13, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8410
movq 0x998(%r15), %rax
movl (%rax,%r12,4), %edx
incq %r13
cmpl %edx, %r13d
jl 0xa8144
movq 0x870(%r15), %rcx
incl %ebp
cmpl (%rcx,%r12,4), %ebp
jl 0xa8139
movq (%rbx,%r12,8), %rdi
callq 0x8410
incq %r12
movslq 0x8a4(%r14), %rax
cmpq %rax, %r12
jl 0xa8122
movq %rbx, %rdi
callq 0x8410
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_O3/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
cmpl $0x0, 0x8a4(%rdi)
jle 0xa838b
movq %rdi, %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x8410
incq %r15
movslq 0x8a4(%r14), %rax
cmpq %rax, %r15
jl 0xa8373
movq %rbx, %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa850d
cmpl $0x0, 0x8a4(%rbx)
jle 0xa8425
xorl %r14d, %r14d
movq 0x8f8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0x958(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0x930(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
cmpw $0x1, 0x93c(%rbx)
jne 0xa8416
movq 0x960(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0x950(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0x8a4(%rbx), %rax
cmpq %rax, %r14
jl 0xa83bc
movq 0x8f0(%rbx), %rdi
callq 0x8410
movq 0x8f8(%rbx), %rdi
callq 0x8410
movq 0x900(%rbx), %rdi
callq 0x8410
movq 0x910(%rbx), %rdi
callq 0x8410
movq 0x928(%rbx), %rdi
callq 0x8410
movq 0x930(%rbx), %rdi
callq 0x8410
movq 0x958(%rbx), %rdi
callq 0x8410
cmpw $0x1, 0x93c(%rbx)
jne 0xa84a7
movq 0x948(%rbx), %rdi
callq 0x8410
movq 0x950(%rbx), %rdi
callq 0x8410
movq 0x960(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x75c(%rbx)
jle 0xa84d4
movq 0x760(%rbx), %rdi
callq 0x8410
movq 0x768(%rbx), %rdi
callq 0x8410
movq 0x770(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x87c(%rbx)
jle 0xa850d
movq 0x880(%rbx), %rdi
callq 0x8410
movq 0x888(%rbx), %rdi
callq 0x8410
movq 0x890(%rbx), %rdi
callq 0x8410
movq 0x898(%rbx), %rdi
callq 0x8410
movw $0x0, 0x116a(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x70df1(%rip), %xmm0    # 0x11e350
movsd %xmm0, 0x8(%rsp)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x43a4e(%rip), %xmm1    # 0xf0fc8
callq 0x8620
xorpd 0x40ca9(%rip), %xmm0    # 0xee230
callq 0x8670
mulsd (%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
movsd 0x43a24(%rip), %xmm1    # 0xf0fc8
callq 0x8620
mulsd 0x43a17(%rip), %xmm0    # 0xf0fc8
movsd 0x41747(%rip), %xmm1    # 0xeed00
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_O3/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 0xb0bfe
movq %rdi, %r14
addq $0x96a, %r14            # imm = 0x96A
movq %rbx, %rdi
movq %r14, %rsi
callq 0x232f2
cmpl $0x1, %eax
jne 0xb0bfe
leaq 0x3d830(%rip), %rsi     # 0xee3f0
leaq 0x6fd8e(%rip), %rdx     # 0x120955
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x3d456(%rip), %rsi     # 0xee034
leaq 0x6fda8(%rip), %rdx     # 0x12098d
movq %r14, %rdi
movl $0x11c1, %ecx           # imm = 0x11C1
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0xb0c54
movq 0x80(%rbx), %rdi
callq 0x8410
movq 0x88(%rbx), %rdi
callq 0x8410
movq 0x90(%rbx), %rdi
callq 0x8410
movq 0x98(%rbx), %rdi
callq 0x8410
movq 0xa0(%rbx), %rdi
callq 0x8410
movq 0xa8(%rbx), %rdi
callq 0x8410
movq 0xb0(%rbx), %rdi
callq 0x8410
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpl $0x0, 0x10(%rdi)
jle 0xb48eb
cmpl $0x0, 0x9c(%rbx)
jle 0xb48b4
xorl %r14d, %r14d
movq 0xb8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0xd0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0xd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0xb482a
movq 0xb0(%rbx), %rdi
callq 0x8410
movq 0xa0(%rbx), %rdi
callq 0x8410
movq 0xb8(%rbx), %rdi
callq 0x8410
movq 0xc0(%rbx), %rdi
callq 0x8410
movq 0xd0(%rbx), %rdi
callq 0x8410
movq 0xd8(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x10(%rbx)
jle 0xb48d0
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0xb48b7
movq 0x28(%rbx), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movw $0x0, 0x8ea(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb68c4
leaq 0x6eb7f(%rip), %rsi     # 0x1253ef
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x30af0
leaq 0x377f7(%rip), %rsi     # 0xee082
leaq 0x6ebf5(%rip), %rdx     # 0x125487
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x92, %rbx
leaq 0x37784(%rip), %rsi     # 0xee034
leaq 0x6ebe6(%rip), %rdx     # 0x12549d
movq %rbx, %rdi
movl $0x32, %ecx
movq %r15, %r8
jmp 0xb6941
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 0x18071
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0xb694f
leaq 0x37ae4(%rip), %rsi     # 0xee3f0
leaq 0x6eb9a(%rip), %rdx     # 0x1254ad
leaq 0x800(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x37705(%rip), %rsi     # 0xee034
leaq 0x6eb67(%rip), %rdx     # 0x12549d
movq %r15, %rdi
movl $0x3f, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0xb6975
movslq 0x54(%rbx), %rax
testq %rax, %rax
jle 0xb6973
movq 0x68(%rbx), %rcx
xorl %edx, %edx
cmpl %ebp, (%rcx,%rdx,4)
jge 0xb696b
movq $0x0, (%r14,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xb695e
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rax, %rax
jle 0xbf099
movq 0x70(%rdi), %rcx
movslq 0x54(%rdi), %rdx
movslq 0x2c(%rdi), %r8
shlq $0x3, %r8
addq 0x78(%rdi), %r8
shlq $0x3, %rdx
xorl %edi, %edi
cvttsd2si (%rcx,%rdi,8), %r9d
movslq %r9d, %r9
movsd (%rsi,%r9,8), %xmm0
addsd (%r8), %xmm0
movsd %xmm0, (%r8)
incq %rdi
addq %rdx, %r8
cmpq %rdi, %rax
jne 0xbf075
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rax, %rax
jle 0xbf89b
pushq %rbx
movq 0x70(%rdi), %rcx
movq 0x78(%rdi), %r8
movslq 0x54(%rdi), %r9
movslq 0x30(%rdi), %r10
movslq 0x38(%rdi), %rdi
shlq $0x3, %r9
xorl %r11d, %r11d
cvttsd2si (%rcx,%r11,8), %ebx
movslq %ebx, %rbx
movsd (%rsi,%rbx,8), %xmm0
addsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r8,%r10,8)
movsd (%rdx,%rbx,8), %xmm0
addsd (%r8,%rdi,8), %xmm0
movsd %xmm0, (%r8,%rdi,8)
incq %r11
addq %r9, %r8
cmpq %r11, %rax
jne 0xbf864
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b6ba(%rip), %xmm0    # 0xf2c40
movq %rdx, %r12
movapd %xmm0, %xmm1
divsd 0x5e87b(%rip), %xmm1    # 0x125e10
movq %rdi, %r14
divsd 0x2b6e0(%rip), %xmm1    # 0xf2c80
movsd %xmm1, 0x380(%rcx)
movsd 0x280d0(%rip), %xmm1    # 0xef680
callq 0x8620
addsd %xmm0, %xmm0
divsd 0x5e857(%rip), %xmm0    # 0x125e18
movsd %xmm0, 0x388(%rbx)
movabsq $0x40e86a0000000000, %rax # imm = 0x40E86A0000000000
movq %rax, 0x310(%rbx)
movsd (%r12), %xmm0
mulsd 0x29e90(%rip), %xmm0    # 0xf1478
addsd 0x26c70(%rip), %xmm0    # 0xee260
divsd 0x5e828(%rip), %xmm0    # 0x125e20
movsd 0x5e828(%rip), %xmm1    # 0x125e28
callq 0x8620
mulsd 0x5e823(%rip), %xmm0    # 0x125e30
movsd %xmm0, (%rsp)
movsd 0x8(%r15), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x20(%r15), %xmm0
divsd 0x5e80e(%rip), %xmm0    # 0x125e38
movsd 0x5e7f6(%rip), %xmm1    # 0x125e28
callq 0x8620
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%r15), %xmm0
divsd 0x5e7f1(%rip), %xmm0    # 0x125e40
movsd 0x26c41(%rip), %xmm1    # 0xee298
callq 0x8620
mulsd (%rsp), %xmm0
movsd %xmm0, 0x318(%rbx)
addq $0x928, %r14            # imm = 0x928
leaq 0x5ea8a(%rip), %r15     # 0x126101
leaq 0x5ea89(%rip), %r12     # 0x126107
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x8550
leaq 0x6f4(%rbx), %rdi
incl %eax
movslq %eax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x8550
leaq 0x5ea68(%rip), %r12     # 0x12611d
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x8550
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 0x8550
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc9f8b
movq 0x340(%rbx), %rdi
callq 0x8410
movq 0x348(%rbx), %rdi
callq 0x8410
movq 0x370(%rbx), %rdi
callq 0x8410
movq 0x378(%rbx), %rdi
callq 0x8410
cmpl $0x1, 0xcdc(%rbx)
jne 0xc9edd
movq 0xcc8(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0xbf0(%rbx)
jle 0xc9f08
xorl %r14d, %r14d
movq 0xbc0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0xbf0(%rbx), %rax
cmpq %rax, %r14
jl 0xc9ee9
movq 0xbc0(%rbx), %rdi
callq 0x8410
movq 0xc00(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0xbf0(%rbx)
jle 0xc9f5b
xorl %r14d, %r14d
movq 0xbd0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0xbd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0xbf0(%rbx), %rax
cmpq %rax, %r14
jl 0xc9f2c
movq 0xbd0(%rbx), %rdi
callq 0x8410
movq 0xbd8(%rbx), %rdi
callq 0x8410
movq 0xbc8(%rbx), %rdi
callq 0x8410
movq 0xc10(%rbx), %rdi
callq 0x8410
movw $0x0, 0x1e02(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rax, %rax
jle 0xcd780
movq 0x340(%rdi), %rcx
movq 0xc00(%rdi), %rdi
movslq %esi, %rsi
addq $0x10, %rdx
shlq $0x3, %rsi
xorl %r8d, %r8d
movsd 0x20b13(%rip), %xmm0    # 0xee260
movsd (%rcx,%r8,8), %xmm1
movsd %xmm1, -0x10(%rdx)
movsd (%rdi,%r8,8), %xmm1
movsd %xmm1, -0x8(%rdx)
movsd (%rcx,%r8,8), %xmm2
addsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rdx)
incq %r8
addq %rsi, %rdx
cmpq %r8, %rax
jne 0xcd74d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_output_sd_titles
int distortions_output_sd_titles(struct distortions * psd,
                                 char titles[_MAXTITLESTRINGLENGTH_]){

  char temp_title[256];
  int index_type;
  class_store_columntitle(titles,"Dimensionless frequency x",_TRUE_);
  class_store_columntitle(titles,"Frequency nu [GHz]",_TRUE_);
  class_store_columntitle(titles,"SD_tot",_TRUE_);
  for (index_type=0;index_type<psd->type_size;++index_type){
    if (index_type==psd->index_type_g) {
      class_sprintf(temp_title,"SD[g]");
    }
    if (index_type==psd->index_type_y) {
      class_sprintf(temp_title,"SD[y]");
    }
    if (index_type==psd->index_type_mu) {
      class_sprintf(temp_title,"SD[mu]");
    }
    if (index_type>=psd->index_type_PCA) {
      class_sprintf(temp_title,"SD[e_%i]",(index_type-psd->index_type_PCA));
    }
    class_store_columntitle(titles,temp_title,_TRUE_);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x8180
movups 0x5a812(%rip), %xmm0    # 0x127fb9
movups %xmm0, (%rbx,%rax)
movups 0x5a811(%rip), %xmm0    # 0x127fc3
movups %xmm0, 0xa(%rbx,%rax)
movq %rbx, %rdi
callq 0x8180
movw $0x9, %bp
movw %bp, (%rbx,%rax)
movq %rbx, %rdi
callq 0x8180
movups 0x5a7fd(%rip), %xmm0    # 0x127fd3
movups %xmm0, (%rbx,%rax)
movl $0x5d7a48, 0xf(%rbx,%rax) # imm = 0x5D7A48
movq %rbx, %rdi
callq 0x8180
movw %bp, (%rbx,%rax)
movq %rbx, %rdi
callq 0x8180
movl $0x745f4453, (%rbx,%rax) # imm = 0x745F4453
movl $0x746f74, 0x3(%rbx,%rax) # imm = 0x746F74
movq %rbx, %rdi
callq 0x8180
movw %bp, (%rbx,%rax)
cmpl $0x0, 0xbf0(%r14)
jle 0xcd8cd
movq %rsp, %r15
leaq 0x5a7d7(%rip), %r12     # 0x128000
xorl %ebp, %ebp
cmpl 0xbe0(%r14), %ebp
jne 0xcd842
movw $0x5d, 0x4(%rsp)
movl $0x675b4453, (%rsp)     # imm = 0x675B4453
cmpl 0xbe8(%r14), %ebp
jne 0xcd859
movw $0x5d, 0x4(%rsp)
movl $0x795b4453, (%rsp)     # imm = 0x795B4453
cmpl 0xbe4(%r14), %ebp
jne 0xcd871
movl $0x5d756d, 0x3(%rsp)    # imm = 0x5D756D
movl $0x6d5b4453, (%rsp)     # imm = 0x6D5B4453
movl %ebp, %ecx
subl 0xbec(%r14), %ecx
jl 0xcd8a5
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
movl %ebp, %ecx
subl 0xbec(%r14), %ecx
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x8550
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8660
movq %rbx, %rdi
callq 0x8180
movw $0x9, (%rbx,%rax)
incl %ebp
cmpl 0xbf0(%r14), %ebp
jl 0xcd82b
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_output_sd_data
int distortions_output_sd_data(struct distortions * psd,
                               int number_of_titles,
                               double * data){
  int index_type;
  int storeidx;
  double * dataptr;
  int index_x;

  for (index_x=0; index_x<psd->x_size; index_x++) {
    dataptr = data + index_x*number_of_titles;
    storeidx = 0;

    class_store_double(dataptr, psd->x[index_x], _TRUE_,storeidx);
    class_store_double(dataptr, psd->x[index_x]*psd->x_to_nu, _TRUE_,storeidx);
    class_store_double(dataptr, psd->DI[index_x]*1.e26*psd->DI_units, _TRUE_,storeidx);
    for (index_type=0;index_type<psd->type_size;++index_type){
      class_store_double(dataptr, psd->sd_table[index_type][index_x]*1.e26*psd->DI_units, _TRUE_,storeidx);
    }
  }

  return _SUCCESS_;
}

// Assembly:
movslq 0x368(%rdi), %rax
testq %rax, %rax
jle 0xcd9a3
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x370(%rdi), %rcx
movq 0xc10(%rdi), %r8
movl 0xbf0(%rdi), %r9d
movslq %esi, %rsi
leaq 0x18(%rdx), %r10
leaq (,%rsi,8), %r11
xorl %ebx, %ebx
movsd 0x5867c(%rip), %xmm0    # 0x125fa0
movq %rbx, %r14
imulq %rsi, %r14
movsd (%rcx,%rbx,8), %xmm1
movsd %xmm1, (%rdx,%r14,8)
mulsd 0x380(%rdi), %xmm1
movsd %xmm1, 0x8(%rdx,%r14,8)
movsd (%r8,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
mulsd 0x388(%rdi), %xmm1
movsd %xmm1, 0x10(%rdx,%r14,8)
testl %r9d, %r9d
jle 0xcd991
movq 0xbd8(%rdi), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %r12
movsd (%r12,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
mulsd 0x388(%rdi), %xmm1
movsd %xmm1, (%r10,%r15,8)
incq %r15
cmpq %r15, %r9
jne 0xcd96d
incq %rbx
addq %r11, %r10
cmpq %rax, %rbx
jne 0xcd924
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../external/heating/injection.c
// Function: injection_indices
int injection_indices(struct thermodynamics* pth){

  /** - Define local variables */
  struct injection* pin = &(pth->in);
  int index_dep,index_inj;

  /* Check energy injection */
  if(pin->DM_annihilation_efficiency!=0){
    pin->has_DM_ann = _TRUE_;
  }
  if(pin->DM_decay_fraction!=0){
    pin->has_DM_dec = _TRUE_;
  }
  if(pin->PBH_evaporation_fraction!=0){
    pin->has_PBH_eva = _TRUE_;
  }
  if(pin->PBH_accretion_fraction!=0){
    pin->has_PBH_acc = _TRUE_;
  }

  /** - Indices for injection table */
  index_inj = 0;
  class_define_index(pin->index_inj_DM_ann  , pin->has_DM_ann  , index_inj, 1);
  class_define_index(pin->index_inj_DM_dec  , pin->has_DM_dec  , index_inj, 1);
  class_define_index(pin->index_inj_PBH_eva , pin->has_PBH_eva , index_inj, 1);
  class_define_index(pin->index_inj_PBH_acc , pin->has_PBH_acc , index_inj, 1);
  class_define_index(pin->index_inj_tot     , _TRUE_           , index_inj, 1);
  pin->inj_size = index_inj;

  /** - Indices for deposition (and chi) table */
  index_dep = 0;
  class_define_index(pin->index_dep_heat , _TRUE_, index_dep, 1);
  class_define_index(pin->index_dep_ionH , _TRUE_, index_dep, 1);
  class_define_index(pin->index_dep_ionHe, _TRUE_, index_dep, 1);
  class_define_index(pin->index_dep_lya  , _TRUE_, index_dep, 1);
  class_define_index(pin->index_dep_lowE , _TRUE_, index_dep, 1);
  pin->dep_size = index_dep;

  return _SUCCESS_;
}

// Assembly:
movsd 0xc0(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0xcf36c
jnp 0xcf376
movl $0x1, 0x61c(%rdi)
movsd 0x110(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jne 0xcf386
jnp 0xcf390
movl $0x1, 0x620(%rdi)
movsd 0x120(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jne 0xcf3a0
jnp 0xcf3aa
movl $0x1, 0x624(%rdi)
movsd 0x130(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jne 0xcf3ba
jnp 0xcf3c4
movl $0x1, 0x628(%rdi)
cmpl $0x0, 0x61c(%rdi)
je 0xcf3de
movl $0x0, 0x598(%rdi)
movl $0x1, %eax
jmp 0xcf3e0
xorl %eax, %eax
cmpl $0x0, 0x620(%rdi)
je 0xcf3f1
movl %eax, 0x59c(%rdi)
incl %eax
cmpl $0x0, 0x624(%rdi)
je 0xcf402
movl %eax, 0x5a0(%rdi)
incl %eax
cmpl $0x0, 0x628(%rdi)
je 0xcf413
movl %eax, 0x5a4(%rdi)
incl %eax
movl %eax, 0x5a8(%rdi)
incl %eax
movl %eax, 0x5ac(%rdi)
movaps 0x3b738(%rip), %xmm0    # 0x10ab60
movups %xmm0, 0x5f8(%rdi)
movabsq $0x500000004, %rax      # imm = 0x500000004
movq %rax, 0x608(%rdi)
xorl %eax, %eax
retq