LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x828, %rsp            # imm = 0x828
movq %rdi, 0x818(%rsp)
movq %rsi, 0x810(%rsp)
movq 0x810(%rsp), %rax
movq 0x80(%rax), %rax
movq 0xa0(%rax), %rdi
callq 0x8420
movq 0x810(%rsp), %rax
movq 0x80(%rax), %rax
movq 0xa8(%rax), %rdi
callq 0x8420
movq 0x818(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xbaa84
jmp 0xba9c6
movl 0xc(%rsp), %eax
subl $0x1, %eax
jne 0xbaa9f
jmp 0xba9d5
movq 0x810(%rsp), %rax
movq 0x80(%rax), %rax
movq 0xc0(%rax), %rdi
callq 0x1b3aa0
cmpl $0x1, %eax
jne 0xbaa67
leaq 0x10(%rsp), %rdi
movq 0x810(%rsp), %rax
movq 0x80(%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x20, %rcx
leaq 0x1179bd(%rip), %rsi    # 0x1d23d8
leaq 0x138e35(%rip), %rdx    # 0x1f3857
movb $0x0, %al
callq 0x5b9c0
movq 0x818(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x10(%rsp), %r8
leaq 0x1175f0(%rip), %rsi    # 0x1d2034
leaq 0x138e39(%rip), %rdx    # 0x1f3884
movl $0x75f, %ecx            # imm = 0x75F
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x824(%rsp)
jmp 0xbaaf7
movq 0x810(%rsp), %rax
movq 0x80(%rax), %rax
movq 0xc0(%rax), %rdi
callq 0x8420
jmp 0xbaa9f
movq 0x810(%rsp), %rax
movq 0x80(%rax), %rax
movq 0xc8(%rax), %rdi
callq 0x8420
movq 0x810(%rsp), %rax
movq 0x88(%rax), %rax
movq 0x38(%rax), %rdi
callq 0x8420
movq 0x810(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x8420
movq 0x810(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x8420
movq 0x810(%rsp), %rdi
callq 0x8420
movl $0x0, 0x824(%rsp)
movl 0x824(%rsp), %eax
addq $0x828, %rsp            # imm = 0x828
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, 0x1008(%rsp)
movq 0x1008(%rsp), %rax
movswl 0xb8(%rax), %eax
cmpl $0x1, %eax
jne 0xbabbf
movq 0x1008(%rsp), %rdi
callq 0x19f8a0
cmpl $0x1, %eax
jne 0xbabbd
leaq 0x800(%rsp), %rdi
movq 0x1008(%rsp), %rcx
addq $0xc0, %rcx
addq $0x570, %rcx            # imm = 0x570
leaq 0x11786a(%rip), %rsi    # 0x1d23d8
leaq 0x136ff0(%rip), %rdx    # 0x1f1b65
movb $0x0, %al
callq 0x5b9c0
movq 0x1008(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x800(%rsp), %r8
leaq 0x11749a(%rip), %rsi    # 0x1d2034
leaq 0x136fd8(%rip), %rdx    # 0x1f1b79
movl $0x1c1, %ecx            # imm = 0x1C1
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1014(%rsp)
jmp 0xbac9d
jmp 0xbabbf
movq 0x1008(%rsp), %rax
movq 0xf10(%rax), %rdi
callq 0x8420
movq 0x1008(%rsp), %rax
movq 0xf18(%rax), %rdi
callq 0x8420
movq 0x1008(%rsp), %rax
movq 0xf20(%rax), %rdi
callq 0x8420
movq 0x1008(%rsp), %rax
movq 0xf28(%rax), %rdi
callq 0x8420
movq 0x1008(%rsp), %rdi
callq 0xbacb0
cmpl $0x1, %eax
jne 0xbac81
movq %rsp, %rdi
movq 0x1008(%rsp), %rcx
addq $0x1064, %rcx           # imm = 0x1064
leaq 0x11779e(%rip), %rsi    # 0x1d23d8
leaq 0x136f4c(%rip), %rdx    # 0x1f1b8d
movb $0x0, %al
callq 0x5b9c0
movq 0x1008(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
movq %rsp, %r8
leaq 0x1173d3(%rip), %rsi    # 0x1d2034
leaq 0x136f11(%rip), %rdx    # 0x1f1b79
movl $0x1cc, %ecx            # imm = 0x1CC
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1014(%rsp)
jmp 0xbac9d
movq 0x1008(%rsp), %rax
movw $0x0, 0x1864(%rax)
movl $0x0, 0x1014(%rsp)
movl 0x1014(%rsp), %eax
addq $0x1018, %rsp           # imm = 0x1018
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/thermodynamics.c
// Function: thermodynamics_free_input
int thermodynamics_free_input(
                        struct thermodynamics * pth
                        ) {

  switch(pth->reio_parametrization){

  case reio_none:
  case reio_camb:
  case reio_half_tanh:
  default:
    /* nothing to be read*/
    break;

  case reio_bins_tanh:
    /* Read */
    free(pth->binned_reio_z);
    free(pth->binned_reio_xe);
    break;

  case reio_many_tanh:
    /* Read */
    free(pth->many_tanh_z);
    free(pth->many_tanh_xe);
    break;

    /** 8.d) reionization parameters if reio_parametrization=reio_many_tanh */
  case reio_inter:
    /* Read */
    free(pth->reio_inter_z);
    free(pth->reio_inter_xe);
    break;

  }

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x5, %rax
ja 0xbace3
movq 0x8(%rsp), %rax
leaq 0x136928(%rip), %rcx    # 0x1f1600
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xbace3
jmp 0xbad49
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x8420
jmp 0xbad49
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x8420
jmp 0xbad49
movq 0x10(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x8420
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x838, %rsp            # imm = 0x838
movsd %xmm0, 0x828(%rsp)
movq %rdi, 0x820(%rsp)
movq %rsi, 0x818(%rsp)
movq %rdx, 0x810(%rsp)
movq 0x820(%rsp), %rax
movq %rax, 0x800(%rsp)
movq 0x800(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xf10(%rax), %rdi
movq 0x800(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xf08(%rax), %esi
movsd 0x828(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x810(%rsp), %rcx
leaq 0x80c(%rsp), %rdx
callq 0x2b730
cmpl $0x1, %eax
jne 0xbed49
movq %rsp, %rdi
movq 0x810(%rsp), %rcx
leaq 0x1136cf(%rip), %rsi    # 0x1d23d8
leaq 0x1354ac(%rip), %rdx    # 0x1f41bc
movb $0x0, %al
callq 0x5b9c0
movq 0x810(%rsp), %rdi
movq %rsp, %r8
leaq 0x11330b(%rip), %rsi    # 0x1d2034
leaq 0x1354e9(%rip), %rdx    # 0x1f4219
movl $0xb29, %ecx            # imm = 0xB29
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x834(%rsp)
jmp 0xbeda5
movq 0x800(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xf10(%rax), %rax
movl 0x80c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x800(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xf10(%rax), %rax
movslq 0x80c(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x818(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x0, 0x834(%rsp)
movl 0x834(%rsp), %eax
addq $0x838, %rsp            # imm = 0x838
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
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), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1048, %rsp           # imm = 0x1048
movq %rdi, 0x1038(%rsp)
movq %rsi, 0x1030(%rsp)
movl %edx, 0x102c(%rsp)
movl %ecx, 0x1028(%rsp)
movl %r8d, 0x1024(%rsp)
movsd %xmm0, 0x1018(%rsp)
movq %r9, 0x1010(%rsp)
movq 0x1038(%rsp), %rdi
movsd 0x1018(%rsp), %xmm0
leaq 0x1008(%rsp), %rsi
callq 0x9ee00
cmpl $0x1, %eax
jne 0xc7b8e
leaq 0x800(%rsp), %rdi
movq 0x1038(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x10a899(%rip), %rsi    # 0x1d23d8
leaq 0x12e21f(%rip), %rdx    # 0x1f5d65
movb $0x0, %al
callq 0x5b9c0
movq 0x1030(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
leaq 0x800(%rsp), %r8
leaq 0x10a4c9(%rip), %rsi    # 0x1d2034
leaq 0x12f044(%rip), %rdx    # 0x1f6bb6
movl $0x99, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1044(%rsp)
jmp 0xc7c31
movq 0x1030(%rsp), %rdi
movl 0x102c(%rsp), %esi
movl 0x1028(%rsp), %edx
movl 0x1024(%rsp), %ecx
movsd 0x1008(%rsp), %xmm0
movq 0x1010(%rsp), %r8
callq 0xc7720
cmpl $0x1, %eax
jne 0xc7c26
movq %rsp, %rdi
movq 0x1030(%rsp), %rcx
addq $0x6c8a, %rcx           # imm = 0x6C8A
leaq 0x10a7f9(%rip), %rsi    # 0x1d23d8
leaq 0x12efeb(%rip), %rdx    # 0x1f6bd1
movb $0x0, %al
callq 0x5b9c0
movq 0x1030(%rsp), %rdi
addq $0x6c8a, %rdi           # imm = 0x6C8A
movq %rsp, %r8
leaq 0x10a42e(%rip), %rsi    # 0x1d2034
leaq 0x12efa9(%rip), %rdx    # 0x1f6bb6
movl $0x9d, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1044(%rsp)
jmp 0xc7c31
movl $0x0, 0x1044(%rsp)
movl 0x1044(%rsp), %eax
addq $0x1048, %rsp           # imm = 0x1048
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x820(%rax)
je 0xd1af3
movq (%rsp), %rax
movq 0x820(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
cmpq $0x0, 0x828(%rax)
je 0xd1b11
movq (%rsp), %rax
movq 0x828(%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/../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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rax
movq 0x190(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
cmpl $0x0, 0x178(%rax)
jle 0xd76d5
movq (%rsp), %rax
movq 0x180(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movswl 0xe(%rax), %eax
cmpl $0x1, %eax
jne 0xd7753
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x848(%rcx), %eax
jne 0xd7753
movq 0x10(%rsp), %rax
movswl 0x34(%rax), %eax
cmpl $0x1, %eax
je 0xd7721
movq 0x10(%rsp), %rax
movswl 0x36(%rax), %eax
cmpl $0x1, %eax
je 0xd7721
movq 0x10(%rsp), %rax
movswl 0x87c(%rax), %eax
cmpl $0x1, %eax
jne 0xd7751
movq (%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xf0(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xf8(%rax), %rdi
callq 0x8420
jmp 0xd7753
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0xc0(%rax)
je 0xf8cd3
movq (%rsp), %rax
movq 0xc0(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
cmpq $0x0, 0xc8(%rax)
je 0xf8cf1
movq (%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xf0(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xf8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x100(%rax), %rdi
callq 0x8420
movq (%rsp), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x290(%rax)
jle 0x1160eb
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x115ff3
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x278(%rcx), %eax
jge 0x115fbe
movq 0x10(%rsp), %rax
movq 0x2b8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2c0(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2c8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x115f52
movq 0x10(%rsp), %rax
movq 0x2b8(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2c0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2c8(%rax), %rdi
callq 0x8420
jmp 0x116011
movq 0x10(%rsp), %rax
cmpl $0x5, 0x18(%rax)
jne 0x11600f
movq 0x10(%rsp), %rax
movq 0x220(%rax), %rdi
callq 0x8420
jmp 0x116011
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x278(%rcx), %eax
jge 0x116085
movq 0x10(%rsp), %rax
movq 0x2a0(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2a8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2b0(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x116019
movq 0x10(%rsp), %rax
movq 0x2a0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2a8(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x2b0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x280(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x288(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x298(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movw $0x0, 0xb48(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/primordial.c
// Function: primordial_inflation_indices
int primordial_inflation_indices(
                                 struct primordial * ppm
                                 ) {

  int index_in;

  index_in = 0;

  /* indices for background quantities */
  ppm->index_in_a = index_in;
  index_in ++;
  ppm->index_in_phi = index_in;
  index_in ++;
  if ((ppm->primordial_spec_type == inflation_V) || (ppm->primordial_spec_type == inflation_V_end)) {
    ppm->index_in_dphi = index_in;
    index_in ++;
  }

  /* size of background vector */
  ppm->in_bg_size = index_in;

  /* indices for perturbations */
  ppm->index_in_ksi_re = index_in;
  index_in ++;
  ppm->index_in_ksi_im = index_in;
  index_in ++;
  ppm->index_in_dksi_re = index_in;
  index_in ++;
  ppm->index_in_dksi_im = index_in;
  index_in ++;
  ppm->index_in_ah_re = index_in;
  index_in ++;
  ppm->index_in_ah_im = index_in;
  index_in ++;
  ppm->index_in_dah_re = index_in;
  index_in ++;
  ppm->index_in_dah_im = index_in;
  index_in ++;

  /* size of perturbation vector */
  ppm->in_size = index_in;

  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2d0(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2d4(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x116157
movq -0x8(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x116171
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2d8(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2fc(%rax)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2dc(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2e0(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2e4(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2e8(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2ec(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2f0(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2f4(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x2f8(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x300(%rax)
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rdi
leaq 0xde9e4(%rip), %rsi     # 0x1ff591
callq 0x8660
movq (%rsp), %rdi
leaq 0xd0181(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq (%rsp), %rdi
leaq 0xde9ce(%rip), %rsi     # 0x1ff59b
callq 0x8660
movq (%rsp), %rdi
leaq 0xd0161(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq 0x10(%rsp), %rax
movswl 0x12(%rax), %eax
cmpl $0x1, %eax
jne 0x120c10
movq (%rsp), %rdi
leaq 0xde9ac(%rip), %rsi     # 0x1ff5a7
callq 0x8660
movq (%rsp), %rdi
leaq 0xd0133(%rip), %rsi     # 0x1f0d3e
callq 0x8660
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x290(%rcx), %eax
jge 0x120d58
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
imull 0x24(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x298(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movq 0x2a0(%rax), %rax
movq 0x30(%rsp), %rcx
movslq 0x848(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movswl 0x12(%rax), %eax
cmpl $0x1, %eax
jne 0x120d46
movq 0x28(%rsp), %rax
movq 0x2a0(%rax), %rax
movq 0x30(%rsp), %rcx
movslq 0x84c(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x120d48
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x120c3f
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, 0x1028(%rsp)
movq %rsi, 0x1020(%rsp)
movq %rdx, 0x1018(%rsp)
movq %rcx, 0x1010(%rsp)
movq 0x1028(%rsp), %rdi
movq 0x1020(%rsp), %rsi
movq 0x1018(%rsp), %rdx
movq 0x1010(%rsp), %rcx
callq 0x1c09b0
cmpl $0x1, %eax
jne 0x12e39e
leaq 0x810(%rsp), %rdi
movq 0x1010(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xa4089(%rip), %rsi     # 0x1d23d8
leaq 0xd400c(%rip), %rdx     # 0x202362
movb $0x0, %al
callq 0x5b9c0
movq 0x1010(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x810(%rsp), %r8
leaq 0xa3cb9(%rip), %rsi     # 0x1d2034
leaq 0xd4002(%rip), %rdx     # 0x202384
movl $0xa44, %ecx            # imm = 0xA44
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1034(%rsp)
jmp 0x12e48f
movq 0x1010(%rsp), %rax
cmpl $0x1, 0x90(%rax)
jle 0x12e484
movq 0x1010(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x1010(%rsp), %rax
movl 0x90(%rax), %esi
movq 0x1010(%rsp), %rax
movq 0x130(%rax), %rdx
movq 0x1010(%rsp), %rax
movl 0x104(%rax), %ecx
movq 0x1010(%rsp), %rax
movq 0x138(%rax), %r8
movq 0x1010(%rsp), %rax
addq $0x192, %rax            # imm = 0x192
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x1cf90
cmpl $0x1, %eax
jne 0x12e482
leaq 0x10(%rsp), %rdi
movq 0x1010(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xa3f9f(%rip), %rsi     # 0x1d23d8
leaq 0xd3f56(%rip), %rdx     # 0x202396
movb $0x0, %al
callq 0x5b9c0
movq 0x1010(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x10(%rsp), %r8
leaq 0xa3bd2(%rip), %rsi     # 0x1d2034
leaq 0xd3f1b(%rip), %rdx     # 0x202384
movl $0xa50, %ecx            # imm = 0xA50
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1034(%rsp)
jmp 0x12e48f
jmp 0x12e484
movl $0x0, 0x1034(%rsp)
movl 0x1034(%rsp), %eax
addq $0x1038, %rsp           # imm = 0x1038
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8a4(%rcx), %eax
jge 0x1376fd
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
movq 0x870(%rcx), %rcx
movslq 0xc(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x1376da
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x20(%rsp), %rcx
movq 0x998(%rcx), %rcx
movslq 0xc(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x1376c8
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rdx
movq 0x998(%rdx), %rdx
movslq 0xc(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x13766a
jmp 0x1376ca
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x137648
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x13762b
movq 0x10(%rsp), %rdi
callq 0x8420
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_free_source_correspondence
int transfer_free_source_correspondence(
                                        struct transfer * ptr,
                                        int ** tp_of_tt
                                        ) {

  int index_md;

  for (index_md = 0; index_md < ptr->md_size; index_md++) {
    free(tp_of_tt[index_md]);
  }
  free(tp_of_tt);

  return _SUCCESS_;

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8a4(%rcx), %eax
jge 0x1379c7
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x137996
movq 0x8(%rsp), %rdi
callq 0x8420
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_lensing_sampling
int transfer_lensing_sampling(
                              struct precision * ppr,
                              struct background * pba,
                              struct perturbations * ppt,
                              struct transfer * ptr,
                              int bin,
                              double tau0,
                              double * tau0_minus_tau,
                              int tau_size) {

  /* running index on time */
  int index_tau;

  /* minimum and maximal value of time in new sampled interval */
  double tau_min,tau_mean,tau_max;

  /* time interval for this bin */
  class_call(transfer_selection_times(ppr,
                                      pba,
                                      ppt,
                                      ptr,
                                      bin,
                                      &tau_min,
                                      &tau_mean,
                                      &tau_max),
             ptr->error_message,
             ptr->error_message);

  for (index_tau=0; index_tau<tau_size; index_tau++) {
    //tau0_minus_tau[index_tau]=pba->conformal_age-tau_min-((double)index_tau)/((double)tau_size-1.)*(tau0-tau_min);
    tau0_minus_tau[index_tau]=((double)(tau_size-1-index_tau))/((double)(tau_size-1))*(tau0-tau_min);
  }

  return _SUCCESS_;

}

// Assembly:
subq $0x878, %rsp            # imm = 0x878
movl 0x880(%rsp), %eax
movq %rdi, 0x868(%rsp)
movq %rsi, 0x860(%rsp)
movq %rdx, 0x858(%rsp)
movq %rcx, 0x850(%rsp)
movl %r8d, 0x84c(%rsp)
movsd %xmm0, 0x840(%rsp)
movq %r9, 0x838(%rsp)
movq 0x868(%rsp), %rdi
movq 0x860(%rsp), %rsi
movq 0x858(%rsp), %rdx
movq 0x850(%rsp), %rcx
movl 0x84c(%rsp), %r8d
leaq 0x828(%rsp), %r9
leaq 0x820(%rsp), %r10
leaq 0x818(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x13c9b0
cmpl $0x1, %eax
jne 0x141a31
leaq 0x10(%rsp), %rdi
movq 0x850(%rsp), %rcx
addq $0x96a, %rcx            # imm = 0x96A
leaq 0x909f3(%rip), %rsi     # 0x1d23d8
leaq 0xc1be4(%rip), %rdx     # 0x2035d0
movb $0x0, %al
callq 0x5b9c0
movq 0x850(%rsp), %rdi
addq $0x96a, %rdi            # imm = 0x96A
leaq 0x10(%rsp), %r8
leaq 0x90626(%rip), %rsi     # 0x1d2034
leaq 0xc2519(%rip), %rdx     # 0x203f2e
movl $0xb6d, %ecx            # imm = 0xB6D
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x874(%rsp)
jmp 0x141abc
movl $0x0, 0x834(%rsp)
movl 0x834(%rsp), %eax
cmpl 0x880(%rsp), %eax
jge 0x141ab1
movl 0x880(%rsp), %eax
subl $0x1, %eax
subl 0x834(%rsp), %eax
cvtsi2sd %eax, %xmm0
movl 0x880(%rsp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd 0x840(%rsp), %xmm1
subsd 0x828(%rsp), %xmm1
mulsd %xmm1, %xmm0
movq 0x838(%rsp), %rax
movslq 0x834(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x834(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x834(%rsp)
jmp 0x141a3c
movl $0x0, 0x874(%rsp)
movl 0x874(%rsp), %eax
addq $0x878, %rsp            # imm = 0x878
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_dNdz_analytic
int transfer_dNdz_analytic(
                           struct transfer * ptr,
                           double z,
                           double * dNdz,
                           double * dln_dNdz_dz) {

  /* Implement here your favorite analytic ansatz for the selection
     function. Typical function for photometric sample: dN/dz =
     (z/z0)^alpha exp[-(z/z0)^beta]. Then: dln(dN/dz)/dz = (alpha -
     beta*(z/z0)^beta)/z. In principle, one is free to use different
     ansatz for the selection function and the evolution
     function. Since the selection function uses only dN/dz, while the
     evolution uses only dln(dN/dz)/dz, it is possible to use
     different functions for dN/dz and dln(dN/dz)/dz */

  double z0,alpha,beta;

  //Euclid IST dNdz, do not change this!
  z0 = 0.9/pow(2.,1./2.);
  alpha = 2.0;
  beta = 1.5;

  *dNdz = pow(z/z0,alpha) * exp(-pow(z/z0,beta));

  *dln_dNdz_dz = (alpha - pow(z/z0,beta)*beta)/z;

  return _SUCCESS_;

}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movsd 0x90a3f(%rip), %xmm0    # 0x1d2c80
movsd 0x90a3f(%rip), %xmm1    # 0x1d2c88
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x8ffff(%rip), %xmm0    # 0x1d2258
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x90a15(%rip), %xmm0    # 0x1d2c80
movsd %xmm0, 0x18(%rsp)
movsd 0x909d7(%rip), %xmm0    # 0x1d2c50
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8610
movsd %xmm0, (%rsp)
movsd 0x38(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x8610
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x8610
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd 0x38(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/transfer.c
// Function: transfer_workspace_free
int transfer_workspace_free(
                            struct transfer * ptr,
                            struct transfer_workspace *ptw
                            ) {

  if (ptw->HIS_allocated==_TRUE_){
    //Free HIS structure:
    class_call(hyperspherical_HIS_free(&(ptw->HIS),ptr->error_message),
               ptr->error_message,
               ptr->error_message);
  }
  free(ptw->interpolated_sources);
  free(ptw->sources);
  free(ptw->tau0_minus_tau);
  free(ptw->w_trapz);
  free(ptw->chi);
  free(ptw->cscKgen);
  free(ptw->cotKgen);

  return _SUCCESS_;
}

// Assembly:
subq $0x818, %rsp            # imm = 0x818
movq %rdi, 0x808(%rsp)
movq %rsi, 0x800(%rsp)
movq 0x800(%rsp), %rax
cmpl $0x1, 0x60(%rax)
jne 0x147cff
movq 0x800(%rsp), %rdi
movq 0x808(%rsp), %rsi
addq $0x96a, %rsi            # imm = 0x96A
callq 0x402f0
cmpl $0x1, %eax
jne 0x147cfd
movq %rsp, %rdi
movq 0x808(%rsp), %rcx
addq $0x96a, %rcx            # imm = 0x96A
leaq 0x8a725(%rip), %rsi     # 0x1d23d8
leaq 0xbd25d(%rip), %rdx     # 0x204f17
movb $0x0, %al
callq 0x5b9c0
movq 0x808(%rsp), %rdi
addq $0x96a, %rdi            # imm = 0x96A
movq %rsp, %r8
leaq 0x8a35a(%rip), %rsi     # 0x1d2034
leaq 0xbd26e(%rip), %rdx     # 0x204f4f
movl $0x11c1, %ecx           # imm = 0x11C1
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x814(%rsp)
jmp 0x147d96
jmp 0x147cff
movq 0x800(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x8420
movq 0x800(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x8420
movq 0x800(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x8420
movq 0x800(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x8420
movq 0x800(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x8420
movq 0x800(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x8420
movq 0x800(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x8420
movl $0x0, 0x814(%rsp)
movl 0x814(%rsp), %eax
addq $0x818, %rsp            # imm = 0x818
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_free
int harmonic_free(
                  struct harmonic * phr
                  ) {

  int index_md;

  if (phr->md_size > 0) {
    if (phr->ct_size > 0) {

      for (index_md = 0; index_md < phr->md_size; index_md++) {
        free(phr->l_max_ct[index_md]);
        free(phr->cl[index_md]);
        free(phr->ddcl[index_md]);
      }
      free(phr->l);
      free(phr->l_size);
      free(phr->l_max_ct);
      free(phr->l_max);
      free(phr->cl);
      free(phr->ddcl);
    }

    for (index_md=0; index_md < phr->md_size; index_md++)
      free(phr->is_non_zero[index_md]);

    free(phr->is_non_zero);
    free(phr->ic_size);
    free(phr->ic_ic_size);

  }
  phr->is_allocated = _FALSE_;

  return _SUCCESS_;

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x14fb05
movq 0x10(%rsp), %rax
cmpl $0x0, 0x9c(%rax)
jle 0x14faa1
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x14fa3b
movq 0x10(%rsp), %rax
movq 0xb8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x14f9d2
movq 0x10(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xb8(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rdi
callq 0x8420
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x14fadb
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x14faa9
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movw $0x0, 0x8ea(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_at_z
int harmonic_pk_at_z(
                     struct background * pba,
                     struct harmonic * phr,
                     enum linear_or_logarithmic mode,
                     double z,
                     double * output_tot,    /* array with argument output_tot[index_k] (must be already allocated) */
                     double * output_ic,     /* array with argument output_tot[index_k * phr->ic_ic_size[index_md] + index_ic1_ic2] (must be already allocated only if more than one initial condition) */
                     double * output_cb_tot, /* same as output_tot for the baryon+CDM only */
                     double * output_cb_ic   /* same as output_ic  for the baryon+CDM only */
                     ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_at_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_z() instead.\n");

  class_call(fourier_pks_at_z(
                              pba,
                              phr->pfo,
                              mode,
                              pk_linear,
                              z,
                              output_tot,
                              output_ic,
                              output_cb_tot,
                              output_cb_ic
                              ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
subq $0x858, %rsp            # imm = 0x858
movq 0x860(%rsp), %rax
movq %rdi, 0x848(%rsp)
movq %rsi, 0x840(%rsp)
movl %edx, 0x83c(%rsp)
movsd %xmm0, 0x830(%rsp)
movq %rcx, 0x828(%rsp)
movq %r8, 0x820(%rsp)
movq %r9, 0x818(%rsp)
movq 0xf1a42(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0xb3cf0(%rip), %rsi     # 0x206288
movb $0x0, %al
callq 0x84e0
movq 0x848(%rsp), %rdi
movq 0x840(%rsp), %rax
movq 0xe0(%rax), %rsi
movl 0x83c(%rsp), %edx
movsd 0x830(%rsp), %xmm0
movq 0x828(%rsp), %r8
movq 0x820(%rsp), %r9
movq 0x818(%rsp), %r10
movq 0x860(%rsp), %rax
xorl %ecx, %ecx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x124f50
cmpl $0x1, %eax
jne 0x152666
leaq 0x10(%rsp), %rdi
movq 0x840(%rsp), %rax
movq 0xe0(%rax), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0x7fdbb(%rip), %rsi     # 0x1d23d8
leaq 0xb3cfc(%rip), %rdx     # 0x206320
movb $0x0, %al
callq 0x5b9c0
movq 0x840(%rsp), %rdi
addq $0xea, %rdi
leaq 0x10(%rsp), %r8
leaq 0x7f9ee(%rip), %rsi     # 0x1d2034
leaq 0xb3d3d(%rip), %rdx     # 0x20638a
movl $0x571, %ecx            # imm = 0x571
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x854(%rsp)
jmp 0x152671
movl $0x0, 0x854(%rsp)
movl 0x854(%rsp), %eax
addq $0x858, %rsp            # imm = 0x858
retq
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_at_k_and_z
int harmonic_pk_at_k_and_z(
                           struct background * pba,
                           struct primordial * ppm,
                           struct harmonic * phr,
                           double k,
                           double z,
                           double * pk_tot,    /* pointer to a single number (must be already allocated) */
                           double * pk_ic,     /* array of argument pk_ic[index_ic1_ic2]
                                                  (must be already allocated only if several initial conditions) */
                           double * pk_cb_tot, /* same as pk_tot for baryon+CDM part only */
                           double * pk_cb_ic   /* same as pk_ic  for baryon+CDM part only */
                           ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_at_k_and_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_linear_at_k_and_z() instead.\n");

  class_call(fourier_pks_at_k_and_z(pba,
                                    ppm,
                                    phr->pfo,
                                    pk_linear,
                                    k,
                                    z,
                                    pk_tot,
                                    pk_ic,
                                    pk_cb_tot,
                                    pk_cb_ic),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;
}

// Assembly:
subq $0x858, %rsp            # imm = 0x858
movq 0x860(%rsp), %rax
movq %rdi, 0x848(%rsp)
movq %rsi, 0x840(%rsp)
movq %rdx, 0x838(%rsp)
movsd %xmm0, 0x830(%rsp)
movsd %xmm1, 0x828(%rsp)
movq %rcx, 0x820(%rsp)
movq %r8, 0x818(%rsp)
movq %r9, 0x810(%rsp)
movq 0xf18f8(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0xb3cb9(%rip), %rsi     # 0x20639b
movb $0x0, %al
callq 0x84e0
movq 0x848(%rsp), %rdi
movq 0x840(%rsp), %rsi
movq 0x838(%rsp), %rax
movq 0xe0(%rax), %rdx
movsd 0x830(%rsp), %xmm0
movsd 0x828(%rsp), %xmm1
movq 0x820(%rsp), %r8
movq 0x818(%rsp), %r9
movq 0x810(%rsp), %r10
movq 0x860(%rsp), %rax
xorl %ecx, %ecx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1264f0
cmpl $0x1, %eax
jne 0x1527ba
leaq 0x10(%rsp), %rdi
movq 0x838(%rsp), %rax
movq 0xe0(%rax), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0x7fc67(%rip), %rsi     # 0x1d23d8
leaq 0xb3cce(%rip), %rdx     # 0x206446
movb $0x0, %al
callq 0x5b9c0
movq 0x838(%rsp), %rdi
addq $0xea, %rdi
leaq 0x10(%rsp), %r8
leaq 0x7f89a(%rip), %rsi     # 0x1d2034
leaq 0xb3d05(%rip), %rdx     # 0x2064a6
movl $0x5a2, %ecx            # imm = 0x5A2
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x854(%rsp)
jmp 0x1527c5
movl $0x0, 0x854(%rsp)
movl 0x854(%rsp), %eax
addq $0x858, %rsp            # imm = 0x858
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_nl_at_z
int harmonic_pk_nl_at_z(
                        struct background * pba,
                        struct harmonic * phr,
                        enum linear_or_logarithmic mode,
                        double z,
                        double * output_tot,   /* array with argument output_tot[index_k] (must be already allocated) */
                        double * output_cb_tot
                        ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_nl_at_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_z() instead.\n");

  class_call(fourier_pks_at_z(pba,
                              phr->pfo,
                              mode,
                              pk_nonlinear,
                              z,
                              output_tot,
                              NULL,
                              output_cb_tot,
                              NULL
                              ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
subq $0x848, %rsp            # imm = 0x848
movq %rdi, 0x838(%rsp)
movq %rsi, 0x830(%rsp)
movl %edx, 0x82c(%rsp)
movsd %xmm0, 0x820(%rsp)
movq %rcx, 0x818(%rsp)
movq %r8, 0x810(%rsp)
movq 0xf17b2(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0xb3c95(%rip), %rsi     # 0x2064bd
movb $0x0, %al
callq 0x84e0
movq 0x838(%rsp), %rdi
movq 0x830(%rsp), %rax
movq 0xe0(%rax), %rsi
movl 0x82c(%rsp), %edx
movsd 0x820(%rsp), %xmm0
movq 0x818(%rsp), %r8
movq 0x810(%rsp), %rax
movl $0x1, %ecx
xorl %r9d, %r9d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x124f50
cmpl $0x1, %eax
jne 0x1528f0
leaq 0x10(%rsp), %rdi
movq 0x830(%rsp), %rax
movq 0xe0(%rax), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0x7fb31(%rip), %rsi     # 0x1d23d8
leaq 0xb3caa(%rip), %rdx     # 0x206558
movb $0x0, %al
callq 0x5b9c0
movq 0x830(%rsp), %rdi
addq $0xea, %rdi
leaq 0x10(%rsp), %r8
leaq 0x7f764(%rip), %rsi     # 0x1d2034
leaq 0xb3ce4(%rip), %rdx     # 0x2065bb
movl $0x5cb, %ecx            # imm = 0x5CB
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x844(%rsp)
jmp 0x1528fb
movl $0x0, 0x844(%rsp)
movl 0x844(%rsp), %eax
addq $0x848, %rsp            # imm = 0x848
retq
nopw (%rax,%rax)