LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x8430
movq 0x80(%rbx), %rax
movq 0xa8(%rax), %rdi
callq 0x8430
movl 0x10(%r14), %eax
testl %eax, %eax
je 0x66e7a
cmpl $0x1, %eax
jne 0x66e8f
movq 0x80(%rbx), %rax
movq 0xc0(%rax), %rdi
callq 0xd45f1
movl $0xc0, %ecx
cmpl $0x1, %eax
jne 0x66e7f
movq 0x80(%rbx), %rax
movq 0xc0(%rax), %rcx
addq $0x20, %rcx
leaq 0x7e5b6(%rip), %rsi     # 0xe53f0
leaq 0x9fa44(%rip), %rdx     # 0x106885
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0x1064, %r14           # imm = 0x1064
leaq 0x7e1d8(%rip), %rsi     # 0xe5034
leaq 0x9fa4f(%rip), %rdx     # 0x1068b2
movq %r14, %rdi
movl $0x75f, %ecx            # imm = 0x75F
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0x66ec1
movl $0xc8, %ecx
movq 0x80(%rbx), %rax
movq (%rax,%rcx), %rdi
callq 0x8430
movq 0x88(%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x8430
movq 0x80(%rbx), %rdi
callq 0x8430
movq 0x88(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/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 0x66f3e
movq %rbx, %rdi
callq 0xc9018
cmpl $0x1, %eax
jne 0x66f3e
leaq 0x630(%rbx), %rcx
leaq 0x7e4f2(%rip), %rsi     # 0xe53f0
leaq 0x9dcd8(%rip), %rdx     # 0x104bdd
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0x1064, %rbx           # imm = 0x1064
leaq 0x7e114(%rip), %rsi     # 0xe5034
leaq 0x9dcca(%rip), %rdx     # 0x104bf1
movq %rbx, %rdi
movl $0x1c1, %ecx            # imm = 0x1C1
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0x66f80
movq 0xf10(%rbx), %rdi
callq 0x8430
movq 0xf18(%rbx), %rdi
callq 0x8430
movq 0xf20(%rbx), %rdi
callq 0x8430
movq 0xf28(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x66f8b
andw $0x0, 0x1864(%rbx)
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/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 0x7c456(%rip), %xmm0    # 0xe5230
leaq 0xc(%rsp), %rdx
movq %rbx, %rcx
callq 0x196f6
cmpl $0x1, %eax
jne 0x68e31
leaq 0x7c5fd(%rip), %rsi     # 0xe53f0
leaq 0x9e369(%rip), %rdx     # 0x107163
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x7c221(%rip), %rsi     # 0xe5034
leaq 0x9e3a6(%rip), %rdx     # 0x1071c0
movq %rbx, %rdi
movl $0xb29, %ecx            # imm = 0xB29
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0x68e53
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_O2/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 0x8430
movq 0x20(%rbx), %rdi
callq 0x8430
movq 0x28(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x58adb
cmpl $0x1, %eax
jne 0x6d3bc
addq $0xd1c, %r15            # imm = 0xD1C
leaq 0x7806c(%rip), %rsi     # 0xe53f0
leaq 0x9b954(%rip), %rdx     # 0x108cdf
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x6c8a, %rbx           # imm = 0x6C8A
leaq 0x77c89(%rip), %rsi     # 0xe5034
leaq 0x9c8fb(%rip), %rdx     # 0x109cad
movq %rbx, %rdi
movl $0x99, %ecx
jmp 0x6d416
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %ebp, %ecx
movq %r14, %r8
callq 0x6d194
testl %eax, %eax
je 0x6d435
addq $0x6c8a, %rbx           # imm = 0x6C8A
leaq 0x78009(%rip), %rsi     # 0xe53f0
leaq 0x9c8da(%rip), %rdx     # 0x109cc8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x77c2d(%rip), %rsi     # 0xe5034
leaq 0x9c89f(%rip), %rdx     # 0x109cad
movq %rbx, %rdi
movl $0x9d, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x6d423
// File: /workspace/github_c_makefile_star2_O2/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 0x6ed33
cmpl %ebp, 0x858(%r15)
jne 0x6ed33
movb $0x0, 0x2(%r14)
movw $0x6461, (%r14)         # imm = 0x6461
movups 0x9b436(%rip), %xmm0    # 0x10a145
movups %xmm0, 0x2d(%rbx)
movups 0x9b41e(%rip), %xmm0    # 0x10a138
movups %xmm0, 0x20(%rbx)
movups 0x9b403(%rip), %xmm0    # 0x10a128
movups %xmm0, 0x10(%rbx)
movups 0x9b3e8(%rip), %xmm0    # 0x10a118
movups %xmm0, (%rbx)
cmpw $0x1, 0x16(%r15)
jne 0x6ed61
cmpl %ebp, 0x860(%r15)
jne 0x6ed61
movb $0x0, 0x2(%r14)
movw $0x6962, (%r14)         # imm = 0x6962
leaq 0x9b3ff(%rip), %rsi     # 0x10a155
pushq $0x44
popq %rdx
movq %rbx, %rdi
callq 0x82f0
cmpw $0x1, 0x18(%r15)
jne 0x6ed8b
cmpl %ebp, 0x85c(%r15)
jne 0x6ed8b
movl $0x696463, (%r14)       # imm = 0x696463
leaq 0x9b419(%rip), %rsi     # 0x10a199
pushq $0x42
popq %rdx
movq %rbx, %rdi
callq 0x82f0
cmpw $0x1, 0x1a(%r15)
jne 0x6edb5
cmpl %ebp, 0x864(%r15)
jne 0x6edb5
movl $0x64696e, (%r14)       # imm = 0x64696E
leaq 0x9b431(%rip), %rsi     # 0x10a1db
pushq $0x4f
popq %rdx
movq %rbx, %rdi
callq 0x82f0
cmpw $0x1, 0x1c(%r15)
jne 0x6eddf
cmpl %ebp, 0x868(%r15)
jne 0x6eddf
movl $0x76696e, (%r14)       # imm = 0x76696E
leaq 0x9b456(%rip), %rsi     # 0x10a22a
pushq $0x50
popq %rdx
movq %rbx, %rdi
callq 0x82f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x8430
movq 0x828(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8430
movq 0x30(%rbx), %rdi
callq 0x8430
movq 0x38(%rbx), %rdi
callq 0x8430
movq 0x40(%rbx), %rdi
callq 0x8430
cmpl $0x0, 0x178(%rbx)
jle 0x75aba
movq 0x180(%rbx), %rdi
callq 0x8430
cmpw $0x1, 0xe(%r14)
jne 0x75b0a
cmpl %ebp, 0x848(%r14)
jne 0x75b0a
cmpw $0x1, 0x34(%r14)
je 0x75ae6
cmpw $0x1, 0x36(%r14)
je 0x75ae6
cmpw $0x1, 0x87c(%r14)
jne 0x75b0a
movq 0xe8(%rbx), %rdi
callq 0x8430
movq 0xf0(%rbx), %rdi
callq 0x8430
movq 0xf8(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x8430
movq 0xc8(%rbx), %rdi
callq 0x8430
movq 0xf0(%rbx), %rdi
callq 0x8430
movq 0xf8(%rbx), %rdi
callq 0x8430
movq 0x100(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8fff3
movq %rdi, %r14
cmpw $0x1, 0xb2a(%rdi)
movsd %xmm1, 0x18(%rsp)
jne 0x8ff53
cmpw $0x1, 0xb2c(%r14)
jne 0x8ff53
movsd 0xb38(%r14), %xmm0
addsd 0x558c9(%rip), %xmm0    # 0xe57e8
movsd %xmm0, 0x8(%rsp)
movsd 0xb30(%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm1, %xmm0
divsd (%r14), %xmm0
callq 0x82e0
movsd %xmm0, 0x10(%rsp)
movsd 0xb40(%r14), %xmm0
jmp 0x8ffae
movq 0x2b8(%r14), %rax
movq 0x2c0(%r14), %rcx
movq (%rax,%r15,8), %rax
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,8), %xmm0
addsd 0x55871(%rip), %xmm0    # 0xe57e8
movsd %xmm0, 0x8(%rsp)
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm1, %xmm0
divsd (%r14), %xmm0
callq 0x82e0
movsd %xmm0, 0x10(%rsp)
movq 0x2c8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
mulsd 0x55cfa(%rip), %xmm0    # 0xe5cb0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
divsd (%r14), %xmm0
callq 0x82e0
mulsd %xmm0, %xmm0
mulsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x86a0
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_O2/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
movsd %xmm2, (%rsp)
movq %rdi, %rbx
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x90ffe
ucomisd %xmm1, %xmm0
jae 0x90ffe
movsd %xmm0, 0x8(%rsp)
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x82e0
divsd 0x783a6(%rip), %xmm0    # 0x109328
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %eax
leal 0x2(%rax), %ebp
movl %ebp, 0x290(%rbx)
cltq
leaq 0x10(,%rax,8), %rdi
callq 0x8490
movq %rax, 0x298(%rbx)
testq %rax, %rax
je 0x91059
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq %ebp, %rax
cmpq %rax, %r15
movsd 0x8(%rsp), %xmm0
jge 0x910a6
callq 0x82e0
cvtsi2sd %r15d, %xmm1
mulsd 0x7834b(%rip), %xmm1    # 0x109328
divsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x298(%rbx), %rax
movsd %xmm1, (%rax,%r15,8)
incq %r15
movl 0x290(%rbx), %ebp
jmp 0x90fb9
leaq 0x7f0ac(%rip), %rsi     # 0x1100b1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x54067(%rip), %rsi     # 0xe5082
leaq 0x7f0b7(%rip), %rdx     # 0x1100d9
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x53fef(%rip), %rsi     # 0xe5034
leaq 0x7f0ac(%rip), %rdx     # 0x1100f8
movq %rbx, %rdi
movl $0x2ca, %ecx            # imm = 0x2CA
movq %r15, %r8
jmp 0x9109b
shll $0x3, %ebp
leaq 0x53fa1(%rip), %rsi     # 0xe5004
leaq 0x7f0a6(%rip), %rdx     # 0x110110
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x53fab(%rip), %rsi     # 0xe5034
leaq 0x7f068(%rip), %rdx     # 0x1100f8
movq %rbx, %rdi
movl $0x2ce, %ecx            # imm = 0x2CE
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x290(%rdi)
jle 0x91ff4
movl 0x18(%rbx), %eax
cmpl $0x5, %eax
je 0x91f60
testl %eax, %eax
jne 0x91f6f
leaq 0x2c8(%rbx), %r14
xorl %r15d, %r15d
movslq 0x278(%rbx), %rax
movq 0x2b8(%rbx), %rdi
cmpq %rax, %r15
jge 0x91f4d
movq (%rdi,%r15,8), %rdi
callq 0x8430
movq 0x2c0(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8430
movq 0x2c8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x8430
incq %r15
jmp 0x91f0c
callq 0x8430
movq 0x2c0(%rbx), %rdi
callq 0x8430
jmp 0x91f67
leaq 0x220(%rbx), %r14
movq (%r14), %rdi
callq 0x8430
xorl %r14d, %r14d
movslq 0x278(%rbx), %rax
movq 0x2a0(%rbx), %rdi
cmpq %rax, %r14
jge 0x91fb3
movq (%rdi,%r14,8), %rdi
callq 0x8430
movq 0x2a8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x2b0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
incq %r14
jmp 0x91f72
callq 0x8430
movq 0x2a8(%rbx), %rdi
callq 0x8430
movq 0x2b0(%rbx), %rdi
callq 0x8430
movq 0x280(%rbx), %rdi
callq 0x8430
movq 0x288(%rbx), %rdi
callq 0x8430
movq 0x298(%rbx), %rdi
callq 0x8430
andw $0x0, 0xb48(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_hubble
int primordial_inflation_hubble(
                                struct primordial * ppm,
                                double phi,
                                double * H,
                                double * dH,
                                double * ddH,
                                double * dddH
                                ) {

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

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
movsd 0x1e0(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x1d8(%rdi), %xmm1
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
mulsd %xmm0, %xmm2
mulsd 0x51f40(%rip), %xmm2    # 0xe5cb0
movsd %xmm2, 0x18(%rsp)
movq %rsi, %r13
movsd 0x1e8(%rdi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rsp)
movsd 0x529b1(%rip), %xmm1    # 0xe6748
callq 0x8650
divsd 0x528ac(%rip), %xmm0    # 0xe6650
mulsd 0x1f0(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x54637(%rip), %xmm1    # 0xe83f8
movsd 0x10(%rsp), %xmm0
callq 0x8650
divsd 0x528f4(%rip), %xmm0    # 0xe66c8
mulsd 0x1f8(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r13)
movsd 0x1e8(%r14), %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm1
addsd 0x1e0(%r14), %xmm1
movsd 0x1f0(%r14), %xmm2
mulsd 0x18(%rsp), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x52922(%rip), %xmm1    # 0xe6748
callq 0x8650
divsd 0x5281d(%rip), %xmm0    # 0xe6650
mulsd 0x1f8(%r14), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r12)
movsd 0x1f0(%r14), %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd 0x1e8(%r14), %xmm0
movsd 0x18(%rsp), %xmm1
mulsd 0x1f8(%r14), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r15)
movapd %xmm2, %xmm0
mulsd 0x1f8(%r14), %xmm0
addsd 0x1f0(%r14), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_check_hubble
int primordial_inflation_check_hubble(
                                      struct primordial * ppm,
                                      double phi,
                                      double * H,
                                      double * dH,
                                      double * ddH,
                                      double * dddH
                                      ) {

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

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

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

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x93d2d
movsd (%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x95339
leaq 0x7c0b5(%rip), %rsi     # 0x11139f
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x4fd7f(%rip), %rsi     # 0xe5082
leaq 0x7c0b9(%rip), %rdx     # 0x1113c3
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x4fd0c(%rip), %rsi     # 0xe5034
leaq 0x7c04e(%rip), %rdx     # 0x11137d
movq %rbx, %rdi
movl $0x99f, %ecx            # imm = 0x99F
jmp 0x9539a
movsd (%r14), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jbe 0x953a7
leaq 0x7c07e(%rip), %rsi     # 0x1113cb
leaq 0x800(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x4fd1c(%rip), %rsi     # 0xe5082
leaq 0x7c09b(%rip), %rdx     # 0x111408
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x4fca9(%rip), %rsi     # 0xe5034
leaq 0x7bfeb(%rip), %rdx     # 0x11137d
movq %rbx, %rdi
movl $0x9a4, %ecx            # imm = 0x9A4
movq %r15, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_check_potential
int primordial_inflation_check_potential(
                                         struct primordial * ppm,
                                         double phi,
                                         double * V,
                                         double * dV,
                                         double * ddV
                                         ) {

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

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

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

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
callq 0x93719
testl %eax, %eax
je 0x966a2
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x4ed85(%rip), %rsi     # 0xe53f0
leaq 0x7aba9(%rip), %rdx     # 0x11121b
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4e9a9(%rip), %rsi     # 0xe5034
leaq 0x7abba(%rip), %rdx     # 0x11124c
movq %rbx, %rdi
movl $0x96d, %ecx            # imm = 0x96D
movq %r14, %r8
jmp 0x96775
movsd 0x8(%rsp), %xmm0
xorpd %xmm2, %xmm2
ucomisd (%r15), %xmm2
jae 0x9671c
movsd (%r14), %xmm1
xorl %eax, %eax
ucomisd %xmm2, %xmm1
jb 0x9677f
leaq 0x7ac25(%rip), %rsi     # 0x1112f0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x4e9a1(%rip), %rsi     # 0xe5082
leaq 0x7ac8b(%rip), %rdx     # 0x111373
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x4e929(%rip), %rsi     # 0xe5034
leaq 0x7ab3a(%rip), %rdx     # 0x11124c
movq %rbx, %rdi
movl $0x977, %ecx            # imm = 0x977
jmp 0x96772
leaq 0x7ab4e(%rip), %rsi     # 0x111271
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0x4e949(%rip), %rsi     # 0xe5082
leaq 0x7aba7(%rip), %rdx     # 0x1112e7
leaq 0x810(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x4e8d1(%rip), %rsi     # 0xe5034
leaq 0x7aae2(%rip), %rdx     # 0x11124c
movq %rbx, %rdi
movl $0x972, %ecx            # imm = 0x972
movq %r15, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_get_epsilon
int primordial_inflation_get_epsilon(
                                     struct primordial * ppm,
                                     double phi,
                                     double * epsilon
                                     ) {

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

  switch (ppm->primordial_spec_type) {

  case inflation_V:
  case inflation_V_end:

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

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

  case inflation_H:

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

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

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

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rdi), %edx
cmpl $0x4, %edx
je 0x978f8
cmpl $0x3, %edx
je 0x9795d
cmpl $0x2, %edx
jne 0x97999
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x93719
testl %eax, %eax
je 0x979f7
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x4dacd(%rip), %rsi     # 0xe53f0
leaq 0x79ae7(%rip), %rdx     # 0x111411
leaq 0x810(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4d6ee(%rip), %rsi     # 0xe5034
leaq 0x79afa(%rip), %rdx     # 0x111447
movq %rbx, %rdi
movl $0x9c5, %ecx            # imm = 0x9C5
movq %r14, %r8
jmp 0x979eb
leaq 0x810(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x93d2d
movsd (%r12), %xmm0
divsd (%r15), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x77989(%rip), %xmm0    # 0x10f320
jmp 0x97a0e
leaq 0x78a5b(%rip), %rsi     # 0x1103fb
leaq 0x810(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x4dbcc(%rip), %rsi     # 0xe5585
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2e014
addq $0x32a, %rbx            # imm = 0x32A
leaq 0x4d65b(%rip), %rsi     # 0xe5034
leaq 0x79a67(%rip), %rdx     # 0x111447
movq %rbx, %rdi
movl $0x9d7, %ecx            # imm = 0x9D7
movq %r15, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0x97a15
movsd (%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x7799a(%rip), %xmm0    # 0x10f3a8
movsd %xmm0, (%r14)
xorl %eax, %eax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_output_titles
int primordial_output_titles(struct perturbations * ppt,
                             struct primordial * ppm,
                             char titles[_MAXTITLESTRINGLENGTH_]
                             ){
  class_store_columntitle(titles,"k [1/Mpc]",_TRUE_);
  class_store_columntitle(titles,"P_scalar(k)",_TRUE_);
  class_store_columntitle(titles,"P_tensor(k)",ppt->has_tensors);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x8190
movabsq $0x63704d2f315b206b, %rcx # imm = 0x63704D2F315B206B
movq %rcx, (%rbx,%rax)
movw $0x5d, 0x8(%rbx,%rax)
movq %rbx, %rdi
callq 0x8190
movw $0x9, %bp
movw %bp, (%rbx,%rax)
movq %rbx, %rdi
callq 0x8190
movabsq $0x72616c6163735f50, %rcx # imm = 0x72616C6163735F50
movq %rcx, (%rbx,%rax)
movl $0x296b28, 0x8(%rbx,%rax) # imm = 0x296B28
movq %rbx, %rdi
callq 0x8190
movw %bp, (%rbx,%rax)
cmpw $0x1, 0x12(%r14)
jne 0x97ab9
movq %rbx, %rdi
callq 0x8190
movabsq $0x726f736e65745f50, %rcx # imm = 0x726F736E65745F50
movq %rcx, (%rbx,%rax)
movl $0x296b28, 0x8(%rbx,%rax) # imm = 0x296B28
movq %rbx, %rdi
callq 0x8190
movw $0x9, (%rbx,%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_output_data
int primordial_output_data(struct perturbations * ppt,
                           struct primordial * ppm,
                           int number_of_titles,
                           double *data){

  int index_k, storeidx;
  double *dataptr;

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

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


  return _SUCCESS_;

}

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

  /* Eisenstein & Hu, implemented exactly like in HMcode, except
     for contribution of primodial spectrum (amplitude, tilt), now
     more accurate */
  class_call(hmcode_eisenstein_hu(ppr,
                                  pba,
                                  ppm,
                                  pfo,
                                  pfo->ln_k,
                                  pfo->k_size_extra,
                                  pfo->ln_pk_l_an_extra),
             pfo->error_message,
             pfo->error_message);

  class_call(array_spline_table_lines(pfo->ln_k,
                                      pfo->k_size_extra,
                                      pfo->ln_pk_l_an_extra,
                                      1,
                                      pfo->ddln_pk_l_an_extra,
                                      _SPLINE_NATURAL_,
                                      pfo->error_message),
             pfo->error_message,
             pfo->error_message);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rcx, %rbx
movq 0x80(%rcx), %r8
movl 0x104(%rcx), %r9d
movq 0x118(%rcx), %rax
movq %rax, (%rsp)
callq 0xdc341
cmpl $0x1, %eax
jne 0x9de76
addq $0x192, %rbx            # imm = 0x192
leaq 0x475b9(%rip), %rsi     # 0xe53f0
leaq 0x76e2e(%rip), %rdx     # 0x114c6c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x471dd(%rip), %rsi     # 0xe5034
leaq 0x76e6c(%rip), %rdx     # 0x114cca
movq %rbx, %rdi
movl $0xa20, %ecx            # imm = 0xA20
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %r14
jmp 0x9def4
movq 0x80(%rbx), %rdi
movl 0x104(%rbx), %esi
movq 0x118(%rbx), %rdx
movq 0x120(%rbx), %r8
addq $0x192, %rbx            # imm = 0x192
movq %rbx, (%rsp)
pushq $0x1
popq %rbp
xorl %r14d, %r14d
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x125a5
cmpl $0x1, %eax
jne 0x9def4
leaq 0x47538(%rip), %rsi     # 0xe53f0
leaq 0x76e28(%rip), %rdx     # 0x114ce7
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4715c(%rip), %rsi     # 0xe5034
leaq 0x76deb(%rip), %rdx     # 0x114cca
movq %rbx, %rdi
movl $0xa2a, %ecx            # imm = 0xA2A
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
movl %ebp, %r14d
movl %r14d, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/fourier.c
// Function: fourier_wnw_split
int fourier_wnw_split(
                      struct precision *ppr,
                      struct background *pba,
                      struct primordial * ppm,
                      struct fourier *pfo
                      ) {

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

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

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rcx, %rbx
callq 0xdbd3b
cmpl $0x1, %eax
jne 0x9df6b
addq $0x192, %rbx            # imm = 0x192
leaq 0x474c7(%rip), %rsi     # 0xe53f0
leaq 0x76e38(%rip), %rdx     # 0x114d68
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x470eb(%rip), %rsi     # 0xe5034
leaq 0x76e3a(%rip), %rdx     # 0x114d8a
movq %rbx, %rdi
movl $0xa44, %ecx            # imm = 0xA44
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %r14
jmp 0x9dff2
movl 0x90(%rbx), %esi
xorl %r14d, %r14d
cmpl $0x2, %esi
jl 0x9dff2
movq 0x88(%rbx), %rdi
movq 0x130(%rbx), %rdx
movl 0x104(%rbx), %ecx
movq 0x138(%rbx), %r8
addq $0x192, %rbx            # imm = 0x192
movq %rbx, (%rsp)
pushq $0x1
popq %rbp
movl %ebp, %r9d
callq 0x125a5
cmpl $0x1, %eax
jne 0x9dff2
leaq 0x4743a(%rip), %rsi     # 0xe53f0
leaq 0x76ddf(%rip), %rdx     # 0x114d9c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x4705e(%rip), %rsi     # 0xe5034
leaq 0x76dad(%rip), %rdx     # 0x114d8a
movq %rbx, %rdi
movl $0xa50, %ecx            # imm = 0xA50
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
movl %ebp, %r14d
movl %r14d, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/fourier.c
// Function: fourier_get_tau_list
int fourier_get_tau_list(
                         struct perturbations * ppt,
                         struct fourier * pfo
                         ) {

  int index_tau;

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

  if (ppt->ln_tau_size > 1) {

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

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

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

    pfo->tau_size = ppt->tau_size;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %rbx
movq %rdi, %r14
movslq 0xa60(%rdi), %r15
movl %r15d, 0x90(%rsi)
cmpq $0x2, %r15
jl 0x9e65d
leaq (,%r15,8), %rdi
callq 0x8490
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0x9e703
movq 0xa58(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x9e65d
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x9e649
cmpl $0x0, (%rbx)
je 0x9e6ba
movslq 0x9f8(%r14), %r15
movl %r15d, 0x140(%rbx)
movq %r15, %rdi
shlq $0x3, %rdi
callq 0x8490
movq %rax, 0x148(%rbx)
testq %rax, %rax
je 0x9e6c1
movq %rax, %rcx
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x9e74f
movq 0x9f0(%r14), %rdi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
jmp 0x9e69b
xorl %eax, %eax
jmp 0x9e74f
leal (,%r15,8), %ecx
leaq 0x46934(%rip), %rsi     # 0xe5004
leaq 0x76375(%rip), %rdx     # 0x114a4c
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
addq $0x192, %rbx            # imm = 0x192
leaq 0x46942(%rip), %rsi     # 0xe5034
leaq 0x7633e(%rip), %rdx     # 0x114a37
movq %rbx, %rdi
movl $0x8b8, %ecx            # imm = 0x8B8
jmp 0x9e742
shll $0x3, %r15d
leaq 0x468f6(%rip), %rsi     # 0xe5004
leaq 0x76316(%rip), %rdx     # 0x114a2b
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2e014
addq $0x192, %rbx            # imm = 0x192
leaq 0x46901(%rip), %rsi     # 0xe5034
leaq 0x762fd(%rip), %rdx     # 0x114a37
movq %rbx, %rdi
movl $0x8ac, %ecx            # imm = 0x8AC
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_source_tau_size_max
int transfer_source_tau_size_max(
                                 struct precision * ppr,
                                 struct background * pba,
                                 struct perturbations * ppt,
                                 struct transfer * ptr,
                                 double tau_rec,
                                 double tau0,
                                 int * tau_size_max
                                 ) {

  int index_md;
  int index_tt;
  int tau_size_tt=0;

  *tau_size_max = 0;

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

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

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

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

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %r8, %r14
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rcx, %rbx
leaq 0x14(%rsp), %rax
andl $0x0, (%rax)
movq %rdx, 0x18(%rsp)
andl $0x0, (%r8)
movq %rsi, %r13
movq %rdi, %rbp
xorl %r15d, %r15d
movslq 0x8a4(%rbx), %rax
cmpq %rax, %r15
jge 0xa0bdc
xorl %r12d, %r12d
movq 0x8f0(%rbx), %rax
cmpl (%rax,%r15,4), %r12d
jge 0xa0b7b
leaq 0x14(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rcx
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movl %r15d, %r8d
movl %r12d, %r9d
callq 0xa4dec
testl %eax, %eax
jne 0xa0b80
movl (%r14), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, (%r14)
incl %r12d
jmp 0xa0b28
incq %r15
jmp 0xa0b15
addq $0x96a, %rbx            # imm = 0x96A
leaq 0x44862(%rip), %rsi     # 0xe53f0
leaq 0x754a0(%rip), %rdx     # 0x116035
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x44486(%rip), %rsi     # 0xe5034
leaq 0x754de(%rip), %rdx     # 0x116093
movq %rbx, %rdi
movl $0x66a, %ecx            # imm = 0x66A
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xa0bca
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_perturbation_sources_spline_free
int transfer_perturbation_sources_spline_free(
                                              struct perturbations * ppt,
                                              struct transfer * ptr,
                                              double *** sources_spline
                                              ) {
  int index_md;
  int index_ic;
  int index_tp;

  for (index_md = 0; index_md < ptr->md_size; index_md++) {
    for (index_ic = 0; index_ic < ppt->ic_size[index_md]; index_ic++) {
      for (index_tp = 0; index_tp < ppt->tp_size[index_md]; index_tp++) {
        free(sources_spline[index_md][index_ic * ppt->tp_size[index_md] + index_tp]);
      }
    }
    free(sources_spline[index_md]);
  }
  free(sources_spline);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movslq 0x8a4(%r14), %rax
cmpq %rax, %r12
jge 0xa2f0e
xorl %ebp, %ebp
movq 0x870(%r15), %rax
cmpl (%rax,%r12,4), %ebp
jge 0xa2f00
xorl %r13d, %r13d
movq 0x998(%r15), %rax
movl (%rax,%r12,4), %eax
cmpl %eax, %r13d
jge 0xa2efc
movq (%rbx,%r12,8), %rcx
imull %ebp, %eax
addl %r13d, %eax
cltq
movq (%rcx,%rax,8), %rdi
callq 0x8430
incl %r13d
jmp 0xa2ed2
incl %ebp
jmp 0xa2ec2
movq (%rbx,%r12,8), %rdi
callq 0x8430
incq %r12
jmp 0xa2eb4
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq