LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/input.c
// Function: input_init
int input_init(int argc,
               char **argv,
               struct precision * ppr,
               struct background *pba,
               struct thermodynamics *pth,
               struct perturbations *ppt,
               struct transfer *ptr,
               struct primordial *ppm,
               struct harmonic *phr,
               struct fourier * pfo,
               struct lensing *ple,
               struct distortions *psd,
               struct output *pop,
               ErrorMsg errmsg){

  /** Summary: */

  /** Define local variables */
  struct file_content fc;        // Structure with all parameters

  /** Find and read input file */
  class_call(input_find_file(argc,
                             argv,
                             &fc,
                             errmsg),
             errmsg,
             errmsg);

  /** Initialize all parameters given the input 'file_content' structure.
      If its size is null, all parameters take their default values. */
  class_call(input_read_from_file(&fc,ppr,pba,pth,ppt,ptr,ppm,phr,pfo,ple,psd,pop,
                                  errmsg),
             errmsg,
             errmsg);

  /** Free local struture */
  class_call(parser_free(&fc),
             errmsg,
             errmsg);

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x830, %rsp            # imm = 0x830
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq 0x898(%rsp), %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x3164a
testl %eax, %eax
je 0x31554
leaq 0xbfed0(%rip), %rsi     # 0xf13f0
leaq 0xc4871(%rip), %rdx     # 0xf5d98
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbfaf4(%rip), %rsi     # 0xf1034
leaq 0xc487a(%rip), %rdx     # 0xf5dc1
movq %rbx, %rdi
movl $0x4b, %ecx
jmp 0x3162a
movq 0x860(%rsp), %r9
subq $0x8, %rsp
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
pushq %rbx
pushq 0x8a0(%rsp)
pushq 0x8a0(%rsp)
pushq 0x8a0(%rsp)
pushq 0x8a0(%rsp)
pushq 0x8a0(%rsp)
pushq 0x8a0(%rsp)
callq 0x31a3a
addq $0x40, %rsp
testl %eax, %eax
je 0x315e1
leaq 0xbfe40(%rip), %rsi     # 0xf13f0
leaq 0xc4815(%rip), %rdx     # 0xf5dcc
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbfa64(%rip), %rsi     # 0xf1034
leaq 0xc47ea(%rip), %rdx     # 0xf5dc1
movq %rbx, %rdi
movl $0x52, %ecx
jmp 0x3162a
leaq 0x8(%rsp), %rdi
callq 0x1e68f
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x31639
leaq 0xbfdf5(%rip), %rsi     # 0xf13f0
leaq 0xc4818(%rip), %rdx     # 0xf5e1a
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbfa19(%rip), %rsi     # 0xf1034
leaq 0xc479f(%rip), %rdx     # 0xf5dc1
movq %rbx, %rdi
movl $0x57, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x830, %rsp            # imm = 0x830
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_at_tau
int background_at_tau(
                      struct background *pba,
                      double tau,
                      enum vecback_format return_format,
                      enum interpolation_method inter_mode,
                      int * last_index,
                      double * pvecback /* vector with argument pvecback[index_bg] (must be already allocated with a size compatible with return_format) */
                      ) {

  /** Summary: */

  /** - define local variables */
  double z;

  /** - Get current redshift */
  class_call(background_z_of_tau(pba,tau,&z),
             pba->error_message,
             pba->error_message);

  /** - Get background at corresponding redshift */
  class_call(background_at_z(pba,z,return_format,inter_mode,last_index,pvecback),
             pba->error_message,
             pba->error_message);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x5ee3a
testl %eax, %eax
je 0x5edbd
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x92664(%rip), %rsi     # 0xf13f0
leaq 0xaf0ee(%rip), %rdx     # 0x10de81
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x92288(%rip), %rsi     # 0xf1034
leaq 0xaf0ee(%rip), %rdx     # 0x10dea1
movq %rbx, %rdi
movl $0xfa, %ecx
jmp 0x5ee17
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x5ea8c
testl %eax, %eax
je 0x5ee36
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x92608(%rip), %rsi     # 0xf13f0
leaq 0xaf0c4(%rip), %rdx     # 0x10deb3
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x9222c(%rip), %rsi     # 0xf1034
leaq 0xaf092(%rip), %rdx     # 0x10dea1
movq %rbx, %rdi
movl $0xff, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x5ee26
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: V_scf
double V_scf(
             struct background *pba,
             double phi) {
  /** we check first which potential should be considered */
  double result = 0.;
  if(pba->scf_potential == pol_times_exp){
    result =  V_e_scf(pba,phi)*V_p_scf(pba,phi);
  }
  else if(pba->scf_potential == double_exp){
    result = V_double_exp_scf(pba,phi);
  }
  else if(pba->scf_potential == axion){
    result = V_axion_scf(pba,phi);
  }
  else if(pba->scf_potential == phi_2n){
    result = V_phi_2n_scf(pba,phi);
  }
  else if(pba->scf_potential == axionquad){
    result = V_axionquad_scf(pba,phi);
  }
    // printf("result Vf %e\n", result);

  return result;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl 0x160(%rdi), %eax
cmpq $0x4, %rax
ja 0x60158
movapd %xmm0, %xmm2
movq %rdi, %rbx
leaq 0xadaff(%rip), %rcx     # 0x10db80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
xorpd 0x91193(%rip), %xmm0    # 0xf1230
mulsd %xmm2, %xmm0
movsd %xmm2, 0x10(%rsp)
callq 0x8670
movsd %xmm0, 0x8(%rsp)
movq 0x168(%rbx), %rax
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
subsd 0x18(%rax), %xmm0
callq 0x8620
movapd %xmm0, %xmm2
addsd 0x18(%rsp), %xmm2
jmp 0x6013f
movsd 0x188(%rbx), %xmm0
mulsd (%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x91bcb(%rip), %xmm2    # 0xf1cd0
jmp 0x6015c
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
jmp 0x687ed
movsd 0x1c0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x210(%rbx), %xmm1
addsd %xmm1, %xmm1
movapd %xmm2, %xmm0
callq 0x8620
movapd %xmm0, %xmm2
mulsd 0x8(%rsp), %xmm2
jmp 0x6015c
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
jmp 0x6859f
xorpd %xmm2, %xmm2
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_scf
double dV_scf(
              struct background *pba,
	      double phi) {
  /** we check first which potential should be considered */
  double result = 0.;
  if(pba->scf_potential == pol_times_exp){
    result =  dV_e_scf(pba,phi)*V_p_scf(pba,phi) + V_e_scf(pba,phi)*dV_p_scf(pba,phi);
  }
  else if(pba->scf_potential == double_exp){
    result =  dV_double_exp_scf(pba,phi);
  }
  else if(pba->scf_potential == axion){
    result = dV_axion_scf(pba,phi);
  }
  else if(pba->scf_potential == phi_2n){
    result = dV_phi_2n_scf(pba,phi);
  }
  else if(pba->scf_potential == axionquad){
    result = dV_axionquad_scf(pba,phi);
  }

  // printf("result dVf %e\n", result);

  return result;

}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl 0x160(%rdi), %eax
cmpq $0x4, %rax
ja 0x602d2
movapd %xmm0, %xmm2
movq %rdi, %rbx
leaq 0xada0b(%rip), %rcx     # 0x10db94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
movapd %xmm0, 0x10(%rsp)
xorpd 0x91085(%rip), %xmm0    # 0xf1230
mulsd %xmm2, %xmm0
movsd %xmm2, (%rsp)
callq 0x8670
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x168(%rbx), %rax
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
subsd 0x18(%rax), %xmm0
callq 0x8620
addsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
xorpd 0x91020(%rip), %xmm0    # 0xf1230
mulsd (%rsp), %xmm0
callq 0x8670
movsd %xmm0, 0x8(%rsp)
movq 0x168(%rbx), %rax
movsd 0x8(%rax), %xmm2
movsd %xmm2, 0x28(%rsp)
movsd (%rsp), %xmm0
subsd 0x18(%rax), %xmm0
movsd 0x915a4(%rip), %xmm1    # 0xf17e8
addsd %xmm2, %xmm1
callq 0x8620
mulsd 0x28(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
jmp 0x602d6
movsd 0x188(%rbx), %xmm0
mulsd (%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm0
jmp 0x602d6
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
jmp 0x6887a
movsd 0x1c0(%rbx), %xmm0
movsd 0x210(%rbx), %xmm1
addsd %xmm0, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
addsd %xmm1, %xmm1
addsd 0x91537(%rip), %xmm1    # 0xf17e8
movapd %xmm2, %xmm0
callq 0x8620
mulsd (%rsp), %xmm0
jmp 0x602d6
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
jmp 0x68647
xorpd %xmm0, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: ddV_scf
double ddV_scf(
               struct background *pba,
               double phi) {
  /** we check first which potential should be considered */
  double result = 0.;

  if(pba->scf_potential == pol_times_exp){
    result =  ddV_e_scf(pba,phi)*V_p_scf(pba,phi) + 2*dV_e_scf(pba,phi)*dV_p_scf(pba,phi) + V_e_scf(pba,phi)*ddV_p_scf(pba,phi);
  }

  else if(pba->scf_potential == double_exp){
    result =  ddV_double_exp_scf(pba,phi);
  }
  else if(pba->scf_potential == axion){
    result = ddV_axion_scf(pba,phi);
  }
  else if(pba->scf_potential == phi_2n){
    result = ddV_phi_2n_scf(pba,phi);
  }
  else if(pba->scf_potential == axionquad){
    result = ddV_axionquad_scf(pba,phi);
  }


  // printf("result ddVf %e\n", result);
  return result;

}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movl 0x160(%rdi), %eax
cmpq $0x4, %rax
ja 0x604f7
movapd %xmm0, %xmm2
movq %rdi, %rbx
leaq 0xad8a9(%rip), %rcx     # 0x10dba8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
xorpd 0x90f07(%rip), %xmm0    # 0xf1230
mulsd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x8670
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x168(%rbx), %rax
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rax), %xmm0
callq 0x8620
addsd 0x10(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
movapd %xmm0, 0x10(%rsp)
xorpd 0x90e9a(%rip), %xmm0    # 0xf1230
mulsd 0x8(%rsp), %xmm0
callq 0x8670
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x168(%rbx), %rax
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd %xmm1, 0x38(%rsp)
addsd 0x91412(%rip), %xmm1    # 0xf17e8
callq 0x8620
mulsd 0x38(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
xorpd 0x90e26(%rip), %xmm0    # 0xf1230
mulsd 0x8(%rsp), %xmm0
callq 0x8670
movsd %xmm0, 0x10(%rsp)
movq 0x168(%rbx), %rax
movsd 0x8(%rax), %xmm1
movsd 0x913b9(%rip), %xmm0    # 0xf17e8
addsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rax), %xmm0
addsd 0x92308(%rip), %xmm1    # 0xf2758
callq 0x8620
mulsd 0x38(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
jmp 0x604fb
movsd 0x188(%rbx), %xmm0
mulsd (%rbx), %xmm0
mulsd %xmm0, %xmm0
jmp 0x604fb
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
jmp 0x68927
movsd 0x1c0(%rbx), %xmm0
movsd 0x210(%rbx), %xmm1
ucomisd 0x90db9(%rip), %xmm1    # 0xf1260
addsd %xmm0, %xmm0
jne 0x604af
jnp 0x604fb
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm1
movsd 0x91329(%rip), %xmm3    # 0xf17e8
addsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm3, 0x8(%rsp)
addsd 0x92283(%rip), %xmm1    # 0xf2758
movapd %xmm2, %xmm0
callq 0x8620
mulsd 0x8(%rsp), %xmm0
jmp 0x604fb
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
jmp 0x6871d
xorpd %xmm0, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../include/background.h
// Function: gsl_sf_gamma
static double gsl_sf_gamma(double z) {
    /* Lanczos coefficients for g = 7 */
    static double p[] = {
        0.99999999999980993227684700473478,
        676.520368121885098567009190444019,
       -1259.13921672240287047156078755283,
        771.3234287776530788486528258894,
       -176.61502916214059906584551354,
        12.507343278686904814458936853,
       -0.13857109526572011689554707,
        9.984369578019570859563e-6,
        1.50563273514931155834e-7
    };

    // if(creal(z) < 0.5)
    //     return M_PI / (sin(M_PI*z)*gsl_sf_gamma(1. - z));

    z -= 1;
    // double complex x = p[0];
    double x = p[0];
    int n;
    for(n = 1; n < 9; n++)
        x += p[n] / (z + 1.*n);
    // double complex t = z + 7.5;
    double t = z + 7.5;
    return sqrt(2*_PI_) * pow(t, z+0.5) * exp(-t) * x;
}

// Assembly:
movapd %xmm0, %xmm1
addsd 0x8f444(%rip), %xmm1    # 0xf17e8
movsd 0xab6bc(%rip), %xmm3    # 0x10da68
movl $0x1, %eax
leaq 0xab808(%rip), %rcx     # 0x10dbc0
movsd (%rcx,%rax,8), %xmm0
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addsd %xmm0, %xmm3
incq %rax
cmpq $0x9, %rax
jne 0x623b8
subq $0x28, %rsp
movsd 0xab68b(%rip), %xmm0    # 0x10da70
addsd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
addsd 0x8f8d9(%rip), %xmm1    # 0xf1cd0
movsd %xmm3, 0x8(%rsp)
callq 0x8620
mulsd 0xab66e(%rip), %xmm0    # 0x10da78
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x8ee13(%rip), %xmm0    # 0xf1230
callq 0x8670
mulsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_free_noinput
int background_free_noinput(
                            struct background *pba
                            ) {

  free(pba->tau_table);
  free(pba->z_table);
  free(pba->loga_table);
  free(pba->d2tau_dz2_table);
  free(pba->d2z_dtau2_table);
  free(pba->background_table);
  free(pba->d2background_dloga2_table);


  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x450(%rdi), %rdi
callq 0x8410
movq 0x458(%rbx), %rdi
callq 0x8410
movq 0x448(%rbx), %rdi
callq 0x8410
movq 0x468(%rbx), %rdi
callq 0x8410
movq 0x470(%rbx), %rdi
callq 0x8410
movq 0x460(%rbx), %rdi
callq 0x8410
movq 0x478(%rbx), %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_sources
int background_sources(
                       double loga,
                       double * y,
                       double * dy,
                       int index_loga,
                       void * parameters_and_workspace,
                       ErrorMsg error_message
                       ) {

  struct background_parameters_and_workspace * pbpaw;
  struct background * pba;
  double a;
  double * bg_table_row;

  pbpaw = parameters_and_workspace;
  pba =  pbpaw->pba;

  /** - localize the row inside background_table where the current values must be stored */
  bg_table_row = pba->background_table + index_loga*pba->bg_size;

  /** - scale factor a (in fact, given our normalisation conventions, this stands for a/a_0) */
  a = exp(loga);

  /** - corresponding redhsift 1/a-1 */
  pba->z_table[index_loga] = MAX(0.,1./a-1.);

  /** - corresponding conformal time */
  pba->tau_table[index_loga] = y[pba->index_bi_tau];

  /** -> compute all other quantities depending only on a + {B} variables and get them stored
      in one row of background_table
      The value of {B} variables in pData are also copied to pvecback.*/
  class_call(background_functions(pba, a, y, long_info, bg_table_row),
             pba->error_message,
             pba->error_message);

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %r14
movq (%rcx), %rbx
movslq 0x43c(%rbx), %r15
movslq %edx, %r12
imulq %r12, %r15
shlq $0x3, %r15
addq 0x460(%rbx), %r15
callq 0x8670
movsd 0x89d26(%rip), %xmm1    # 0xf1260
divsd %xmm0, %xmm1
addsd 0x8a2a2(%rip), %xmm1    # 0xf17e8
xorpd %xmm2, %xmm2
maxsd %xmm2, %xmm1
movq 0x458(%rbx), %rax
movsd %xmm1, (%rax,%r12,8)
movslq 0x4a0(%rbx), %rax
movsd (%r14,%rax,8), %xmm1
movq 0x450(%rbx), %rax
movsd %xmm1, (%rax,%r12,8)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %r15, %rcx
callq 0x5f134
testl %eax, %eax
je 0x675d8
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x89e56(%rip), %rsi     # 0xf13f0
leaq 0xa8b74(%rip), %rdx     # 0x110115
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x89a7c(%rip), %rsi     # 0xf1034
leaq 0xa8b8f(%rip), %rdx     # 0x11014e
movq %rbx, %rdi
movl $0xd1b, %ecx            # imm = 0xD1B
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0x675da
xorl %eax, %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/background.c
// Function: dV_e_scf
double dV_e_scf(struct background *pba,
                double phi
                ) {
  double scf_lambda = pba->scf_parameters[0];
  //  double scf_alpha  = pba->scf_parameters[1];
  //  double scf_A      = pba->scf_parameters[2];
  //  double scf_B      = pba->scf_parameters[3];

  return -scf_lambda*V_e_scf(pba,phi);
}

// Assembly:
subq $0x18, %rsp
movq 0x168(%rdi), %rax
movsd (%rax), %xmm1
xorpd 0x88d72(%rip), %xmm1    # 0xf1230
movapd %xmm1, (%rsp)
mulsd %xmm1, %xmm0
callq 0x8670
mulsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: ddV_e_scf
double ddV_e_scf(struct background *pba,
                 double phi
                 ) {
  double scf_lambda = pba->scf_parameters[0];
  //  double scf_alpha  = pba->scf_parameters[1];
  //  double scf_A      = pba->scf_parameters[2];
  //  double scf_B      = pba->scf_parameters[3];

  return pow(-scf_lambda,2)*V_e_scf(pba,phi);
}

// Assembly:
subq $0x18, %rsp
movq 0x168(%rdi), %rax
movsd (%rax), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
movapd %xmm2, (%rsp)
xorpd 0x88d36(%rip), %xmm1    # 0xf1230
mulsd %xmm1, %xmm0
callq 0x8670
mulsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: V_p_scf
double V_p_scf(
               struct background *pba,
               double phi) {
  //  double scf_lambda = pba->scf_parameters[0];
  double scf_alpha  = pba->scf_parameters[1];
  double scf_A      = pba->scf_parameters[2];
  double scf_B      = pba->scf_parameters[3];

  return  pow(phi - scf_B,  scf_alpha) +  scf_A;
}

// Assembly:
pushq %rax
movq 0x168(%rdi), %rax
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd %xmm2, (%rsp)
subsd 0x18(%rax), %xmm0
callq 0x8620
addsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_p_scf
double dV_p_scf(
                struct background *pba,
                double phi) {

  //  double scf_lambda = pba->scf_parameters[0];
  double scf_alpha  = pba->scf_parameters[1];
  //  double scf_A      = pba->scf_parameters[2];
  double scf_B      = pba->scf_parameters[3];

  return   scf_alpha*pow(phi -  scf_B,  scf_alpha - 1);
}

// Assembly:
pushq %rax
movq 0x168(%rdi), %rax
movsd 0x8(%rax), %xmm2
movsd %xmm2, (%rsp)
subsd 0x18(%rax), %xmm0
movsd 0x89294(%rip), %xmm1    # 0xf17e8
addsd %xmm2, %xmm1
callq 0x8620
mulsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: V_axion_scf
double V_axion_scf(
                  struct background *pba,
                  double phi){
    // int n = pba->scf_parameters[0];
    double n = pba->n_axion;
    // double fa = pba->scf_parameters[2];
    double fa = pba->f_axion;
    double m = pba->m_scf*pba->H0;
    double result;
    // printf("n %d fa %e V %e phi/fa %e \n",n,fa,m*m/pow(2,n),phi/fa);
    if(n>1)result = pow(m,2)*pow(fa,2)*pow(1 - cos(phi/fa),n);
    else result = pow(m,2)*pow(fa,2)*(1 - cos(phi/fa));
    // printf("result %e phi %e m^2 %e\n",result,phi,m*m);
    return result;

}

// Assembly:
subq $0x28, %rsp
movsd 0x210(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x190(%rdi), %xmm2
movsd (%rdi), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x188(%rdi), %xmm1
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
divsd %xmm2, %xmm0
callq 0x86a0
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x88a20(%rip), %xmm0    # 0xf1260
ucomisd %xmm0, %xmm1
subsd %xmm2, %xmm0
jbe 0x6884f
callq 0x8620
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm2
movsd 0x20(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_axion_scf
double dV_axion_scf(
                  struct background *pba,
                  double phi){
    // int n = pba->scf_parameters[0];
    double n = pba->n_axion;
    // double fa = pba->scf_parameters[2];
    double fa = pba->f_axion;
    double m = pba->m_scf*pba->H0;
    double result;
    if(n>1)result = n*pow(m,2)*fa*pow(1-cos(phi/fa),n-1)*sin(phi/fa);
    else result = pow(m,2)*fa*sin(phi/fa);

    return result;

}

// Assembly:
subq $0x18, %rsp
movapd %xmm0, %xmm1
movsd 0x210(%rdi), %xmm3
movsd 0x188(%rdi), %xmm2
movsd 0x190(%rdi), %xmm0
mulsd (%rdi), %xmm2
ucomisd 0x889ba(%rip), %xmm3    # 0xf1260
mulsd %xmm2, %xmm2
jbe 0x68907
mulsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x86a0
movsd 0x88986(%rip), %xmm2    # 0xf1260
subsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
addsd 0x88efc(%rip), %xmm1    # 0xf17e8
movapd %xmm2, %xmm0
callq 0x8620
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x68914
mulsd %xmm0, %xmm2
divsd %xmm0, %xmm1
movsd %xmm2, (%rsp)
movapd %xmm1, %xmm0
callq 0x80a0
mulsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: ddV_axion_scf
double ddV_axion_scf(
                  struct background *pba,
                  double phi){

     // int n = pba->scf_parameters[0];
     double n = pba->n_axion;
     // double fa = pba->scf_parameters[2];
     double fa = pba->f_axion;
     double m = pba->m_scf*pba->H0;
     double result;
     if(n==1) result = n*pow(m,2)*cos(phi/fa);
     else if (n==2) result =  n*pow(m,2)*(pow(sin(phi/fa),2)+(1-cos(phi/fa))*cos(phi/fa));
     else result = n*pow(m,2)*fa*((n-1)/fa*pow(1-cos(phi/fa),n-2)*pow(sin(phi/fa),2)+pow(1-cos(phi/fa),n-1)/fa*cos(phi/fa)); //this formula bugs sometimes for n=1

     return result;
}

// Assembly:
subq $0x38, %rsp
movsd 0x210(%rdi), %xmm3
movsd 0x188(%rdi), %xmm1
mulsd (%rdi), %xmm1
movsd 0x190(%rdi), %xmm2
ucomisd 0x88911(%rip), %xmm3    # 0xf1260
jne 0x68975
jp 0x68975
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rsp)
divsd %xmm2, %xmm0
callq 0x86a0
mulsd 0x8(%rsp), %xmm0
jmp 0x68ab4
ucomisd 0x89383(%rip), %xmm3    # 0xf1d00
mulsd %xmm1, %xmm1
mulsd %xmm3, %xmm1
jne 0x689ca
jp 0x689ca
divsd %xmm2, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x80a0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x86a0
movsd 0x888a5(%rip), %xmm1    # 0xf1260
subsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
jmp 0x68a87
mulsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x88e0c(%rip), %xmm1    # 0xf17e8
addsd %xmm3, %xmm1
movsd %xmm1, 0x20(%rsp)
divsd %xmm2, %xmm1
movsd %xmm1, 0x28(%rsp)
divsd %xmm2, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd %xmm2, 0x30(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x86a0
movsd 0x8884d(%rip), %xmm2    # 0xf1260
subsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
addsd 0x89d33(%rip), %xmm1    # 0xf2758
movapd %xmm2, %xmm0
callq 0x8620
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x80a0
mulsd %xmm0, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x86a0
movsd 0x887f8(%rip), %xmm1    # 0xf1260
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x8620
divsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x86a0
mulsd 0x20(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_phi_2n_scf
double dV_phi_2n_scf(
                  struct background *pba,
                  double phi){
    // int n = pba->scf_parameters[0];
    double n = pba->n_axion;
    double result;

    result = pba->V0_phi2n*2*n*pow((phi),2*n-1);

    return result;

}

// Assembly:
pushq %rax
movsd 0x1c0(%rdi), %xmm2
movsd 0x210(%rdi), %xmm1
addsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
addsd %xmm1, %xmm1
addsd 0x88cdf(%rip), %xmm1    # 0xf17e8
callq 0x8620
mulsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: ddV_phi_2n_scf
double ddV_phi_2n_scf(
                  struct background *pba,
                  double phi){

     // int n = pba->scf_parameters[0];
     double n = pba->n_axion;
     double result;
     if(n==1) result=pba->V0_phi2n*2;
     else result = pba->V0_phi2n*2*n*(2*n-1)*pow((phi),2*n-2);
     return result;
}

// Assembly:
movapd %xmm0, %xmm2
movsd 0x1c0(%rdi), %xmm0
movsd 0x210(%rdi), %xmm1
ucomisd 0x8872f(%rip), %xmm1    # 0xf1260
addsd %xmm0, %xmm0
jne 0x68b3a
jp 0x68b3a
retq
pushq %rax
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm1
movsd 0x88c9d(%rip), %xmm3    # 0xf17e8
addsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm3, (%rsp)
addsd 0x89bf8(%rip), %xmm1    # 0xf2758
movapd %xmm2, %xmm0
callq 0x8620
mulsd (%rsp), %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/thermodynamics.c
// Function: thermodynamics_checks
int thermodynamics_checks(
                          struct precision * ppr,
                          struct background* pba,
                          struct thermodynamics * pth
                          ) {

  /** Summary: */

  /** - check BBN Y_He fracion */
  class_test((pth->YHe < _YHE_SMALL_)||(pth->YHe > _YHE_BIG_),
             pth->error_message,
             "Y_He=%g out of bounds (%g<Y_He<%g)",pth->YHe,_YHE_SMALL_,_YHE_BIG_);

  /** - tests in order to prevent divisions by zero */
  class_test(pth->YHe == 1.,
             pth->error_message,
             "stop to avoid division by zero");

  /** - test initial condition for recombination */
  class_test(ppr->thermo_z_initial < ppr->recfast_z_He_3,
             pth->error_message,
             "increase z_initial in order to start before HeliumIII recombination");

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdx, %rbx
movsd (%rdx), %xmm0
movsd 0x8940a(%rip), %xmm1    # 0xf3fb0
ucomisd %xmm0, %xmm1
ja 0x6ac20
ucomisd 0x8711c(%rip), %xmm0    # 0xf1cd0
ja 0x6ac20
ucomisd 0x866a2(%rip), %xmm0    # 0xf1260
jne 0x6aca0
jp 0x6aca0
leaq 0x8815c(%rip), %rsi     # 0xf2d2d
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x86498(%rip), %rsi     # 0xf1082
leaq 0xa6982(%rip), %rdx     # 0x111573
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x86425(%rip), %rsi     # 0xf1034
leaq 0xa6947(%rip), %rdx     # 0x11155d
movq %rbx, %rdi
movl $0x2f4, %ecx            # imm = 0x2F4
jmp 0x6ac84
leaq 0xa68e2(%rip), %rsi     # 0x111509
leaq 0x800(%rsp), %r14
movsd 0x89379(%rip), %xmm1    # 0xf3fb0
movsd 0x87091(%rip), %xmm2    # 0xf1cd0
movq %r14, %rdi
movb $0x3, %al
callq 0x30c2c
leaq 0x86432(%rip), %rsi     # 0xf1082
leaq 0xa68d5(%rip), %rdx     # 0x11152c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x863bf(%rip), %rsi     # 0xf1034
leaq 0xa68e1(%rip), %rdx     # 0x11155d
movq %rbx, %rdi
movl $0x2ef, %ecx            # imm = 0x2EF
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
movsd 0x278(%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x190(%rdi), %xmm0
jbe 0x6ac93
leaq 0xa68c7(%rip), %rsi     # 0x111582
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x863ae(%rip), %rsi     # 0xf1082
leaq 0xa68eb(%rip), %rdx     # 0x1115c6
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x8633b(%rip), %rsi     # 0xf1034
leaq 0xa685d(%rip), %rdx     # 0x11155d
movq %rbx, %rdi
movl $0x2f9, %ecx            # imm = 0x2F9
jmp 0x6ac84
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/thermodynamics.c
// Function: thermodynamics_workspace_free
int thermodynamics_workspace_free(
                                  struct thermodynamics* pth,
                                  struct thermo_workspace * ptw
                                  ) {

  free(ptw->ptdw->ap_z_limits);
  free(ptw->ptdw->ap_z_limits_delta);

  switch (pth->recombination) {

  case hyrec:
    class_call(thermodynamics_hyrec_free(ptw->ptdw->phyrec),
               ptw->ptdw->phyrec->error_message,
               pth->error_message);
    free(ptw->ptdw->phyrec);
    break;

  case recfast:
    free(ptw->ptdw->precfast);
    break;
  }

  free(ptw->ptrp->reionization_parameters);
  free(ptw->ptdw);
  free(ptw->ptrp);

  free(ptw);

  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rsi), %rax
movq 0xa0(%rax), %rdi
callq 0x8410
movq 0x80(%rbx), %rax
movq 0xa8(%rax), %rdi
callq 0x8410
movl 0x10(%r14), %eax
testl %eax, %eax
je 0x6dbd0
cmpl $0x1, %eax
jne 0x6dbe5
movq 0x80(%rbx), %rax
movq 0xc0(%rax), %rdi
callq 0xdfb95
movl $0xc0, %ecx
cmpl $0x1, %eax
jne 0x6dbd5
movq 0x80(%rbx), %rax
movq 0xc0(%rax), %rcx
addq $0x20, %rcx
leaq 0x83862(%rip), %rsi     # 0xf13f0
leaq 0xa4e00(%rip), %rdx     # 0x112995
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x1064, %r14           # imm = 0x1064
leaq 0x83484(%rip), %rsi     # 0xf1034
leaq 0xa4e0b(%rip), %rdx     # 0x1129c2
movq %r14, %rdi
movl $0x75f, %ecx            # imm = 0x75F
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0x6dc17
movl $0xc8, %ecx
movq 0x80(%rbx), %rax
movq (%rax,%rcx), %rdi
callq 0x8410
movq 0x88(%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x8410
movq 0x80(%rbx), %rdi
callq 0x8410
movq 0x88(%rbx), %rdi
callq 0x8410
movq %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/thermodynamics.c
// Function: thermodynamics_free
int thermodynamics_free(
                        struct thermodynamics * pth
                        ) {

  if (pth->has_exotic_injection == _TRUE_) {
    /* Free all injection-related functions */
    class_call(injection_free(pth),
               (pth->in).error_message,
               pth->error_message);
  }

  /* Free thermodynamics-related functions */
  free(pth->z_table);
  free(pth->tau_table);
  free(pth->thermodynamics_table);
  free(pth->d2thermodynamics_dz2_table);

  class_call(thermodynamics_free_input(pth),
             pth->error_message,
             pth->error_message);

  pth->is_allocated = _FALSE_;

  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
cmpw $0x1, 0xb8(%rdi)
jne 0x6dc96
movq %rbx, %rdi
callq 0xd3ff7
cmpl $0x1, %eax
jne 0x6dc96
leaq 0x630(%rbx), %rcx
leaq 0x8379c(%rip), %rsi     # 0xf13f0
leaq 0xa3092(%rip), %rdx     # 0x110ced
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x833be(%rip), %rsi     # 0xf1034
leaq 0xa3084(%rip), %rdx     # 0x110d01
movq %rbx, %rdi
movl $0x1c1, %ecx            # imm = 0x1C1
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0x6dcd9
movq 0xf10(%rbx), %rdi
callq 0x8410
movq 0xf18(%rbx), %rdi
callq 0x8410
movq 0xf20(%rbx), %rdi
callq 0x8410
movq 0xf28(%rbx), %rdi
callq 0x8410
movq %rbx, %rdi
callq 0x6dce4
movw $0x0, 0x1864(%rbx)
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/thermodynamics.c
// Function: thermodynamics_timescale
int thermodynamics_timescale(
                             double mz,
                             void * thermo_parameters_and_workspace,
                             double * timescale,
                             ErrorMsg error_message
                             ) {

  int index_z;
  struct thermodynamics_parameters_and_workspace * ptpaw;

  ptpaw = thermo_parameters_and_workspace;

  /* We could evaluate the timescale automatically, e.g, as [x / (dx/dz)]. */

  /* But for simplicity, we assume that the array of values of z to
     sample (pth->z_table) has been chosen in such way that the
     quantities vary only by a small amount over each step. Thus we
     define our step as delta(-z) = ((-z_i+1) - (-z_i)) = (z_i -
     z_i+1) */

  /* find index_z such that pth->z_table[index_z] > z > pth->z_table[index_z+1] */
  class_call(array_hunt_ascending(ptpaw->pth->z_table,
                                  ptpaw->pth->tt_size,
                                  -mz,
                                  &index_z,
                                  error_message),
             error_message,
             error_message);

  *timescale = ptpaw->pth->z_table[index_z+1] - ptpaw->pth->z_table[index_z];

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
movq 0xf10(%rax), %rdi
movl 0xf08(%rax), %esi
xorpd 0x8149e(%rip), %xmm0    # 0xf1230
leaq 0xc(%rsp), %rdx
movq %rbx, %rcx
callq 0x1b8ef
cmpl $0x1, %eax
jne 0x6fdeb
leaq 0x81645(%rip), %rsi     # 0xf13f0
leaq 0xa34c1(%rip), %rdx     # 0x113273
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x81269(%rip), %rsi     # 0xf1034
leaq 0xa34fe(%rip), %rdx     # 0x1132d0
movq %rbx, %rdi
movl $0xb29, %ecx            # imm = 0xB29
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
jmp 0x6fe0d
movq 0x10(%r15), %rax
movq 0xf10(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%r14)
xorl %eax, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/thermodynamics.c
// Function: thermodynamics_vector_free
int thermodynamics_vector_free(
                               struct thermo_vector * tv
                               ) {

  free(tv->y);
  free(tv->dy);
  free(tv->used_in_output);
  free(tv);

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movq 0x28(%rbx), %rdi
callq 0x8410
movq %rbx, %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/perturbations.c
// Function: perturbations_sources_at_z
int perturbations_sources_at_z(
                               struct background * pba,
                               struct perturbations * ppt,
                               int index_md,
                               int index_ic,
                               int index_tp,
                               double z,
                               double * psource_at_z
                               ) {

  double tau;

  class_call(background_tau_of_z(pba,
                                 z,
                                 &tau),
             pba->error_message,
             ppt->error_message);

  class_call(perturbations_sources_at_tau(ppt,index_md,index_ic,index_tp,tau,psource_at_z),
             ppt->error_message,
             ppt->error_message);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rsi
callq 0x5efb7
cmpl $0x1, %eax
jne 0x744c5
addq $0xd1c, %r15            # imm = 0xD1C
leaq 0x7cf63(%rip), %rsi     # 0xf13f0
leaq 0xa095b(%rip), %rdx     # 0x114def
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x6c8a, %rbx           # imm = 0x6C8A
leaq 0x7cb80(%rip), %rsi     # 0xf1034
leaq 0xa1912(%rip), %rdx     # 0x115dcd
movq %rbx, %rdi
movl $0x99, %ecx
jmp 0x7451f
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %ebp, %ecx
movq %r14, %r8
callq 0x742a8
testl %eax, %eax
je 0x74540
addq $0x6c8a, %rbx           # imm = 0x6C8A
leaq 0x7cf00(%rip), %rsi     # 0xf13f0
leaq 0xa18f1(%rip), %rdx     # 0x115de8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x7cb24(%rip), %rsi     # 0xf1034
leaq 0xa18b6(%rip), %rdx     # 0x115dcd
movq %rbx, %rdi
movl $0x9d, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x7452e
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/perturbations.c
// Function: perturbations_output_firstline_and_ic_suffix
int perturbations_output_firstline_and_ic_suffix(
                                                 struct perturbations *ppt,
                                                 int index_ic,
                                                 char first_line[_LINE_LENGTH_MAX_],
                                                 char ic_suffix[_SUFFIXNAMESIZE_]
                                                 ){

  first_line[0]='\0';
  ic_suffix[0]='\0';

  if ((ppt->has_ad == _TRUE_) && (index_ic == ppt->index_ic_ad)) {
    strcpy(ic_suffix,"ad");
    strcpy(first_line,"for adiabatic (AD) mode (normalized to initial curvature=1) ");
  }

  if ((ppt->has_bi == _TRUE_) && (index_ic == ppt->index_ic_bi)) {
    strcpy(ic_suffix,"bi");
    strcpy(first_line,"for baryon isocurvature (BI) mode (normalized to initial entropy=1)");
  }

  if ((ppt->has_cdi == _TRUE_) && (index_ic == ppt->index_ic_cdi)) {
    strcpy(ic_suffix,"cdi");
    strcpy(first_line,"for CDM isocurvature (CDI) mode (normalized to initial entropy=1)");
  }

  if ((ppt->has_nid == _TRUE_) && (index_ic == ppt->index_ic_nid)) {
    strcpy(ic_suffix,"nid");
    strcpy(first_line,"for neutrino density isocurvature (NID) mode (normalized to initial entropy=1)");
  }

  if ((ppt->has_niv == _TRUE_) && (index_ic == ppt->index_ic_niv)) {
    strcpy(ic_suffix,"niv");
    strcpy(first_line,"for neutrino velocity isocurvature (NIV) mode (normalized to initial entropy=1)");
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movb %al, (%rdx)
movb %al, (%rcx)
cmpw $0x1, 0x14(%rdi)
jne 0x75e7b
cmpl %ebp, 0x858(%r15)
jne 0x75e7b
movb $0x0, 0x2(%r14)
movw $0x6461, (%r14)         # imm = 0x6461
movups 0xa040e(%rip), %xmm0    # 0x116265
movups %xmm0, 0x2d(%rbx)
movups 0xa03f6(%rip), %xmm0    # 0x116258
movups %xmm0, 0x20(%rbx)
movups 0xa03db(%rip), %xmm0    # 0x116248
movups %xmm0, 0x10(%rbx)
movups 0xa03c0(%rip), %xmm0    # 0x116238
movups %xmm0, (%rbx)
cmpw $0x1, 0x16(%r15)
jne 0x75eab
cmpl %ebp, 0x860(%r15)
jne 0x75eab
movb $0x0, 0x2(%r14)
movw $0x6962, (%r14)         # imm = 0x6962
leaq 0xa03d7(%rip), %rsi     # 0x116275
movl $0x44, %edx
movq %rbx, %rdi
callq 0x82d0
cmpw $0x1, 0x18(%r15)
jne 0x75ed7
cmpl %ebp, 0x85c(%r15)
jne 0x75ed7
movl $0x696463, (%r14)       # imm = 0x696463
leaq 0xa03ef(%rip), %rsi     # 0x1162b9
movl $0x42, %edx
movq %rbx, %rdi
callq 0x82d0
cmpw $0x1, 0x1a(%r15)
jne 0x75f03
cmpl %ebp, 0x864(%r15)
jne 0x75f03
movl $0x64696e, (%r14)       # imm = 0x64696E
leaq 0xa0405(%rip), %rsi     # 0x1162fb
movl $0x4f, %edx
movq %rbx, %rdi
callq 0x82d0
cmpw $0x1, 0x1c(%r15)
jne 0x75f2f
cmpl %ebp, 0x868(%r15)
jne 0x75f2f
movl $0x76696e, (%r14)       # imm = 0x76696E
leaq 0xa0428(%rip), %rsi     # 0x11634a
movl $0x50, %edx
movq %rbx, %rdi
callq 0x82d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/perturbations.c
// Function: perturbations_free_input
int perturbations_free_input(struct perturbations* ppt) {

  if (ppt->alpha_idm_dr != NULL)
    free(ppt->alpha_idm_dr);
  if (ppt->beta_idr != NULL)
    free(ppt->beta_idr);

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x820(%rdi), %rdi
testq %rdi, %rdi
je 0x7a39d
callq 0x8410
movq 0x828(%rbx), %rdi
testq %rdi, %rdi
je 0x7a3ae
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/perturbations.c
// Function: perturbations_workspace_free
int perturbations_workspace_free (
                                  struct perturbations * ppt,
                                  int index_md,
                                  struct perturbations_workspace * ppw
                                  ) {

  free(ppw->s_l);
  free(ppw->pvecback);
  free(ppw->pvecthermo);
  free(ppw->pvecmetric);
  if (ppw->ap_size > 0)
    free(ppw->approx);

  if (_scalars_) {

    if ((ppt->has_density_transfers == _TRUE_) || (ppt->has_velocity_transfers == _TRUE_) || (ppt->has_source_delta_m == _TRUE_)) {
      free(ppw->delta_ncdm);
      free(ppw->theta_ncdm);
      free(ppw->shear_ncdm);
    }
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x190(%rdx), %rdi
callq 0x8410
movq 0x30(%rbx), %rdi
callq 0x8410
movq 0x38(%rbx), %rdi
callq 0x8410
movq 0x40(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x178(%rbx)
jle 0x7cef8
movq 0x180(%rbx), %rdi
callq 0x8410
cmpw $0x1, 0xe(%r14)
jne 0x7cf48
cmpl %ebp, 0x848(%r14)
jne 0x7cf48
cmpw $0x1, 0x34(%r14)
je 0x7cf24
cmpw $0x1, 0x36(%r14)
je 0x7cf24
cmpw $0x1, 0x87c(%r14)
jne 0x7cf48
movq 0xe8(%rbx), %rdi
callq 0x8410
movq 0xf0(%rbx), %rdi
callq 0x8410
movq 0xf8(%rbx), %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/perturbations.c
// Function: perturbations_vector_free
int perturbations_vector_free(
                              struct perturbations_vector * pv
                              ) {

  if (pv->l_max_ncdm != NULL) free(pv->l_max_ncdm);
  if (pv->q_size_ncdm != NULL) free(pv->q_size_ncdm);
  free(pv->y);
  free(pv->dy);
  free(pv->used_in_sources);
  free(pv);

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0x8d670
callq 0x8410
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x8d681
callq 0x8410
movq 0xf0(%rbx), %rdi
callq 0x8410
movq 0xf8(%rbx), %rdi
callq 0x8410
movq 0x100(%rbx), %rdi
callq 0x8410
movq %rbx, %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_analytic_spectrum
int primordial_analytic_spectrum(
                                 struct primordial * ppm,
                                 int index_md,
                                 int index_ic1_ic2,
                                 double k,
                                 double * pk
                                 ) {


  if (ppm->is_non_zero[index_md][index_ic1_ic2] == _TRUE_) {
    // printf("in primordial_spec_init %d %d\n",ppm->is_primordial_Pk_different,ppm->calling_from_pk);
    if(ppm->is_primordial_Pk_different == _TRUE_ && ppm->calling_from_pk == _TRUE_){
      *pk = ppm->A_s_pk
        *exp((ppm->ns_pk-1.)*log(k/ppm->k_pivot)
             + 0.5 * ppm->running_pk * pow(log(k/ppm->k_pivot), 2.));
    }else{
    *pk = ppm->amplitude[index_md][index_ic1_ic2]
      *exp((ppm->tilt[index_md][index_ic1_ic2]-1.)*log(k/ppm->k_pivot)
           + 0.5 * ppm->running[index_md][index_ic1_ic2] * pow(log(k/ppm->k_pivot), 2.));
    }
  }
  else {
    *pk = 0.;
  }

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movapd %xmm0, %xmm1
movq 0x2b0(%rdi), %rax
movslq %esi, %r15
movq (%rax,%r15,8), %rax
movslq %edx, %r12
xorpd %xmm0, %xmm0
cmpw $0x1, (%rax,%r12,2)
jne 0x979c0
movq %rdi, %r14
cmpw $0x1, 0xb2a(%rdi)
movsd %xmm1, 0x18(%rsp)
jne 0x97920
cmpw $0x1, 0xb2c(%r14)
jne 0x97920
movsd 0xb38(%r14), %xmm0
addsd 0x59efc(%rip), %xmm0    # 0xf17e8
movsd %xmm0, 0x8(%rsp)
movsd 0xb30(%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm1, %xmm0
divsd (%r14), %xmm0
callq 0x82c0
movsd %xmm0, 0x10(%rsp)
movsd 0xb40(%r14), %xmm0
jmp 0x9797b
movq 0x2b8(%r14), %rax
movq 0x2c0(%r14), %rcx
movq (%rax,%r15,8), %rax
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,8), %xmm0
addsd 0x59ea4(%rip), %xmm0    # 0xf17e8
movsd %xmm0, 0x8(%rsp)
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm1, %xmm0
divsd (%r14), %xmm0
callq 0x82c0
movsd %xmm0, 0x10(%rsp)
movq 0x2c8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
mulsd 0x5a34d(%rip), %xmm0    # 0xf1cd0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
divsd (%r14), %xmm0
callq 0x82c0
mulsd %xmm0, %xmm0
mulsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x8670
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq