LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/helium.c
// Function: rec_xesaha_HeII_III
double rec_xesaha_HeII_III(REC_COSMOPARAMS *cosmo, double z, double *xHeIII) {

  double Tr, nH, ainv, s;
  double nH0 = cosmo->nH0, Tr0 = cosmo->T0, fHe = cosmo->fHe;
  double fsR = cosmo->fsR, meR = cosmo->meR;
  /* Current conditions */
  Tr = Tr0*(ainv=1+z) /fsR/fsR/meR; /* Rescaled for different alpha, me */
  nH = nH0*ainv*ainv*ainv;

  /* Obtain Saha ratio, xe*xHeIII/xHeII
   * prefactor = (2*pi*m*k/h^2)^1.5. Includes dependence on fine-structure constant and electron mass*/

  s = fsR*fsR*fsR*meR*meR*meR* 2.414194e15*Tr*sqrt(Tr)*exp(-631462.7/Tr)/nH;

  *xHeIII = 2.*s*fHe/(1.+s+fHe)/(1.+sqrt(1.+4.*s*fHe/(1.+s+fHe)/(1.+s+fHe)));

  return(1. + fHe + *xHeIII);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x70(%rsp), %rax
movsd 0x88(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x70(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x70(%rsp), %rax
movsd 0x80(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x70(%rsp), %rax
movsd 0x98(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x70(%rsp), %rax
movsd 0xa0(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x2b9aa(%rip), %xmm1    # 0x1d2248
addsd 0x68(%rsp), %xmm1
movsd %xmm1, 0x48(%rsp)
mulsd %xmm1, %xmm0
divsd 0x20(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x38(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x67e40(%rip), %xmm1    # 0x20e750
mulsd %xmm1, %xmm0
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x58(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x67e04(%rip), %xmm0    # 0x20e748
divsd 0x58(%rsp), %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
divsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x2c310(%rip), %xmm0    # 0x1d2c80
mulsd 0x40(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd 0x2b8c4(%rip), %xmm1    # 0x1d2248
addsd 0x40(%rsp), %xmm1
addsd 0x28(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x2eb26(%rip), %xmm1    # 0x1d54c8
mulsd 0x40(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
movsd 0x2b892(%rip), %xmm0    # 0x1d2248
addsd 0x40(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
divsd %xmm0, %xmm1
movsd 0x2b87a(%rip), %xmm0    # 0x1d2248
addsd 0x40(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
divsd %xmm0, %xmm1
movsd 0x2b862(%rip), %xmm0    # 0x1d2248
addsd %xmm1, %xmm0
callq 0x82e0
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x2b848(%rip), %xmm1    # 0x1d2248
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x60(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x2b82f(%rip), %xmm0    # 0x1d2248
addsd 0x28(%rsp), %xmm0
movq 0x60(%rsp), %rax
addsd (%rax), %xmm0
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/helium.c
// Function: rec_saha_xHeII
double rec_saha_xHeII(REC_COSMOPARAMS *cosmo, double z) {

  double Tr, nH, ainv, s;
  double nH0 = cosmo->nH0, Tr0 = cosmo->T0, fHe = cosmo->fHe;
  double fsR = cosmo->fsR, meR = cosmo->meR;

  /* Current conditions */
  Tr = Tr0*(ainv=1+z) /fsR/fsR/meR; /* Rescaled for different alpha, me */
  nH = nH0*ainv*ainv*ainv;

  /* Obtain Saha ratio, xe*xHeII/xHeI. prefactor = (2*pi*m*k/h^2)^1.5 */
  s = fsR*fsR*fsR*meR*meR*meR *2.414194e15*Tr*sqrt(Tr)*exp(-285325./Tr)/nH * 4.;

  return 2.*s*fHe/(1.+s)/(1.+sqrt(1.+4.*s*fHe/(1.+s)/(1.+s)));

}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movq 0x70(%rsp), %rax
movsd 0x88(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x70(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x70(%rsp), %rax
movsd 0x80(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x70(%rsp), %rax
movsd 0x98(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x70(%rsp), %rax
movsd 0xa0(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x2b79f(%rip), %xmm1    # 0x1d2248
addsd 0x68(%rsp), %xmm1
movsd %xmm1, 0x50(%rsp)
mulsd %xmm1, %xmm0
divsd 0x28(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x40(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x28(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd 0x67c35(%rip), %xmm1    # 0x20e750
mulsd %xmm1, %xmm0
mulsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x67c07(%rip), %xmm0    # 0x20e758
divsd 0x60(%rsp), %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
divsd 0x58(%rsp), %xmm0
movsd 0x2e951(%rip), %xmm1    # 0x1d54c8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x2c0f7(%rip), %xmm0    # 0x1d2c80
mulsd 0x48(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x2b6ab(%rip), %xmm1    # 0x1d2248
addsd 0x48(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x2e913(%rip), %xmm1    # 0x1d54c8
mulsd 0x48(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
movsd 0x2b67f(%rip), %xmm0    # 0x1d2248
addsd 0x48(%rsp), %xmm0
divsd %xmm0, %xmm1
movsd 0x2b66d(%rip), %xmm0    # 0x1d2248
addsd 0x48(%rsp), %xmm0
divsd %xmm0, %xmm1
movsd 0x2b65b(%rip), %xmm0    # 0x1d2248
addsd %xmm1, %xmm0
callq 0x82e0
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x2b641(%rip), %xmm1    # 0x1d2248
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/hydrogen.c
// Function: free_atomic
void free_atomic(HYREC_ATOMIC *atomic){
  free_2D_array(atomic->logAlpha_tab[0], NTM);
  free_2D_array(atomic->logAlpha_tab[1], NTM);
  free_2D_array(atomic->logAlpha_tab[2], NTM);
  free_2D_array(atomic->logAlpha_tab[3], NTM);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x460(%rax), %rdi
movl $0x28, %esi
callq 0x1a5870
movq (%rsp), %rax
movq 0x468(%rax), %rdi
movl $0x28, %esi
callq 0x1a5870
movq (%rsp), %rax
movq 0x470(%rax), %rdi
movl $0x28, %esi
callq 0x1a5870
movq (%rsp), %rax
movq 0x478(%rax), %rdi
movl $0x28, %esi
callq 0x1a5870
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/hydrogen.c
// Function: interp_Dfnu
double interp_Dfnu(double lna_start, double dlna, double *ytab, unsigned int iz, double lna){
  long ind;
  double frac;

  /* If iz = 0 or 1, radiation field at earlier times is still thermal.
     Also thermal if iz > 1 and lna < lna_start. */
  if (iz == 0 || iz == 1 || lna < lna_start) return 0.;

  /* Check if in range */
  if (lna >= lna_start + dlna*(iz-1)) {
    fprintf(stderr, "Error in interp_Dfnu: lna-value out of range in interpolation routine\n");
    fprintf(stderr, "The time-step used is probably too large\n");
    exit(1);
  }

  /* If iz >= 2, do a linear interpolation so the spectrum is always positive */
  ind  = (long) floor((lna-lna_start)/dlna);
  frac = (lna-lna_start)/dlna - ind;

  return (1.-frac)*ytab[ind] + frac*ytab[ind+1];

}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movsd %xmm2, 0x18(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1ac25f
cmpl $0x1, 0x24(%rsp)
je 0x1ac25f
movsd 0x18(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1ac26d
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x1ac357
movsd 0x18(%rsp), %xmm0
movsd 0x38(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
movl 0x24(%rsp), %eax
decl %eax
cvtsi2sd %rax, %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1ac2d2
movq 0x97d31(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0x628b3(%rip), %rsi     # 0x20eb5c
movb $0x0, %al
callq 0x84e0
movq 0x97d19(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0x628e2(%rip), %rsi     # 0x20eba3
movb $0x0, %al
callq 0x84e0
movl $0x1, %edi
callq 0x8430
movsd 0x18(%rsp), %xmm0
subsd 0x38(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
callq 0x85d0
cvttsd2si %xmm0, %rax
movq %rax, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x38(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
cvtsi2sdq 0x10(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x25f2a(%rip), %xmm0    # 0x1d2248
subsd 0x8(%rsp), %xmm0
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x8(%rsp), %xmm1
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
mulsd 0x8(%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: rec_Tmss
double rec_Tmss(double z, double xe, REC_COSMOPARAMS *cosmo, double dEdtdV, double H) {

  double fsR = cosmo->fsR;
  double meR = cosmo->meR;
  double Tr  = cosmo->T0 *(1.+z);
  double nH  = cosmo->nH0 *cube(1.+z);

  /* Coefficient = 8 sigma_T a_r / (3 m_e c) */
  /* Here Tr, Tm are the actual (not rescaled) temperatures */
  double coeff  = fsR*fsR/meR/meR/meR*4.91466895548409e-22*Tr*Tr*Tr*Tr*xe/(1.+xe+cosmo->fHe)/H;
  double Tm = Tr/(1.+1./coeff)
              + (1.+2.*xe)/3.*dEdtdV/kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H /(1.+coeff);

  return Tm;
}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movsd %xmm2, 0x48(%rsp)
movsd %xmm3, 0x40(%rsp)
movq 0x50(%rsp), %rax
movsd 0x98(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x50(%rsp), %rax
movsd 0xa0(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x50(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x231ff(%rip), %xmm1    # 0x1d2248
addsd 0x60(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rax
movsd 0x88(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x231d4(%rip), %xmm0    # 0x1d2248
addsd 0x60(%rsp), %xmm0
callq 0x1a5670
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
movsd 0x5fbf8(%rip), %xmm1    # 0x20ecb0
mulsd %xmm1, %xmm0
mulsd 0x28(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
mulsd 0x58(%rsp), %xmm0
movsd 0x23166(%rip), %xmm1    # 0x1d2248
addsd 0x58(%rsp), %xmm1
movq 0x50(%rsp), %rax
addsd 0x80(%rax), %xmm1
divsd %xmm1, %xmm0
divsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x23135(%rip), %xmm2    # 0x1d2248
divsd 0x18(%rsp), %xmm2
movsd 0x23127(%rip), %xmm1    # 0x1d2248
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x58(%rsp), %xmm1
addsd %xmm1, %xmm1
movsd 0x2310d(%rip), %xmm2    # 0x1d2248
addsd %xmm2, %xmm1
movsd 0x24551(%rip), %xmm2    # 0x1d3698
divsd %xmm2, %xmm1
mulsd 0x48(%rsp), %xmm1
movsd 0x5f79f(%rip), %xmm2    # 0x20e8f8
divsd %xmm2, %xmm1
movsd 0x23aeb(%rip), %xmm2    # 0x1d2c50
mulsd 0x20(%rsp), %xmm2
movsd 0x230d5(%rip), %xmm3    # 0x1d2248
addsd 0x58(%rsp), %xmm3
movq 0x50(%rsp), %rax
addsd 0x80(%rax), %xmm3
mulsd %xmm3, %xmm2
divsd %xmm2, %xmm1
divsd 0x40(%rsp), %xmm1
movsd 0x230ac(%rip), %xmm2    # 0x1d2248
addsd 0x18(%rsp), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: rec_dTmdlna
double rec_dTmdlna(double z, double xe, double Tm, REC_COSMOPARAMS *cosmo, double dEdtdV, double H) {
  double fsR = cosmo->fsR;
  double meR = cosmo->meR;
  double Tr  = cosmo->T0 *(1.+z);
  double nH  = cosmo->nH0 *cube(1.+z);
  return ( (Tr/Tm-1.<1e-10  && Tr > 3000.)  ? -Tr :
          -2.*Tm + fsR*fsR/meR/meR/meR*4.91466895548409e-22*Tr*Tr*Tr*Tr*xe/(1.+xe+cosmo->fHe)*(Tr-Tm)/H
          + (1.+2.*xe)/3. *dEdtdV /kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H);
   /* Coefficient = 8 sigma_T a_r / (3 m_e c) */
   /* Here Tr, Tm are the actual (not rescaled) temperatures */
}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
movsd %xmm2, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movsd %xmm3, 0x40(%rsp)
movsd %xmm4, 0x38(%rsp)
movq 0x48(%rsp), %rax
movsd 0x98(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x48(%rsp), %rax
movsd 0xa0(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x23029(%rip), %xmm1    # 0x1d2248
addsd 0x60(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rax
movsd 0x88(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x22ffe(%rip), %xmm0    # 0x1d2248
addsd 0x60(%rsp), %xmm0
callq 0x1a5670
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
divsd 0x50(%rsp), %xmm1
movsd 0x22fcc(%rip), %xmm0    # 0x1d2248
subsd %xmm0, %xmm1
movsd 0x272a8(%rip), %xmm0    # 0x1d6530
ucomisd %xmm1, %xmm0
jbe 0x1af2ca
movsd 0x20(%rsp), %xmm0
movsd 0x5fa1c(%rip), %xmm1    # 0x20ecb8
ucomisd %xmm1, %xmm0
jbe 0x1af2ca
movsd 0x20(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x1af3ca
movsd 0x50(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
movsd 0x5f9ba(%rip), %xmm2    # 0x20ecb0
mulsd %xmm2, %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x58(%rsp), %xmm0
movsd 0x22f28(%rip), %xmm2    # 0x1d2248
addsd 0x58(%rsp), %xmm2
movq 0x48(%rsp), %rax
addsd 0x80(%rax), %xmm2
divsd %xmm2, %xmm0
movsd 0x20(%rsp), %xmm2
subsd 0x50(%rsp), %xmm2
mulsd %xmm2, %xmm0
divsd 0x38(%rsp), %xmm0
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
movsd 0x58(%rsp), %xmm1
addsd %xmm1, %xmm1
movsd 0x22ee1(%rip), %xmm2    # 0x1d2248
addsd %xmm2, %xmm1
movsd 0x24325(%rip), %xmm2    # 0x1d3698
divsd %xmm2, %xmm1
mulsd 0x40(%rsp), %xmm1
movsd 0x5f573(%rip), %xmm2    # 0x20e8f8
divsd %xmm2, %xmm1
movsd 0x238bf(%rip), %xmm2    # 0x1d2c50
mulsd 0x18(%rsp), %xmm2
movsd 0x22ea9(%rip), %xmm3    # 0x1d2248
addsd 0x58(%rsp), %xmm3
movq 0x48(%rsp), %rax
addsd 0x80(%rax), %xmm3
mulsd %xmm3, %xmm2
divsd %xmm2, %xmm1
divsd 0x38(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: Tm_implicit
double Tm_implicit(double z, double xe, double Tm, REC_COSMOPARAMS *cosmo, double dEdtdV, double H, double DLNA) {
  double fsR = cosmo->fsR;
  double meR = cosmo->meR;
  double Tr  = cosmo->T0 *(1.+z);
  double nH  = cosmo->nH0 *cube(1.+z);
  double gamma = fsR*fsR/meR/meR/meR*4.91466895548409e-22*Tr*Tr*Tr*Tr*xe/(1.+xe+cosmo->fHe)/H;
  return (Tm + DLNA*(gamma*Tr + (1.+2.*xe)/3. *dEdtdV /kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H) )/ ( 1.+(2.+gamma)*DLNA );
}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
movsd %xmm2, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movsd %xmm3, 0x40(%rsp)
movsd %xmm4, 0x38(%rsp)
movsd %xmm5, 0x30(%rsp)
movq 0x48(%rsp), %rax
movsd 0x98(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rax
movsd 0xa0(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x22e03(%rip), %xmm1    # 0x1d2248
addsd 0x60(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movsd 0x88(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x22dd9(%rip), %xmm0    # 0x1d2248
addsd 0x60(%rsp), %xmm0
callq 0x1a5670
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
movsd 0x5f7fe(%rip), %xmm1    # 0x20ecb0
mulsd %xmm1, %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd 0x58(%rsp), %xmm0
movsd 0x22d6c(%rip), %xmm1    # 0x1d2248
addsd 0x58(%rsp), %xmm1
movq 0x48(%rsp), %rax
addsd 0x80(%rax), %xmm1
divsd %xmm1, %xmm0
divsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x50(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
movsd 0x18(%rsp), %xmm4
movsd 0x58(%rsp), %xmm3
addsd %xmm3, %xmm3
movsd 0x22d1f(%rip), %xmm5    # 0x1d2248
addsd %xmm5, %xmm3
movsd 0x24163(%rip), %xmm5    # 0x1d3698
divsd %xmm5, %xmm3
mulsd 0x40(%rsp), %xmm3
movsd 0x5f3b1(%rip), %xmm5    # 0x20e8f8
divsd %xmm5, %xmm3
movsd 0x236fd(%rip), %xmm5    # 0x1d2c50
mulsd 0x10(%rsp), %xmm5
movsd 0x22ce7(%rip), %xmm6    # 0x1d2248
addsd 0x58(%rsp), %xmm6
movq 0x48(%rsp), %rax
addsd 0x80(%rax), %xmm6
mulsd %xmm6, %xmm5
divsd %xmm5, %xmm3
divsd 0x38(%rsp), %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x236e6(%rip), %xmm1    # 0x1d2c80
addsd 0x8(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x22c96(%rip), %xmm2    # 0x1d2248
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_integrator
double hyrec_integrator(double deriv, double deriv_prev[2], double z) {
  double result;

  if (MODEL == FULL) result = 1.25 * deriv - 0.25 *deriv_prev[1];
  else result = 23./12.*deriv -16./12. * deriv_prev[0] + 5./12. *deriv_prev[1];

  // update derivatives
  deriv_prev[1] = deriv_prev[0];
  deriv_prev[0] = deriv;

  return result;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movq %rdi, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd -0x8(%rsp), %xmm1
movq -0x10(%rsp), %rax
movsd 0x25f2c(%rip), %xmm0    # 0x1d5510
mulsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x5f6c1(%rip), %xmm2    # 0x20ecc8
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x5f69f(%rip), %xmm2    # 0x20ecc0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x8(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_free
void hyrec_free(HYREC_DATA *data) {
  free_atomic(data->atomic);
  free(data->cosmo->inj_params);
  free(data->cosmo);
  free(data->atomic);
  free(data->xe_output);
  free(data->Tm_output);
  free(data->error_message);
  if (MODEL == FULL) free_radiation(data->rad);
  free(data->rad);
  free_fit(data->fit);
  free(data->fit);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1a8530
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x1a87f0
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x8420
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_xe
double hyrec_xe(double z, HYREC_DATA *data) {
  if (z > data->zmax) return data->xe_output[0];
  if (z < data->zmin) {
    fprintf(stderr, "\033[1m\033[31m error\033[22;30m in hyrec_xe: requesting x_e at z = %f ", z);
    fprintf(stderr, "lower than zmin\n");
    exit(1);
  }
  double DLNA = data->cosmo->dlna;
  return rec_interp1d(-log(1.+data->zmax), DLNA, data->xe_output, data->Nz, -log(1.+z), &data->error, data->error_message);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movq 0x30(%rsp), %rax
ucomisd 0x10(%rax), %xmm0
jbe 0x1b3429
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x1b3550
movsd 0x38(%rsp), %xmm1
movq 0x30(%rsp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1b347f
movq 0x90b8a(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
movsd 0x38(%rsp), %xmm0
leaq 0x5c349(%rip), %rsi     # 0x20f79f
movb $0x1, %al
callq 0x84e0
movq 0x90b6c(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0x5c370(%rip), %rsi     # 0x20f7de
movb $0x0, %al
callq 0x84e0
movl $0x1, %edi
callq 0x8430
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0xa8(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movsd 0x1eda5(%rip), %xmm0    # 0x1d2248
addsd 0x10(%rax), %xmm0
callq 0x82f0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movl %eax, 0x1c(%rsp)
movsd 0x1ed4f(%rip), %xmm0    # 0x1d2248
addsd 0x38(%rsp), %xmm0
callq 0x82f0
movsd 0x8(%rsp), %xmm1
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movaps %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
movq 0x30(%rsp), %rdx
addq $0x38, %rdx
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rcx
callq 0x1a5ae0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/history.c
// Function: hyrec_Tm
double hyrec_Tm(double z, HYREC_DATA *data) {
  if(z > data->zmax) return data->cosmo->T0*(1.+z);
  if (z < data->zmin) {
    fprintf(stderr, "\033[1m\033[31m error\033[22;30m in hyrec_Tm: requesting x_e at z = %f ", z);
    fprintf(stderr, "lower than zmin\n");
    exit(1);
  }
  double DLNA = data->cosmo->dlna;
  return rec_interp1d(-log(1.+data->zmax), DLNA, data->Tm_output, data->Nz, -log(1.+z), &data->error, data->error_message);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movq 0x30(%rsp), %rax
ucomisd 0x10(%rax), %xmm0
jbe 0x1b35ac
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd 0x1ecb1(%rip), %xmm1    # 0x1d2248
addsd 0x38(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x1b36d3
movsd 0x38(%rsp), %xmm1
movq 0x30(%rsp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1b3602
movq 0x90a07(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
movsd 0x38(%rsp), %xmm0
leaq 0x5c216(%rip), %rsi     # 0x20f7ef
movb $0x1, %al
callq 0x84e0
movq 0x909e9(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0x5c1ed(%rip), %rsi     # 0x20f7de
movb $0x0, %al
callq 0x84e0
movl $0x1, %edi
callq 0x8430
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0xa8(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movsd 0x1ec22(%rip), %xmm0    # 0x1d2248
addsd 0x10(%rax), %xmm0
callq 0x82f0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movl %eax, 0x1c(%rsp)
movsd 0x1ebcc(%rip), %xmm0    # 0x1d2248
addsd 0x38(%rsp), %xmm0
callq 0x82f0
movsd 0x8(%rsp), %xmm1
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movaps %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
movq 0x30(%rsp), %rdx
addq $0x38, %rdx
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rcx
callq 0x1a5ae0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/wrap_hyrec.c
// Function: thermodynamics_hyrec_free
int thermodynamics_hyrec_free(struct thermohyrec* phy){

  /* We just need to free hyrec (without error management) */
  hyrec_free(phy->data);
  free(phy->data);

  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1b3330
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: beta_pbh
double beta_pbh(double Mpbh, double z, double xe, double Teff) {
  double a, vB, tB;

  a     = 1./(1.+z);
  vB    = 9.09e3 * sqrt((1.+xe)*Teff);    /* Bondi speed in cm/s */
  tB    = 1.33e26 *Mpbh/vB/vB/vB;         /* Bondi timescale in sec*/

  return 5.60e-24 *xe/a/a/a/a *tB;       
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd 0x1db04(%rip), %xmm1    # 0x1d2248
addsd 0x28(%rsp), %xmm1
movsd 0x1daf6(%rip), %xmm0    # 0x1d2248
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x1dae4(%rip), %xmm0    # 0x1d2248
addsd 0x20(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0x5b228(%rip), %xmm0    # 0x20f9a8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x5b20e(%rip), %xmm0    # 0x20f9a0
mulsd 0x30(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x5b1e1(%rip), %xmm0    # 0x20f998
mulsd 0x20(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
mulsd (%rsp), %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: lambda_pbh
double lambda_pbh(double Mpbh, double z, double xe, double Teff) {
  double beta, gamma, lam_ricotti, lam_ad, lam_iso, lam_nodrag;

  beta  = beta_pbh(Mpbh, z, xe, Teff);
  gamma = gamma_pbh(Mpbh, z, xe, Teff);        
  
  lam_ricotti = exp(4.5/(3.+pow(beta, 0.75)))/square(sqrt(1.+beta)+1.);
  /* Fitting formula from Ricotti 2007 for the fully isothermal case */
  lam_ad      = pow(0.6, 1.5)/4.;
  lam_iso     = exp(1.5)/4.; 
  
  lam_nodrag = lam_ad + (lam_iso - lam_ad) * pow(gamma*gamma/(88. + gamma*gamma), 0.22); /* Fitting formula for the no-drag case */
   
  return lam_ricotti *lam_nodrag /lam_iso;
}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
movsd %xmm2, 0x50(%rsp)
movsd %xmm3, 0x48(%rsp)
movsd 0x60(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
movsd 0x48(%rsp), %xmm3
callq 0x1b4720
movsd %xmm0, 0x40(%rsp)
movsd 0x60(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
movsd 0x48(%rsp), %xmm3
callq 0x1b47e0
movsd %xmm0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x1e408(%rip), %xmm1    # 0x1d2cc8
callq 0x8610
movsd 0x1edcb(%rip), %xmm1    # 0x1d3698
addsd %xmm0, %xmm1
movsd 0x41a77(%rip), %xmm0    # 0x1f6350
divsd %xmm1, %xmm0
callq 0x8670
movsd %xmm0, (%rsp)
movsd 0x1d959(%rip), %xmm0    # 0x1d2248
addsd 0x40(%rsp), %xmm0
callq 0x82e0
movsd 0x1d946(%rip), %xmm1    # 0x1d2248
addsd %xmm1, %xmm0
callq 0x1a5650
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x1d96b(%rip), %xmm0    # 0x1d2290
movsd 0x1e323(%rip), %xmm1    # 0x1d2c50
callq 0x8610
movsd 0x20b8e(%rip), %xmm1    # 0x1d54c8
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x1e304(%rip), %xmm0    # 0x1d2c50
callq 0x8670
movsd 0x20b6f(%rip), %xmm1    # 0x1d54c8
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x58293(%rip), %xmm2    # 0x20cc38
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x5827b(%rip), %xmm1    # 0x20cc30
callq 0x8610
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: TS_over_me_pbh
double TS_over_me_pbh(double Mpbh, double z, double xe, double Teff) {
  double gamma, tau, omega, Y;
  
  gamma = gamma_pbh(Mpbh, z, xe, Teff);

  tau = 1.5/(5. + pow(gamma, 2./3.));     /* T/Teff -> tau *rB/r        for r << rB */
  omega = sqrt(2. - 5*tau);               /* v/vB -> -omega *sqrt(rB/r) for r << rB */

  Y = pow((1.+ xe)/2., 7.) * tau/2. *pow(omega/4.,2./3.)*1836.;

  return Y /pow(1.+Y/0.27, 1./3.); 
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd %xmm2, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
callq 0x1b47e0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x20a3b(%rip), %xmm1    # 0x1d5538
callq 0x8610
movsd 0x1d766(%rip), %xmm1    # 0x1d2270
addsd %xmm0, %xmm1
movsd 0x1e13a(%rip), %xmm0    # 0x1d2c50
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x39bfa(%rip), %xmm1    # 0x1ee728
mulsd %xmm1, %xmm0
movsd 0x1e146(%rip), %xmm1    # 0x1d2c80
addsd %xmm1, %xmm0
callq 0x82e0
movsd %xmm0, 0x20(%rsp)
movsd 0x1d6f7(%rip), %xmm0    # 0x1d2248
addsd 0x40(%rsp), %xmm0
movsd 0x1e121(%rip), %xmm1    # 0x1d2c80
divsd %xmm1, %xmm0
movsd 0x1ec1d(%rip), %xmm1    # 0x1d3788
callq 0x8610
mulsd 0x28(%rsp), %xmm0
movsd 0x1e102(%rip), %xmm1    # 0x1d2c80
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x20932(%rip), %xmm1    # 0x1d54c8
divsd %xmm1, %xmm0
movsd 0x20996(%rip), %xmm1    # 0x1d5538
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x5ae04(%rip), %xmm1    # 0x20f9c0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm1
movsd 0x58030(%rip), %xmm0    # 0x20cc10
divsd %xmm0, %xmm1
movsd 0x1d65c(%rip), %xmm0    # 0x1d2248
addsd %xmm1, %xmm0
movsd 0x208a0(%rip), %xmm1    # 0x1d5498
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: eps_over_mdot_pbh
double eps_over_mdot_pbh(double Mpbh, double z, double xe, double Teff) {
  double X, G;

  X = TS_over_me_pbh(Mpbh, z, xe, Teff);
  
  /* Fit to the (e-e + e-p) free-free Gaunt factor */
  if (X < 1) G = 4./M_PI * sqrt(2./M_PI/X) *(1.+ 5.5*pow(X, 1.25));
  else       G = 27./2./M_PI *(log(2.*X*0.56146 + 0.08) + 4./3.);

  return X/1836./137. * G;   /* alpha[fine-struct] * TS/mp * G */
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
callq 0x1b4ab0
movsd %xmm0, 0x10(%rsp)
movsd 0x1d5f1(%rip), %xmm0    # 0x1d2248
ucomisd 0x10(%rsp), %xmm0
jbe 0x1b4cc5
movsd 0x57ff1(%rip), %xmm0    # 0x20cc58
divsd 0x10(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0x57fd3(%rip), %xmm0    # 0x20cc50
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x1e014(%rip), %xmm1    # 0x1d2ca8
callq 0x8610
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movsd 0x57f9f(%rip), %xmm2    # 0x20cc48
mulsd %xmm2, %xmm1
movsd 0x1d593(%rip), %xmm2    # 0x1d2248
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x1b4d11
movsd 0x1dfb3(%rip), %xmm0    # 0x1d2c80
mulsd 0x10(%rsp), %xmm0
movsd 0x5aced(%rip), %xmm1    # 0x20f9c8
mulsd %xmm1, %xmm0
movsd 0x57f81(%rip), %xmm1    # 0x20cc68
addsd %xmm1, %xmm0
callq 0x82f0
movaps %xmm0, %xmm1
movsd 0x20815(%rip), %xmm0    # 0x1d5510
addsd %xmm0, %xmm1
movsd 0x57f59(%rip), %xmm0    # 0x20cc60
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x5aca1(%rip), %xmm1    # 0x20f9c0
divsd %xmm1, %xmm0
movsd 0x5aca5(%rip), %xmm1    # 0x20f9d0
divsd %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: L_pbh
double L_pbh(double Mpbh, double z, double xe, double Teff) {
  double Mdot, mdot, eff;

  Mdot = Mdot_pbh(Mpbh, z, xe, Teff); 
  mdot = Mdot / (1.4e17 * Mpbh);        /* Mdot c^2 / L_Eddington */ 
  eff  = mdot *eps_over_mdot_pbh(Mpbh, z, xe, Teff); 
  
  return eff * Mdot * 9e20;  /* L = epsilon Mdot c^2 */  
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd %xmm2, 0x30(%rsp)
movsd %xmm3, 0x28(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
callq 0x1b49f0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x5ac53(%rip), %xmm1    # 0x20f9e0
mulsd 0x40(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
callq 0x1b4c10
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd 0x5abeb(%rip), %xmm1    # 0x20f9d8
mulsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: L_pbh_av
double L_pbh_av(double Mpbh, double z, double xe, double Tgas) {
  double vbc_rms, vbc_max, vbc, P_vbc, num, denom, x, Teff;
  int i, Nvbc;

  Nvbc = 50; // More than enough at the level of precision we use
  
  vbc_rms = vbc_rms_func(z);
 
  vbc_max = 5.*vbc_rms;

  num = denom = 0.;
  for (i = 0; i < Nvbc; i++) {
    vbc    = i*vbc_max/(Nvbc-1.);
    x      = vbc/vbc_rms;
    denom += P_vbc = x*x* exp(-1.5*x*x);

    Teff = Tgas + 121e-10 *vbc*vbc/(1.+xe); 
    
    num += L_pbh(Mpbh, z, xe, Teff) * P_vbc;
  }

  return num/denom;
}

// Assembly:
subq $0x78, %rsp
movsd %xmm0, 0x70(%rsp)
movsd %xmm1, 0x68(%rsp)
movsd %xmm2, 0x60(%rsp)
movsd %xmm3, 0x58(%rsp)
movl $0x32, 0x10(%rsp)
movsd 0x68(%rsp), %xmm0
callq 0x1b4e00
movsd %xmm0, 0x50(%rsp)
movsd 0x1d3d3(%rip), %xmm0    # 0x1d2270
mulsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x1b4fd2
cvtsi2sdl 0x14(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
movsd 0x1d35d(%rip), %xmm2    # 0x1d2248
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
divsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x205c3(%rip), %xmm0    # 0x1d54e8
mulsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x58(%rsp), %xmm0
movsd 0x5aa8d(%rip), %xmm1    # 0x20f9f0
mulsd 0x40(%rsp), %xmm1
mulsd 0x40(%rsp), %xmm1
movsd 0x1d2d1(%rip), %xmm2    # 0x1d2248
addsd 0x60(%rsp), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x70(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movsd 0x60(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
callq 0x1b4d40
movsd 0x38(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1b4ec3
movsd 0x30(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: dEdtdV_pbh
double dEdtdV_pbh(double fpbh, double Mpbh, double z, double xe, double Tgas) { 
  double xe_used = (xe < 1.? xe : 1.); /* Since we are not accounting for Helium */
  if (fpbh > 0.) {
    return 6.12e-52/Mpbh * cube(1.+z) * fpbh *L_pbh_av(Mpbh, z, xe_used, Tgas);
  }
  else return 0.;
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd %xmm3, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd 0x1d22e(%rip), %xmm0    # 0x1d2248
ucomisd 0x30(%rsp), %xmm0
jbe 0x1b5030
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x1b5040
movsd 0x1d210(%rip), %xmm0    # 0x1d2248
movsd %xmm0, 0x18(%rsp)
jmp 0x1b5040
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x48(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1b50cd
movsd 0x5a995(%rip), %xmm0    # 0x20f9f8
divsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1d1d1(%rip), %xmm0    # 0x1d2248
addsd 0x38(%rsp), %xmm0
callq 0x1a5670
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
callq 0x1b4e60
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x1b50d6
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/energy_injection.c
// Function: update_dEdtdV_dep
void update_dEdtdV_dep(double z_out, double dlna, double xe, double Tgas,
		       double nH, double H, INJ_PARAMS *params, double *dEdtdV_dep) {

  double inj  = dEdtdV_inj(z_out, xe, Tgas, params);
  
  if (params->on_the_spot == 1) *dEdtdV_dep = inj;

  // Else put in your favorite recipe to translate from injection to deposition
  // Here I assume injected photon spectrum Compton cools at rate dE/dt = - 0.1 n_h c sigma_T E
  // This is valid for E_photon ~ MeV or so.
  
  else { // c sigma_T = 2e-14 (cgs)
    *dEdtdV_dep = (*dEdtdV_dep *exp(-7.*dlna) + 2e-15* dlna*nH/H *inj)
                 /(1.+ 2e-15 *dlna*nH/H);                              
  }       
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd %xmm2, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movsd %xmm4, 0x30(%rsp)
movsd %xmm5, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
movq 0x20(%rsp), %rdi
callq 0x1b50f0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, 0x58(%rax)
jne 0x1b51d3
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x1b5259
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x2033e(%rip), %xmm0    # 0x1d5528
mulsd 0x48(%rsp), %xmm0
callq 0x8670
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x5a7fa(%rip), %xmm1    # 0x20fa00
mulsd 0x48(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
divsd 0x28(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x5a7d2(%rip), %xmm2    # 0x20fa00
mulsd 0x48(%rsp), %xmm2
mulsd 0x30(%rsp), %xmm2
divsd 0x28(%rsp), %xmm2
movsd 0x1d000(%rip), %xmm1    # 0x1d2248
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_workspace_free
int hmcode_workspace_free(
                          struct fourier *pfo,
                          struct hmcode_workspace *phw
                          ) {

  int index_pk;

  free(phw->rtab);
  free(phw->stab);
  free(phw->ddstab);

  free(phw->growtable);
  free(phw->ztable);
  free(phw->tautable);

  for (index_pk=0; index_pk<pfo->pk_size; index_pk++){
    free(phw->sigma_8[index_pk]);
    free(phw->sigma_disp[index_pk]);
    free(phw->sigma_disp_100[index_pk]);
    free(phw->sigma_prime[index_pk]);
  }

  free(phw->sigma_8);
  free(phw->sigma_disp);
  free(phw->sigma_disp_100);
  free(phw->sigma_prime);

  free(phw->pk_wiggle);
  free(phw->ddpk_wiggle);
  free(phw->lnk_wiggle);

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x64(%rcx), %eax
jge 0x1bd660
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1bd5e9
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8420
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_baryonic_feedback
int hmcode_baryonic_feedback(
                             struct fourier *pfo
                             ) {

  switch (pfo->feedback) {

  case hmcode_emu_dmonly:
    {
      pfo->eta_0 = 0.603;
      pfo->c_min = 3.13;
      break;
    }

  case hmcode_owls_dmonly:
    {
      pfo->eta_0 = 0.64;
      pfo->c_min = 3.43;
      break;
    }

  case hmcode_owls_ref:
    {
      pfo->eta_0 = 0.68;
      pfo->c_min = 3.91;
      break;
    }

  case hmcode_owls_agn:
    {
      pfo->eta_0 = 0.76;
      pfo->c_min = 2.32;
      break;
    }

  case hmcode_owls_dblim:
    {
      pfo->eta_0 = 0.70;
      pfo->c_min = 3.01;
      break;
    }

  case hmcode_user_defined:
    {
      /* eta_0 and c_min already passed in input */
      break;
    }
  }
  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x10(%rsp)
subq $0x5, %rax
ja 0x1bdf04
movq -0x10(%rsp), %rax
leaq 0x52670(%rip), %rcx     # 0x2104a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rsp), %rax
movsd 0x52562(%rip), %xmm0    # 0x2103b0
movsd %xmm0, 0x18(%rax)
movq -0x8(%rsp), %rax
movsd 0x52548(%rip), %xmm0    # 0x2103a8
movsd %xmm0, 0x10(%rax)
jmp 0x1bdf04
movq -0x8(%rsp), %rax
movsd 0x52529(%rip), %xmm0    # 0x2103a0
movsd %xmm0, 0x18(%rax)
movq -0x8(%rsp), %rax
movsd 0x5250f(%rip), %xmm0    # 0x210398
movsd %xmm0, 0x10(%rax)
jmp 0x1bdf04
movq -0x8(%rsp), %rax
movsd 0x524f3(%rip), %xmm0    # 0x210390
movsd %xmm0, 0x18(%rax)
movq -0x8(%rsp), %rax
movsd 0x524d9(%rip), %xmm0    # 0x210388
movsd %xmm0, 0x10(%rax)
jmp 0x1bdf04
movq -0x8(%rsp), %rax
movsd 0x524bd(%rip), %xmm0    # 0x210380
movsd %xmm0, 0x18(%rax)
movq -0x8(%rsp), %rax
movsd 0x524a3(%rip), %xmm0    # 0x210378
movsd %xmm0, 0x10(%rax)
jmp 0x1bdf04
movq -0x8(%rsp), %rax
movsd 0x3e4df(%rip), %xmm0    # 0x1fc3c8
movsd %xmm0, 0x18(%rax)
movq -0x8(%rsp), %rax
movsd 0x52475(%rip), %xmm0    # 0x210370
movsd %xmm0, 0x10(%rax)
jmp 0x1bdf04
jmp 0x1bdf04
xorl %eax, %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_halomassfunction
int hmcode_halomassfunction(
                            double nu,
                            double *hmf
                            ){

  double p, q, A;

  p=0.3;
  q=0.707;
  A=0.21616;

  *hmf=A*(1.+(pow(q*nu*nu, -p)))*exp(-q*nu*nu/2.);

  return _SUCCESS_;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movsd 0x12e81(%rip), %xmm0    # 0x1d2288
movsd %xmm0, 0x20(%rsp)
movsd 0x50fd3(%rip), %xmm0    # 0x2103e8
movsd %xmm0, 0x18(%rsp)
movsd 0x50fbd(%rip), %xmm0    # 0x2103e0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
callq 0x8610
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x12dd0(%rip), %xmm1    # 0x1d2248
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd 0x30(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x137c9(%rip), %xmm1    # 0x1d2c80
divsd %xmm1, %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HMcode/hmcode.c
// Function: hmcode_noradiation_growth_free
int hmcode_noradiation_growth_free(
                                   struct fourier *pfo,
                                   struct hmcode_workspace *phw
                                   ){

  struct hmcode_growth *phg;

  phg = phw->phg;
  free(phg->a_table);
  free(phg->growth_table);
  free(phg->normgrowth_table);
  free(phg->ddnormgrowth_table);
  free(phg->dda_table);
  free(phg->pvecnorad);
  free(phg);

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x8420
movq (%rsp), %rdi
callq 0x8420
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)