LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5c726
testl %eax, %eax
je 0x5c6a9
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x91d78(%rip), %rsi     # 0xee3f0
leaq 0xae822(%rip), %rdx     # 0x10aea1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x9199c(%rip), %rsi     # 0xee034
leaq 0xae822(%rip), %rdx     # 0x10aec1
movq %rbx, %rdi
movl $0xfa, %ecx
jmp 0x5c703
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x5c3a8
testl %eax, %eax
je 0x5c722
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x91d1c(%rip), %rsi     # 0xee3f0
leaq 0xae7f8(%rip), %rdx     # 0x10aed3
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x91940(%rip), %rsi     # 0xee034
leaq 0xae7c6(%rip), %rdx     # 0x10aec1
movq %rbx, %rdi
movl $0xff, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x5c712
// File: /workspace/github_c_makefile_star2_O3/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 0x5da9f
movapd %xmm0, %xmm2
movq %rdi, %rbx
leaq 0xad24e(%rip), %rcx     # 0x10aba0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
xorpd 0x908c2(%rip), %xmm0    # 0xee230
mulsd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x8670
movsd %xmm0, (%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
movapd %xmm0, %xmm2
addsd 0x10(%rsp), %xmm2
jmp 0x5da87
movsd 0x188(%rbx), %xmm0
mulsd (%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x912f8(%rip), %xmm2    # 0xeecd0
jmp 0x5daa3
movsd 0x210(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x190(%rbx), %xmm1
movsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x188(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd %xmm1, 0x10(%rsp)
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
callq 0x86a0
movsd 0x18(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x90831(%rip), %xmm0    # 0xee260
ucomisd %xmm0, %xmm1
subsd %xmm2, %xmm0
jbe 0x5da3e
callq 0x8620
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
movsd (%rsp), %xmm2
mulsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
jmp 0x5daa3
movsd 0x1c0(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x210(%rbx), %xmm1
addsd %xmm1, %xmm1
movapd %xmm2, %xmm0
callq 0x8620
movapd %xmm0, %xmm2
mulsd (%rsp), %xmm2
jmp 0x5daa3
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
jmp 0x65c90
xorpd %xmm2, %xmm2
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5dc19
movapd %xmm0, %xmm2
movq %rdi, %rbx
leaq 0xad0e4(%rip), %rcx     # 0x10abb4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x168(%rbx), %rax
movsd (%rax), %xmm0
movapd %xmm0, 0x10(%rsp)
xorpd 0x9073e(%rip), %xmm0    # 0xee230
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 0x906d9(%rip), %xmm0    # 0xee230
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 0x90c5d(%rip), %xmm1    # 0xee7e8
addsd %xmm2, %xmm1
callq 0x8620
mulsd 0x28(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
jmp 0x5dc1d
movsd 0x188(%rbx), %xmm0
mulsd (%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm0
jmp 0x5dc1d
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
jmp 0x65f6b
movsd 0x1c0(%rbx), %xmm0
movsd 0x210(%rbx), %xmm1
addsd %xmm0, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
addsd %xmm1, %xmm1
addsd 0x90bf0(%rip), %xmm1    # 0xee7e8
movapd %xmm2, %xmm0
callq 0x8620
mulsd (%rsp), %xmm0
jmp 0x5dc1d
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
jmp 0x65d38
xorpd %xmm0, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5de3e
movapd %xmm0, %xmm2
movq %rdi, %rbx
leaq 0xacf82(%rip), %rcx     # 0x10abc8
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 0x905c0(%rip), %xmm0    # 0xee230
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 0x90553(%rip), %xmm0    # 0xee230
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 0x90acb(%rip), %xmm1    # 0xee7e8
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 0x904df(%rip), %xmm0    # 0xee230
mulsd 0x8(%rsp), %xmm0
callq 0x8670
movsd %xmm0, 0x10(%rsp)
movq 0x168(%rbx), %rax
movsd 0x8(%rax), %xmm1
movsd 0x90a72(%rip), %xmm0    # 0xee7e8
addsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rax), %xmm0
addsd 0x919c9(%rip), %xmm1    # 0xef760
callq 0x8620
mulsd 0x38(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
jmp 0x5de42
movsd 0x188(%rbx), %xmm0
mulsd (%rbx), %xmm0
mulsd %xmm0, %xmm0
jmp 0x5de42
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
jmp 0x66018
movsd 0x1c0(%rbx), %xmm0
movsd 0x210(%rbx), %xmm1
ucomisd 0x90472(%rip), %xmm1    # 0xee260
addsd %xmm0, %xmm0
jne 0x5ddf6
jnp 0x5de42
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm1
movsd 0x909e2(%rip), %xmm3    # 0xee7e8
addsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm3, 0x8(%rsp)
addsd 0x91944(%rip), %xmm1    # 0xef760
movapd %xmm2, %xmm0
callq 0x8620
mulsd 0x8(%rsp), %xmm0
jmp 0x5de42
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
jmp 0x65e0e
xorpd %xmm0, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8eb54(%rip), %xmm1    # 0xee7e8
movsd 0xaadf4(%rip), %xmm3    # 0x10aa90
movl $0x1, %eax
leaq 0xaaf38(%rip), %rcx     # 0x10abe0
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 0x5fca8
subq $0x28, %rsp
movsd 0xaadc3(%rip), %xmm0    # 0x10aa98
addsd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
addsd 0x8efe9(%rip), %xmm1    # 0xeecd0
movsd %xmm3, 0x8(%rsp)
callq 0x8620
mulsd 0xaada6(%rip), %xmm0    # 0x10aaa0
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x8e523(%rip), %xmm0    # 0xee230
callq 0x8670
mulsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x895cd(%rip), %xmm1    # 0xee260
divsd %xmm0, %xmm1
addsd 0x89b49(%rip), %xmm1    # 0xee7e8
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 0x5ca06
testl %eax, %eax
je 0x64d31
addq $0xd1c, %rbx            # imm = 0xD1C
leaq 0x896fd(%rip), %rsi     # 0xee3f0
leaq 0xa843b(%rip), %rdx     # 0x10d135
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x89323(%rip), %rsi     # 0xee034
leaq 0xa8456(%rip), %rdx     # 0x10d16e
movq %rbx, %rdi
movl $0xd1b, %ecx            # imm = 0xD1B
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0x64d33
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/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 0x88681(%rip), %xmm1    # 0xee230
movapd %xmm1, (%rsp)
mulsd %xmm1, %xmm0
callq 0x8670
mulsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x88645(%rip), %xmm1    # 0xee230
mulsd %xmm1, %xmm0
callq 0x8670
mulsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x88ba3(%rip), %xmm1    # 0xee7e8
addsd %xmm2, %xmm1
callq 0x8620
mulsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8832f(%rip), %xmm0    # 0xee260
ucomisd %xmm0, %xmm1
subsd %xmm2, %xmm0
jbe 0x65f40
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_O3/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 0x882c9(%rip), %xmm3    # 0xee260
mulsd %xmm2, %xmm2
jbe 0x65ff8
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 0x88295(%rip), %xmm2    # 0xee260
subsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
addsd 0x8880b(%rip), %xmm1    # 0xee7e8
movapd %xmm2, %xmm0
callq 0x8620
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x66005
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_O3/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 0x88220(%rip), %xmm3    # 0xee260
jne 0x6605c
jp 0x6605c
mulsd %xmm1, %xmm1
movsd %xmm1, 0x20(%rsp)
divsd %xmm2, %xmm0
callq 0x86a0
jmp 0x661a0
ucomisd 0x88c9c(%rip), %xmm3    # 0xeed00
mulsd %xmm1, %xmm1
jne 0x660c8
jp 0x660c8
addsd %xmm1, %xmm1
movsd %xmm1, 0x20(%rsp)
divsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x80a0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x86a0
movsd 0x881be(%rip), %xmm1    # 0xee260
subsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x86a0
mulsd 0x28(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
jmp 0x661a0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
movsd %xmm1, 0x20(%rsp)
movsd 0x8870a(%rip), %xmm1    # 0xee7e8
addsd %xmm3, %xmm1
movsd %xmm1, 0x18(%rsp)
divsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsp)
divsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, 0x28(%rsp)
movsd %xmm3, 0x30(%rsp)
callq 0x86a0
movsd 0x8814b(%rip), %xmm2    # 0xee260
subsd %xmm0, %xmm2
movsd 0x30(%rsp), %xmm1
addsd 0x89639(%rip), %xmm1    # 0xef760
movapd %xmm2, %xmm0
callq 0x8620
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x80a0
mulsd %xmm0, %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x86a0
movsd 0x880f6(%rip), %xmm1    # 0xee260
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8620
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x86a0
mulsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x885ed(%rip), %xmm1    # 0xee7e8
callq 0x8620
mulsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8803d(%rip), %xmm1    # 0xee260
addsd %xmm0, %xmm0
jne 0x6622c
jp 0x6622c
retq
pushq %rax
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm1
movsd 0x885ab(%rip), %xmm3    # 0xee7e8
addsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm3, (%rsp)
addsd 0x8950e(%rip), %xmm1    # 0xef760
movapd %xmm2, %xmm0
callq 0x8620
mulsd (%rsp), %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x88d5d(%rip), %xmm1    # 0xf0fc0
ucomisd %xmm0, %xmm1
ja 0x682dd
ucomisd 0x86a5f(%rip), %xmm0    # 0xeecd0
ja 0x682dd
ucomisd 0x85fe5(%rip), %xmm0    # 0xee260
jne 0x6835d
jp 0x6835d
leaq 0x87aaf(%rip), %rsi     # 0xefd3d
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x85ddb(%rip), %rsi     # 0xee082
leaq 0xa6315(%rip), %rdx     # 0x10e5c3
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x85d68(%rip), %rsi     # 0xee034
leaq 0xa62da(%rip), %rdx     # 0x10e5ad
movq %rbx, %rdi
movl $0x2f4, %ecx            # imm = 0x2F4
jmp 0x68341
leaq 0xa6275(%rip), %rsi     # 0x10e559
leaq 0x800(%rsp), %r14
movsd 0x88ccc(%rip), %xmm1    # 0xf0fc0
movsd 0x869d4(%rip), %xmm2    # 0xeecd0
movq %r14, %rdi
movb $0x3, %al
callq 0x30af0
leaq 0x85d75(%rip), %rsi     # 0xee082
leaq 0xa6268(%rip), %rdx     # 0x10e57c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x85d02(%rip), %rsi     # 0xee034
leaq 0xa6274(%rip), %rdx     # 0x10e5ad
movq %rbx, %rdi
movl $0x2ef, %ecx            # imm = 0x2EF
movq %r15, %r8
xorl %eax, %eax
callq 0x30af0
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 0x68350
leaq 0xa625a(%rip), %rsi     # 0x10e5d2
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x85cf1(%rip), %rsi     # 0xee082
leaq 0xa627e(%rip), %rdx     # 0x10e616
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x85c7e(%rip), %rsi     # 0xee034
leaq 0xa61f0(%rip), %rdx     # 0x10e5ad
movq %rbx, %rdi
movl $0x2f9, %ecx            # imm = 0x2F9
jmp 0x68341
// File: /workspace/github_c_makefile_star2_O3/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 0x6b268
cmpl $0x1, %eax
jne 0x6b27d
movq 0x80(%rbx), %rax
movq 0xc0(%rax), %rdi
callq 0xdc64a
movl $0xc0, %ecx
cmpl $0x1, %eax
jne 0x6b26d
movq 0x80(%rbx), %rax
movq 0xc0(%rax), %rcx
addq $0x20, %rcx
leaq 0x831ca(%rip), %rsi     # 0xee3f0
leaq 0xa47b8(%rip), %rdx     # 0x10f9e5
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x1064, %r14           # imm = 0x1064
leaq 0x82dec(%rip), %rsi     # 0xee034
leaq 0xa47c3(%rip), %rdx     # 0x10fa12
movq %r14, %rdi
movl $0x75f, %ecx            # imm = 0x75F
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0x6b2af
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_O3/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 0x6b32e
movq %rbx, %rdi
callq 0xd07d5
cmpl $0x1, %eax
jne 0x6b32e
leaq 0x630(%rbx), %rcx
leaq 0x83104(%rip), %rsi     # 0xee3f0
leaq 0xa2a4a(%rip), %rdx     # 0x10dd3d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x82d26(%rip), %rsi     # 0xee034
leaq 0xa2a3c(%rip), %rdx     # 0x10dd51
movq %rbx, %rdi
movl $0x1c1, %ecx            # imm = 0x1C1
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0x6b371
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 0x6b37c
movw $0x0, 0x1864(%rbx)
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/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 0x80f37(%rip), %xmm0    # 0xee230
leaq 0xc(%rsp), %rdx
movq %rbx, %rcx
callq 0x1b9ac
cmpl $0x1, %eax
jne 0x6d352
leaq 0x810de(%rip), %rsi     # 0xee3f0
leaq 0xa2faa(%rip), %rdx     # 0x1102c3
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x80d02(%rip), %rsi     # 0xee034
leaq 0xa2fe7(%rip), %rdx     # 0x110320
movq %rbx, %rdi
movl $0xb29, %ecx            # imm = 0xB29
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
jmp 0x6d374
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_O3/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 0x5c896
cmpl $0x1, %eax
jne 0x71a01
addq $0xd1c, %r15            # imm = 0xD1C
leaq 0x7ca27(%rip), %rsi     # 0xee3f0
leaq 0xa046f(%rip), %rdx     # 0x111e3f
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x6c8a, %rbx           # imm = 0x6C8A
leaq 0x7c644(%rip), %rsi     # 0xee034
leaq 0xa1416(%rip), %rdx     # 0x112e0d
movq %rbx, %rdi
movl $0x99, %ecx
jmp 0x71a5b
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %ebp, %ecx
movq %r14, %r8
callq 0x717e4
testl %eax, %eax
je 0x71a7c
addq $0x6c8a, %rbx           # imm = 0x6C8A
leaq 0x7c9c4(%rip), %rsi     # 0xee3f0
leaq 0xa13f5(%rip), %rdx     # 0x112e28
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x7c5e8(%rip), %rsi     # 0xee034
leaq 0xa13ba(%rip), %rdx     # 0x112e0d
movq %rbx, %rdi
movl $0x9d, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
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 0x71a6a
// File: /workspace/github_c_makefile_star2_O3/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 0x7339f
cmpl %ebp, 0x858(%r15)
jne 0x7339f
movb $0x0, 0x2(%r14)
movw $0x6461, (%r14)         # imm = 0x6461
movups 0x9ff2a(%rip), %xmm0    # 0x1132a5
movups %xmm0, 0x2d(%rbx)
movups 0x9ff12(%rip), %xmm0    # 0x113298
movups %xmm0, 0x20(%rbx)
movups 0x9fef7(%rip), %xmm0    # 0x113288
movups %xmm0, 0x10(%rbx)
movups 0x9fedc(%rip), %xmm0    # 0x113278
movups %xmm0, (%rbx)
cmpw $0x1, 0x16(%r15)
jne 0x733cf
cmpl %ebp, 0x860(%r15)
jne 0x733cf
movb $0x0, 0x2(%r14)
movw $0x6962, (%r14)         # imm = 0x6962
leaq 0x9fef3(%rip), %rsi     # 0x1132b5
movl $0x44, %edx
movq %rbx, %rdi
callq 0x82d0
cmpw $0x1, 0x18(%r15)
jne 0x733fb
cmpl %ebp, 0x85c(%r15)
jne 0x733fb
movl $0x696463, (%r14)       # imm = 0x696463
leaq 0x9ff0b(%rip), %rsi     # 0x1132f9
movl $0x42, %edx
movq %rbx, %rdi
callq 0x82d0
cmpw $0x1, 0x1a(%r15)
jne 0x73427
cmpl %ebp, 0x864(%r15)
jne 0x73427
movl $0x64696e, (%r14)       # imm = 0x64696E
leaq 0x9ff21(%rip), %rsi     # 0x11333b
movl $0x4f, %edx
movq %rbx, %rdi
callq 0x82d0
cmpw $0x1, 0x1c(%r15)
jne 0x73453
cmpl %ebp, 0x868(%r15)
jne 0x73453
movl $0x76696e, (%r14)       # imm = 0x76696E
leaq 0x9ff44(%rip), %rsi     # 0x11338a
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_O3/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 0x778e6
callq 0x8410
movq 0x828(%rbx), %rdi
testq %rdi, %rdi
je 0x778f7
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a356
movq 0x180(%rbx), %rdi
callq 0x8410
cmpw $0x1, 0xe(%r14)
jne 0x7a3a6
cmpl %ebp, 0x848(%r14)
jne 0x7a3a6
cmpw $0x1, 0x34(%r14)
je 0x7a382
cmpw $0x1, 0x36(%r14)
je 0x7a382
cmpw $0x1, 0x87c(%r14)
jne 0x7a3a6
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_O3/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 0x8aae0
callq 0x8410
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x8aaf1
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_O3/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 0x94c0e
movq %rdi, %r14
cmpw $0x1, 0xb2a(%rdi)
movsd %xmm1, 0x18(%rsp)
jne 0x94b6e
cmpw $0x1, 0xb2c(%r14)
jne 0x94b6e
movsd 0xb38(%r14), %xmm0
addsd 0x59cae(%rip), %xmm0    # 0xee7e8
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 0x94bc9
movq 0x2b8(%r14), %rax
movq 0x2c0(%r14), %rcx
movq (%rax,%r15,8), %rax
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,8), %xmm0
addsd 0x59c56(%rip), %xmm0    # 0xee7e8
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 0x5a0ff(%rip), %xmm0    # 0xeecd0
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
// File: /workspace/github_c_makefile_star2_O3/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 0x95ccb
ucomisd %xmm1, %xmm0
jae 0x95ccb
movsd %xmm0, 0x8(%rsp)
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd %xmm2, (%rsp)
callq 0x82c0
divsd 0x7c849(%rip), %xmm0    # 0x112488
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %r15d
leal 0x2(%r15), %ebp
movl %ebp, 0x290(%rbx)
movslq %r15d, %rax
leaq 0x10(,%rax,8), %rdi
callq 0x8460
movq %rax, 0x298(%rbx)
testq %rax, %rax
je 0x95d26
xorl %r14d, %r14d
cmpl $-0x1, %r15d
jl 0x95d75
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd 0x8(%rsp), %xmm0
callq 0x82c0
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
mulsd 0x7c7e7(%rip), %xmm1    # 0x112488
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 0x95c86
jmp 0x95d75
leaq 0x8353f(%rip), %rsi     # 0x119211
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x5839a(%rip), %rsi     # 0xee082
leaq 0x8354a(%rip), %rdx     # 0x119239
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x58322(%rip), %rsi     # 0xee034
leaq 0x8353f(%rip), %rdx     # 0x119258
movq %rbx, %rdi
movl $0x2ca, %ecx            # imm = 0x2CA
movq %r15, %r8
jmp 0x95d68
shll $0x3, %ebp
leaq 0x582d4(%rip), %rsi     # 0xee004
leaq 0x83539(%rip), %rdx     # 0x119270
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x582de(%rip), %rsi     # 0xee034
leaq 0x834fb(%rip), %rdx     # 0x119258
movq %rbx, %rdi
movl $0x2ce, %ecx            # imm = 0x2CE
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %r14d
movl %r14d, %eax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x96d42
movl 0x18(%rbx), %eax
cmpl $0x5, %eax
je 0x96ca1
testl %eax, %eax
jne 0x96caf
cmpl $0x0, 0x278(%rbx)
jle 0x96c82
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 0x96c43
movq 0x2b8(%rbx), %rdi
callq 0x8410
movq 0x2c0(%rbx), %rdi
callq 0x8410
movl $0x2c8, %eax            # imm = 0x2C8
jmp 0x96ca6
movl $0x220, %eax            # imm = 0x220
movq (%rbx,%rax), %rdi
callq 0x8410
cmpl $0x0, 0x278(%rbx)
jle 0x96cfa
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 0x96cbb
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