LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_get_lnk_list
int primordial_get_lnk_list(
                            struct primordial * ppm,
                            double kmin,
                            double kmax,
                            double k_per_decade
                            ) {

  int i;

  class_test((kmin <= 0.) || (kmax <= kmin),
             ppm->error_message,
             "inconsistent values of kmin=%e, kmax=%e",kmin,kmax);

  ppm->lnk_size = (int)(log(kmax/kmin)/log(10.)*k_per_decade) + 2;

  class_alloc(ppm->lnk,ppm->lnk_size*sizeof(double),ppm->error_message);

  for (i=0; i<ppm->lnk_size; i++)
    ppm->lnk[i]=log(kmin)+i*log(10.)/k_per_decade;

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, %rbx
xorpd %xmm3, %xmm3
ucomisd %xmm0, %xmm3
jae 0x98ac3
ucomisd %xmm1, %xmm0
jae 0x98ac3
movsd %xmm0, 0x8(%rsp)
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd %xmm2, (%rsp)
callq 0x82c0
divsd 0x7ca0e(%rip), %xmm0    # 0x115448
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %eax
leal 0x2(%rax), %ebp
movl %ebp, 0x290(%rbx)
cltq
leaq 0x10(,%rax,8), %rdi
callq 0x8460
movq %rax, 0x298(%rbx)
testq %rax, %rax
je 0x98b1e
cmpl $0x0, 0x290(%rbx)
jle 0x98b7e
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd 0x8(%rsp), %xmm0
callq 0x82c0
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
mulsd 0x7c9af(%rip), %xmm1    # 0x115448
divsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x298(%rbx), %rax
movsd %xmm1, (%rax,%r15,8)
incq %r15
movslq 0x290(%rbx), %rax
cmpq %rax, %r15
jl 0x98a7e
jmp 0x98b6d
leaq 0x83707(%rip), %rsi     # 0x11c1d1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30c2c
leaq 0x585a2(%rip), %rsi     # 0xf1082
leaq 0x83712(%rip), %rdx     # 0x11c1f9
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x5852a(%rip), %rsi     # 0xf1034
leaq 0x83707(%rip), %rdx     # 0x11c218
movq %rbx, %rdi
movl $0x2ca, %ecx            # imm = 0x2CA
movq %r15, %r8
jmp 0x98b60
shll $0x3, %ebp
leaq 0x584dc(%rip), %rsi     # 0xf1004
leaq 0x83701(%rip), %rdx     # 0x11c230
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x584e6(%rip), %rsi     # 0xf1034
leaq 0x836c3(%rip), %rdx     # 0x11c218
movq %rbx, %rdi
movl $0x2ce, %ecx            # imm = 0x2CE
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %r14d
movl %r14d, %eax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x98b6d
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_free
int primordial_free(
                    struct primordial * ppm
                    ) {

  int index_md;

  if (ppm->lnk_size > 0) {

    if (ppm->primordial_spec_type == analytic_Pk) {
      for (index_md = 0; index_md < ppm->md_size; index_md++) {
        free(ppm->amplitude[index_md]);
        free(ppm->tilt[index_md]);
        free(ppm->running[index_md]);
      }
      free(ppm->amplitude);
      free(ppm->tilt);
      free(ppm->running);
    }
    else if (ppm->primordial_spec_type == external_Pk) {
      free(ppm->command);
    }

    for (index_md = 0; index_md < ppm->md_size; index_md++) {
      free(ppm->lnpk[index_md]);
      free(ppm->ddlnpk[index_md]);
      free(ppm->is_non_zero[index_md]);
    }

    free(ppm->lnpk);
    free(ppm->ddlnpk);
    free(ppm->is_non_zero);
    free(ppm->ic_size);
    free(ppm->ic_ic_size);

    free(ppm->lnk);

  }

  ppm->is_allocated = _FALSE_;

  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x290(%rdi)
jle 0x99b45
movl 0x18(%rbx), %eax
cmpl $0x5, %eax
je 0x99aa4
testl %eax, %eax
jne 0x99ab2
cmpl $0x0, 0x278(%rbx)
jle 0x99a85
xorl %r14d, %r14d
movq 0x2b8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0x2c0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0x2c8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0x278(%rbx), %rax
cmpq %rax, %r14
jl 0x99a46
movq 0x2b8(%rbx), %rdi
callq 0x8410
movq 0x2c0(%rbx), %rdi
callq 0x8410
movl $0x2c8, %eax            # imm = 0x2C8
jmp 0x99aa9
movl $0x220, %eax            # imm = 0x220
movq (%rbx,%rax), %rdi
callq 0x8410
cmpl $0x0, 0x278(%rbx)
jle 0x99afd
xorl %r14d, %r14d
movq 0x2a0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0x2a8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
movq 0x2b0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0x278(%rbx), %rax
cmpq %rax, %r14
jl 0x99abe
movq 0x2a0(%rbx), %rdi
callq 0x8410
movq 0x2a8(%rbx), %rdi
callq 0x8410
movq 0x2b0(%rbx), %rdi
callq 0x8410
movq 0x280(%rbx), %rdi
callq 0x8410
movq 0x288(%rbx), %rdi
callq 0x8410
movq 0x298(%rbx), %rdi
callq 0x8410
movw $0x0, 0xb48(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5646c(%rip), %xmm2    # 0xf1cd0
movsd %xmm2, 0x18(%rsp)
movq %rsi, %r13
movsd 0x1e8(%rdi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rsp)
movsd 0x56df5(%rip), %xmm1    # 0xf2680
callq 0x8620
divsd 0x56dd8(%rip), %xmm0    # 0xf2670
mulsd 0x1f0(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x58b73(%rip), %xmm1    # 0xf4428
movsd 0x10(%rsp), %xmm0
callq 0x8620
divsd 0x56e28(%rip), %xmm0    # 0xf26f0
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 0x56d66(%rip), %xmm1    # 0xf2680
callq 0x8620
divsd 0x56d49(%rip), %xmm0    # 0xf2670
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_O1/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 0x9b821
movsd (%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9ce8f
leaq 0x8067f(%rip), %rsi     # 0x11d4bf
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0x54229(%rip), %rsi     # 0xf1082
leaq 0x80683(%rip), %rdx     # 0x11d4e3
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x541b6(%rip), %rsi     # 0xf1034
leaq 0x80618(%rip), %rdx     # 0x11d49d
movq %rbx, %rdi
movl $0x99f, %ecx            # imm = 0x99F
jmp 0x9cef0
movsd (%r14), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jbe 0x9ceff
leaq 0x80648(%rip), %rsi     # 0x11d4eb
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0x541c6(%rip), %rsi     # 0xf1082
leaq 0x80665(%rip), %rdx     # 0x11d528
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x54153(%rip), %rsi     # 0xf1034
leaq 0x805b5(%rip), %rdx     # 0x11d49d
movq %rbx, %rdi
movl $0x9a4, %ecx            # imm = 0x9A4
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9b20b
testl %eax, %eax
je 0x9e2a3
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x53184(%rip), %rsi     # 0xf13f0
leaq 0x7f0c8(%rip), %rdx     # 0x11d33b
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x52da8(%rip), %rsi     # 0xf1034
leaq 0x7f0d9(%rip), %rdx     # 0x11d36c
movq %rbx, %rdi
movl $0x96d, %ecx            # imm = 0x96D
movq %r14, %r8
jmp 0x9e376
movsd 0x8(%rsp), %xmm0
xorpd %xmm2, %xmm2
ucomisd (%r15), %xmm2
jae 0x9e31d
movsd (%r14), %xmm1
xorl %eax, %eax
ucomisd %xmm2, %xmm1
jb 0x9e382
leaq 0x7f144(%rip), %rsi     # 0x11d410
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30c2c
leaq 0x52da0(%rip), %rsi     # 0xf1082
leaq 0x7f1aa(%rip), %rdx     # 0x11d493
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x52d28(%rip), %rsi     # 0xf1034
leaq 0x7f059(%rip), %rdx     # 0x11d36c
movq %rbx, %rdi
movl $0x977, %ecx            # imm = 0x977
jmp 0x9e373
leaq 0x7f06d(%rip), %rsi     # 0x11d391
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0x52d48(%rip), %rsi     # 0xf1082
leaq 0x7f0c6(%rip), %rdx     # 0x11d407
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x52cd0(%rip), %rsi     # 0xf1034
leaq 0x7f001(%rip), %rdx     # 0x11d36c
movq %rbx, %rdi
movl $0x972, %ecx            # imm = 0x972
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9f5d3
cmpl $0x3, %edx
je 0x9f638
cmpl $0x2, %edx
jne 0x9f674
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x9b20b
testl %eax, %eax
je 0x9f6d4
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x51df2(%rip), %rsi     # 0xf13f0
leaq 0x7df2c(%rip), %rdx     # 0x11d531
leaq 0x810(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x51a13(%rip), %rsi     # 0xf1034
leaq 0x7df3f(%rip), %rdx     # 0x11d567
movq %rbx, %rdi
movl $0x9c5, %ecx            # imm = 0x9C5
movq %r14, %r8
jmp 0x9f6c6
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 0x9b821
movsd (%r12), %xmm0
divsd (%r15), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x7bdce(%rip), %xmm0    # 0x11b440
jmp 0x9f6eb
leaq 0x7cea0(%rip), %rsi     # 0x11c51b
leaq 0x810(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x51ef1(%rip), %rsi     # 0xf1585
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30c2c
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x51980(%rip), %rsi     # 0xf1034
leaq 0x7deac(%rip), %rdx     # 0x11d567
movq %rbx, %rdi
movl $0x9d7, %ecx            # imm = 0x9D7
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0x9f6f2
movsd (%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x7bddd(%rip), %xmm0    # 0x11b4c8
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_O1/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_output_titles
int primordial_output_titles(struct perturbations * ppt,
                             struct primordial * ppm,
                             char titles[_MAXTITLESTRINGLENGTH_]
                             ){
  class_store_columntitle(titles,"k [1/Mpc]",_TRUE_);
  class_store_columntitle(titles,"P_scalar(k)",_TRUE_);
  class_store_columntitle(titles,"P_tensor(k)",ppt->has_tensors);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x8180
movabsq $0x63704d2f315b206b, %rcx # imm = 0x63704D2F315B206B
movq %rcx, (%rbx,%rax)
movw $0x5d, 0x8(%rbx,%rax)
movq %rbx, %rdi
callq 0x8180
movw $0x9, %bp
movw %bp, (%rbx,%rax)
movq %rbx, %rdi
callq 0x8180
movabsq $0x72616c6163735f50, %rcx # imm = 0x72616C6163735F50
movq %rcx, (%rbx,%rax)
movl $0x296b28, 0x8(%rbx,%rax) # imm = 0x296B28
movq %rbx, %rdi
callq 0x8180
movw %bp, (%rbx,%rax)
cmpw $0x1, 0x12(%r14)
jne 0x9f796
movq %rbx, %rdi
callq 0x8180
movabsq $0x726f736e65745f50, %rcx # imm = 0x726F736E65745F50
movq %rcx, (%rbx,%rax)
movl $0x296b28, 0x8(%rbx,%rax) # imm = 0x296B28
movq %rbx, %rdi
callq 0x8180
movw $0x9, (%rbx,%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9f847
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 0x9f82c
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 0x9f7ca
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe75fc
cmpl $0x1, %eax
jne 0xa5fba
addq $0x192, %rbx            # imm = 0x192
leaq 0x4b476(%rip), %rsi     # 0xf13f0
leaq 0x7af07(%rip), %rdx     # 0x120e88
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4b09a(%rip), %rsi     # 0xf1034
leaq 0x7af09(%rip), %rdx     # 0x120eaa
movq %rbx, %rdi
movl $0xa44, %ecx            # imm = 0xA44
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebp
jmp 0xa6038
movl 0x90(%rbx), %esi
xorl %ebp, %ebp
cmpl $0x2, %esi
jl 0xa6038
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 0x14191
cmpl $0x1, %eax
jne 0xa6038
leaq 0x4b3ec(%rip), %rsi     # 0xf13f0
leaq 0x7aeb1(%rip), %rdx     # 0x120ebc
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4b010(%rip), %rsi     # 0xf1034
leaq 0x7ae7f(%rip), %rdx     # 0x120eaa
movq %rbx, %rdi
movl $0xa50, %ecx            # imm = 0xA50
jmp 0xa5fa9
movl %ebp, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa66cc
leaq (,%r15,8), %rdi
callq 0x8460
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0xa676c
movq 0xa58(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0xa66ba
xorl %r15d, %r15d
cmpl $0x0, (%rbx)
je 0xa67bb
movslq 0x9f8(%r14), %r12
movl %r12d, 0x140(%rbx)
leaq (,%r12,8), %rdi
callq 0x8460
movq %rax, 0x148(%rbx)
testq %rax, %rax
je 0xa672b
testl %r12d, %r12d
jle 0xa67bb
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 0xa6714
jmp 0xa67bb
shll $0x3, %r12d
leaq 0x4a8ce(%rip), %rsi     # 0xf1004
leaq 0x7a42f(%rip), %rdx     # 0x120b6c
movq %rsp, %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4a8d9(%rip), %rsi     # 0xf1034
leaq 0x7a3f5(%rip), %rdx     # 0x120b57
movq %rbx, %rdi
movl $0x8b8, %ecx            # imm = 0x8B8
jmp 0xa67ab
shll $0x3, %r15d
leaq 0x4a88d(%rip), %rsi     # 0xf1004
leaq 0x7a3cd(%rip), %rdx     # 0x120b4b
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x192, %rbx            # imm = 0x192
leaq 0x4a898(%rip), %rsi     # 0xf1034
leaq 0x7a3b4(%rip), %rdx     # 0x120b57
movq %rbx, %rdi
movl $0x8ac, %ecx            # imm = 0x8AC
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 %rdx, 0x18(%rsp)
xorl %eax, %eax
movl %eax, 0x14(%rsp)
movl %eax, (%r8)
cmpl %eax, 0x8a4(%rcx)
jle 0xa8b3e
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
movq 0x8f0(%rbx), %rax
cmpl $0x0, (%rax,%rbp,4)
jle 0xa8adf
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 0xad2d2
testl %eax, %eax
jne 0xa8af2
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 0xa8a8e
incq %rbp
movslq 0x8a4(%rbx), %rax
cmpq %rax, %rbp
jl 0xa8a7e
xorl %eax, %eax
jmp 0xa8b3e
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x488f0(%rip), %rsi     # 0xf13f0
leaq 0x7965e(%rip), %rdx     # 0x122165
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x48514(%rip), %rsi     # 0xf1034
leaq 0x7969c(%rip), %rdx     # 0x1221c3
movq %rbx, %rdi
movl $0x66a, %ecx            # imm = 0x66A
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0xab1b9
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq 0x870(%r15), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0xab1a1
xorl %ebp, %ebp
movq 0x998(%r15), %rax
movl (%rax,%r12,4), %eax
testl %eax, %eax
jle 0xab192
xorl %r13d, %r13d
movq (%rbx,%r12,8), %rcx
imull %ebp, %eax
cltq
addq %r13, %rax
movq (%rcx,%rax,8), %rdi
callq 0x8410
movq 0x998(%r15), %rax
movl (%rax,%r12,4), %eax
incq %r13
cmpl %eax, %r13d
jl 0xab16a
incl %ebp
movq 0x870(%r15), %rax
cmpl (%rax,%r12,4), %ebp
jl 0xab158
movq (%rbx,%r12,8), %rdi
callq 0x8410
incq %r12
movslq 0x8a4(%r14), %rax
cmpq %rax, %r12
jl 0xab148
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_O1/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 0xab3af
movq %rdi, %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x8410
incq %r15
movslq 0x8a4(%r14), %rax
cmpq %rax, %r15
jl 0xab397
movq %rbx, %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xab531
cmpl $0x0, 0x8a4(%rbx)
jle 0xab449
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 0xab43a
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 0xab3e0
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 0xab4cb
movq 0x948(%rbx), %rdi
callq 0x8410
movq 0x950(%rbx), %rdi
callq 0x8410
movq 0x960(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x75c(%rbx)
jle 0xab4f8
movq 0x760(%rbx), %rdi
callq 0x8410
movq 0x768(%rbx), %rdi
callq 0x8410
movq 0x770(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x87c(%rbx)
jle 0xab531
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_O1/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 0x70d1b(%rip), %xmm0    # 0x121310
movsd %xmm0, 0x8(%rsp)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x439a8(%rip), %xmm1    # 0xf3fb8
callq 0x8620
xorpd 0x40c13(%rip), %xmm0    # 0xf1230
callq 0x8670
mulsd (%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
movsd 0x4397e(%rip), %xmm1    # 0xf3fb8
callq 0x8620
mulsd 0x43971(%rip), %xmm0    # 0xf3fb8
movsd 0x416b1(%rip), %xmm1    # 0xf1d00
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_O1/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 0xb3c7a
movq %rdi, %r14
addq $0x96a, %r14            # imm = 0x96A
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2343c
cmpl $0x1, %eax
jne 0xb3c7a
leaq 0x3d7b4(%rip), %rsi     # 0xf13f0
leaq 0x6fcd2(%rip), %rdx     # 0x123915
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x3d3da(%rip), %rsi     # 0xf1034
leaq 0x6fcec(%rip), %rdx     # 0x12394d
movq %r14, %rdi
movl $0x11c1, %ecx           # imm = 0x11C1
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0xb3cd0
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_O1/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 0xb7a52
cmpl $0x0, 0x9c(%rbx)
jle 0xb7a15
cmpl $0x0, 0x10(%rbx)
jle 0xb79cd
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 0xb7991
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 0xb7a37
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0xb7a1e
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_O1/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 0xb9c54
leaq 0x6e7bf(%rip), %rsi     # 0x1283bf
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x30c2c
leaq 0x37467(%rip), %rsi     # 0xf1082
leaq 0x6e835(%rip), %rdx     # 0x128457
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x92, %rbx
leaq 0x373f4(%rip), %rsi     # 0xf1034
leaq 0x6e826(%rip), %rdx     # 0x12846d
movq %rbx, %rdi
movl $0x32, %ecx
movq %r15, %r8
jmp 0xb9cd1
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 0x17ee6
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0xb9cdf
leaq 0x37754(%rip), %rsi     # 0xf13f0
leaq 0x6e7da(%rip), %rdx     # 0x12847d
leaq 0x800(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x37375(%rip), %rsi     # 0xf1034
leaq 0x6e7a7(%rip), %rdx     # 0x12846d
movq %r15, %rdi
movl $0x3f, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0xb9d05
movslq 0x54(%rbx), %rax
testq %rax, %rax
jle 0xb9d03
movq 0x68(%rbx), %rcx
xorl %edx, %edx
cmpl %ebp, (%rcx,%rdx,4)
jge 0xb9cfb
movq $0x0, (%r14,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xb9cee
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc27a9
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 0xc2785
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
jle 0xc2bbb
movq 0x70(%rdi), %rcx
movslq 0x54(%rdi), %rdx
movslq 0x34(%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 0xc2b97
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc3007
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 0xc2fd0
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ae1e(%rip), %xmm0    # 0xf5c10
movq %rdx, %r12
movapd %xmm0, %xmm1
divsd 0x5dfdf(%rip), %xmm1    # 0x128de0
movq %rdi, %r14
divsd 0x2ae4c(%rip), %xmm1    # 0xf5c58
movsd %xmm1, 0x380(%rcx)
movsd 0x27864(%rip), %xmm1    # 0xf2680
callq 0x8620
addsd %xmm0, %xmm0
divsd 0x5dfbb(%rip), %xmm0    # 0x128de8
movsd %xmm0, 0x388(%rbx)
movabsq $0x40e86a0000000000, %rax # imm = 0x40E86A0000000000
movq %rax, 0x310(%rbx)
movsd (%r12), %xmm0
mulsd 0x29614(%rip), %xmm0    # 0xf4468
addsd 0x26404(%rip), %xmm0    # 0xf1260
divsd 0x5df8c(%rip), %xmm0    # 0x128df0
movsd 0x5df8c(%rip), %xmm1    # 0x128df8
callq 0x8620
mulsd 0x5df87(%rip), %xmm0    # 0x128e00
movsd %xmm0, (%rsp)
movsd 0x8(%r15), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x20(%r15), %xmm0
divsd 0x5df72(%rip), %xmm0    # 0x128e08
movsd 0x5df5a(%rip), %xmm1    # 0x128df8
callq 0x8620
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%r15), %xmm0
divsd 0x5df55(%rip), %xmm0    # 0x128e10
movsd 0x263d5(%rip), %xmm1    # 0xf1298
callq 0x8620
mulsd (%rsp), %xmm0
movsd %xmm0, 0x318(%rbx)
addq $0x928, %r14            # imm = 0x928
leaq 0x5e1f6(%rip), %r15     # 0x1290d9
leaq 0x5e1f5(%rip), %r12     # 0x1290df
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 0x5e1d4(%rip), %r12     # 0x1290f5
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_O1/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 0xcd803
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 0xcd755
movq 0xcc8(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0xbf0(%rbx)
jle 0xcd780
xorl %r14d, %r14d
movq 0xbc0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8410
incq %r14
movslq 0xbf0(%rbx), %rax
cmpq %rax, %r14
jl 0xcd761
movq 0xbc0(%rbx), %rdi
callq 0x8410
movq 0xc00(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0xbf0(%rbx)
jle 0xcd7d3
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 0xcd7a4
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_O1/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 0x8410
movq 0xc28(%rbx), %rdi
callq 0x8410
movq 0xc30(%rbx), %rdi
callq 0x8410
movq 0xc38(%rbx), %rdi
callq 0x8410
movq 0xc40(%rbx), %rdi
callq 0x8410
movq 0xc48(%rbx), %rdi
callq 0x8410
movq 0xc50(%rbx), %rdi
callq 0x8410
movq 0xc58(%rbx), %rdi
callq 0x8410
movq 0xc60(%rbx), %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq