LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_nl_at_k_and_z
int harmonic_pk_nl_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_cb_tot /* same as pk_tot for baryon+CDM only */
                              ) {

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

  class_call(fourier_pks_at_k_and_z(pba,
                                    ppm,
                                    phr->pfo,
                                    pk_nonlinear,
                                    k,
                                    z,
                                    pk_tot,
                                    NULL,
                                    pk_cb_tot,
                                    NULL
                                    ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
subq $0x858, %rsp            # imm = 0x858
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 0xf1678(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0xb3c6d(%rip), %rsi     # 0x2065cf
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), %rax
movl $0x1, %ecx
xorl %r9d, %r9d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x1264f0
cmpl $0x1, %eax
jne 0x152a34
leaq 0x10(%rsp), %rdi
movq 0x838(%rsp), %rax
movq 0xe0(%rax), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0x7f9ed(%rip), %rsi     # 0x1d23d8
leaq 0xb3c84(%rip), %rdx     # 0x206676
movb $0x0, %al
callq 0x5b9c0
movq 0x838(%rsp), %rdi
addq $0xea, %rdi
leaq 0x10(%rsp), %r8
leaq 0x7f620(%rip), %rsi     # 0x1d2034
leaq 0xb3cbe(%rip), %rdx     # 0x2066d9
movl $0x5f8, %ecx            # imm = 0x5F8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x854(%rsp)
jmp 0x152a3f
movl $0x0, 0x854(%rsp)
movl 0x854(%rsp), %eax
addq $0x858, %rsp            # imm = 0x858
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_sigma
int harmonic_sigma(
                   struct background * pba,
                   struct primordial * ppm,
                   struct harmonic * phr,
                   double R,
                   double z,
                   double * sigma
                   ) {

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

  if (phr->pfo->has_pk_m) {

    class_call(fourier_sigma_at_z(pba,
                                  phr->pfo,
                                  R,
                                  z,
                                  phr->pfo->index_pk_m,
                                  80., // hardcoded, yes, but the function is deprecated...
                                  sigma),
               phr->pfo->error_message,
               phr->error_message);

  }

  return _SUCCESS_;
}

// Assembly:
subq $0x838, %rsp            # imm = 0x838
movq %rdi, 0x828(%rsp)
movq %rsi, 0x820(%rsp)
movq %rdx, 0x818(%rsp)
movsd %xmm0, 0x810(%rsp)
movsd %xmm1, 0x808(%rsp)
movq %rcx, 0x800(%rsp)
movq 0xf13c0(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0xb3c26(%rip), %rsi     # 0x206840
movb $0x0, %al
callq 0x84e0
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rax
cmpw $0x0, 0x50(%rax)
je 0x152cf9
movq 0x828(%rsp), %rdi
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rsi
movsd 0x810(%rsp), %xmm0
movsd 0x808(%rsp), %xmm1
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rax
movl 0x54(%rax), %edx
movq 0x800(%rsp), %rcx
movsd 0x8385a(%rip), %xmm2    # 0x1d64e0
callq 0x12f7f0
cmpl $0x1, %eax
jne 0x152cf7
movq %rsp, %rdi
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0x7f728(%rip), %rsi     # 0x1d23d8
leaq 0xb3c23(%rip), %rdx     # 0x2068da
movb $0x0, %al
callq 0x5b9c0
movq 0x818(%rsp), %rdi
addq $0xea, %rdi
movq %rsp, %r8
leaq 0x7f35d(%rip), %rsi     # 0x1d2034
leaq 0xb3c46(%rip), %rdx     # 0x206924
movl $0x65b, %ecx            # imm = 0x65B
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x834(%rsp)
jmp 0x152d04
jmp 0x152cf9
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/harmonic.c
// Function: harmonic_sigma_cb
int harmonic_sigma_cb(
                      struct background * pba,
                      struct primordial * ppm,
                      struct harmonic * phr,
                      double R,
                      double z,
                      double * sigma_cb
                      ) {

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

  if (phr->pfo->has_pk_cb) {

    class_call(fourier_sigma_at_z(pba,
                                  phr->pfo,
                                  R,
                                  z,
                                  phr->pfo->index_pk_cb,
                                  80., // hardcoded, yes, but the function is deprecated...
                                  sigma_cb),
               phr->pfo->error_message,
               phr->error_message);
  }

  return _SUCCESS_;
}

// Assembly:
subq $0x838, %rsp            # imm = 0x838
movq %rdi, 0x828(%rsp)
movq %rsi, 0x820(%rsp)
movq %rdx, 0x818(%rsp)
movsd %xmm0, 0x810(%rsp)
movsd %xmm1, 0x808(%rsp)
movq %rcx, 0x800(%rsp)
movq 0xf1270(%rip), %rax     # 0x243fd0
movq (%rax), %rdi
leaq 0xb3bc9(%rip), %rsi     # 0x206933
movb $0x0, %al
callq 0x84e0
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rax
cmpw $0x0, 0x52(%rax)
je 0x152e49
movq 0x828(%rsp), %rdi
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rsi
movsd 0x810(%rsp), %xmm0
movsd 0x808(%rsp), %xmm1
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rax
movl 0x58(%rax), %edx
movq 0x800(%rsp), %rcx
movsd 0x8370a(%rip), %xmm2    # 0x1d64e0
callq 0x12f7f0
cmpl $0x1, %eax
jne 0x152e47
movq %rsp, %rdi
movq 0x818(%rsp), %rax
movq 0xe0(%rax), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0x7f5d8(%rip), %rsi     # 0x1d23d8
leaq 0xb3bc9(%rip), %rdx     # 0x2069d0
movb $0x0, %al
callq 0x5b9c0
movq 0x818(%rsp), %rdi
addq $0xea, %rdi
movq %rsp, %r8
leaq 0x7f20d(%rip), %rsi     # 0x1d2034
leaq 0xb3bf0(%rip), %rdx     # 0x206a1e
movl $0x686, %ecx            # imm = 0x686
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x834(%rsp)
jmp 0x152e54
jmp 0x152e49
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/lensing.c
// Function: lensing_lensed_cl_tt
int lensing_lensed_cl_tt(
                         double *ksi,
                         double **d00,
                         double *w8,
                         int nmu,
                         struct lensing * ple
                         ) {

  int index_l;

  /** Integration by Gauss-Legendre quadrature. **/
  class_setup_parallel();

  for (index_l=0; index_l<ple->l_size; index_l++){
    class_run_parallel(=,
      double cle;
      int imu;
      cle=0;
      for (imu=0;imu<nmu;imu++) {
        cle += ksi[imu]*d00[imu][(int)ple->l[index_l]]*w8[imu]; /* loop could be optimized */
      }
      ple->cl_lens[index_l*ple->lt_size+ple->index_lt_tt]=cle*2.0*_PI_;
      return _SUCCESS_;
    );
  }

  class_finish_parallel();

  return _SUCCESS_;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movl %ecx, 0xe4(%rsp)
movq %r8, 0xd8(%rsp)
callq 0x2edc0
movl %eax, %esi
leaq 0x90(%rsp), %rdi
callq 0x2ef50
leaq 0x78(%rsp), %rdi
callq 0x2f070
movl $0x0, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
movq 0xd8(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x15ffa3
movl 0xe4(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0xd4(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x160760
jmp 0x15ff42
leaq 0x78(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2f080
jmp 0x15ff53
leaq 0x68(%rsp), %rdi
callq 0x2f0b0
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0x15fec7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x16006c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2f0b0
jmp 0x16006c
leaq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2f0c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2f0f0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2f120
testb $0x1, %al
jne 0x15ffe0
jmp 0x160029
leaq 0x18(%rsp), %rdi
callq 0x2f160
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2f170
movl %eax, (%rsp)
jmp 0x15fffe
movl (%rsp), %eax
cmpl $0x0, %eax
je 0x16001b
movl $0x1, 0x104(%rsp)
movl $0x1, 0x4(%rsp)
jmp 0x160046
jmp 0x16001d
leaq 0x18(%rsp), %rdi
callq 0x2f1f0
jmp 0x15ffcb
leaq 0x78(%rsp), %rdi
callq 0x2f210
movl $0x0, 0x104(%rsp)
movl $0x1, 0x4(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2f230
leaq 0x90(%rsp), %rdi
callq 0x2f290
movl 0x104(%rsp), %eax
addq $0x108, %rsp            # imm = 0x108
retq
leaq 0x78(%rsp), %rdi
callq 0x2f230
leaq 0x90(%rsp), %rdi
callq 0x2f290
movq 0x30(%rsp), %rdi
callq 0x8640
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_addback_cl_tt
int lensing_addback_cl_tt(
                          struct lensing * ple,
                          double *cl_tt) {
  int index_l, l;

  for (index_l=0; index_l<ple->l_size; index_l++) {
    l = (int)ple->l[index_l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_tt] += cl_tt[l];
  }
  return _SUCCESS_;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x16010e
movq -0x8(%rsp), %rax
movq 0x70(%rax), %rax
movslq -0x14(%rsp), %rcx
cvttsd2si (%rax,%rcx,8), %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rdx
imull 0x54(%rdx), %ecx
movq -0x8(%rsp), %rdx
addl 0x2c(%rdx), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1600a2
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_lensed_cl_te
int lensing_lensed_cl_te(
                         double *ksiX,
                         double **d20,
                         double *w8,
                         int nmu,
                         struct lensing * ple
                         ) {

  int index_l;

  /** Integration by Gauss-Legendre quadrature. **/
  class_setup_parallel();

  for (index_l=0; index_l < ple->l_size; index_l++){
    class_run_parallel(=,
      double clte;
      int imu;
      clte=0;
      for (imu=0;imu<nmu;imu++) {
        clte += ksiX[imu]*d20[imu][(int)ple->l[index_l]]*w8[imu]; /* loop could be optimized */
      }
      ple->cl_lens[index_l*ple->lt_size+ple->index_lt_te]=clte*2.0*_PI_;
      return _SUCCESS_;
    );
  }

  class_finish_parallel();
  return _SUCCESS_;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movl %ecx, 0xe4(%rsp)
movq %r8, 0xd8(%rsp)
callq 0x2edc0
movl %eax, %esi
leaq 0x90(%rsp), %rdi
callq 0x2ef50
leaq 0x78(%rsp), %rdi
callq 0x2f070
movl $0x0, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
movq 0xd8(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x160253
movl 0xe4(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0xd4(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x160920
jmp 0x1601f2
leaq 0x78(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2f080
jmp 0x160203
leaq 0x68(%rsp), %rdi
callq 0x2f0b0
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0x160177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x16031c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2f0b0
jmp 0x16031c
leaq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2f0c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2f0f0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2f120
testb $0x1, %al
jne 0x160290
jmp 0x1602d9
leaq 0x18(%rsp), %rdi
callq 0x2f160
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2f170
movl %eax, (%rsp)
jmp 0x1602ae
movl (%rsp), %eax
cmpl $0x0, %eax
je 0x1602cb
movl $0x1, 0x104(%rsp)
movl $0x1, 0x4(%rsp)
jmp 0x1602f6
jmp 0x1602cd
leaq 0x18(%rsp), %rdi
callq 0x2f1f0
jmp 0x16027b
leaq 0x78(%rsp), %rdi
callq 0x2f210
movl $0x0, 0x104(%rsp)
movl $0x1, 0x4(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2f230
leaq 0x90(%rsp), %rdi
callq 0x2f290
movl 0x104(%rsp), %eax
addq $0x108, %rsp            # imm = 0x108
retq
leaq 0x78(%rsp), %rdi
callq 0x2f230
leaq 0x90(%rsp), %rdi
callq 0x2f290
movq 0x30(%rsp), %rdi
callq 0x8640
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_addback_cl_te
int lensing_addback_cl_te(
                          struct lensing * ple,
                          double *cl_te) {
  int index_l, l;

  for (index_l=0; index_l<ple->l_size; index_l++) {
    l = (int)ple->l[index_l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_te] += cl_te[l];
  }
  return _SUCCESS_;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x1603be
movq -0x8(%rsp), %rax
movq 0x70(%rax), %rax
movslq -0x14(%rsp), %rcx
cvttsd2si (%rax,%rcx,8), %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rdx
imull 0x54(%rdx), %ecx
movq -0x8(%rsp), %rdx
addl 0x34(%rdx), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x160352
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_addback_cl_ee_bb
int lensing_addback_cl_ee_bb(
                             struct lensing * ple,
                             double * cl_ee,
                             double * cl_bb) {

  int index_l, l;

  for (index_l=0; index_l<ple->l_size; index_l++) {
    l = (int)ple->l[index_l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_ee] += cl_ee[l];
    ple->cl_lens[index_l*ple->lt_size+ple->index_lt_bb] += cl_bb[l];
  }
  return _SUCCESS_;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x1606f4
movq -0x8(%rsp), %rax
movq 0x70(%rax), %rax
movslq -0x1c(%rsp), %rcx
cvttsd2si (%rax,%rcx,8), %eax
movl %eax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rsp), %ecx
movq -0x8(%rsp), %rdx
imull 0x54(%rdx), %ecx
movq -0x8(%rsp), %rdx
addl 0x30(%rdx), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rsp), %rax
movslq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rsp), %ecx
movq -0x8(%rsp), %rdx
imull 0x54(%rdx), %ecx
movq -0x8(%rsp), %rdx
addl 0x38(%rdx), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x160647
xorl %eax, %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/lensing.c
// Function: lensing_free
int lensing_free(
                 struct lensing * ple
                 ) {

  if (ple->has_lensed_cls == _TRUE_) {

    free(ple->l);
    free(ple->cl_lens);
    free(ple->ddcl_lens);
    free(ple->l_max_lt);

  }

  ple->is_allocated = _FALSE_;

  return _SUCCESS_;

}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movswl (%rax), %eax
cmpl $0x1, %eax
jne 0x160748
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movw $0x0, 0x892(%rax)
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_indices
int distortions_indices(struct distortions * psd) {

  /** Define local variables */
  int index_type = 0;

  /** Define indeces for tables - br_table defined in distortions_compute_branching_ratios,
      - sd_parameter_table and
      - sd_table defined in distortions_compute_spectral_shapes */
  class_define_index(psd->index_type_g,_TRUE_,index_type,1);
  class_define_index(psd->index_type_y,_TRUE_,index_type,1);
  class_define_index(psd->index_type_mu,_TRUE_,index_type,1);
  class_define_index(psd->index_type_PCA,_TRUE_,index_type,psd->sd_PCA_size);

  psd->type_size = index_type;

  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xbe0(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xbe8(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xbe4(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xbec(%rax)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xbf0(%rax)
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_free
int distortions_free(struct distortions * psd) {

  /** Define local variables */
  int index_type;

  if (psd->has_distortions == _TRUE_) {
    /** Delete lists */
    free(psd->z);
    free(psd->z_weights);
    free(psd->x);
    free(psd->x_weights);

    /** Delete noise file */
    if (psd->has_detector_file == _TRUE_) {
      free(psd->delta_Ic_array);
    }

    /** Delete branching ratios */
    for (index_type=0;index_type<psd->type_size;++index_type){
      free(psd->br_table[index_type]);
    }
    free(psd->br_table);

    /** Delete heating functions */
    free(psd->dQrho_dz_tot);

    /** Delete distortion shapes */
    for (index_type=0;index_type<psd->type_size;++index_type){
      free(psd->sd_shape_table[index_type]);
      free(psd->sd_table[index_type]);
    }
    free(psd->sd_shape_table);
    free(psd->sd_table);

    /** Delete distortion amplitudes */
    free(psd->sd_parameter_table);

    /** Delete total distortion */
    free(psd->DI);
  }
  psd->is_allocated = _FALSE_;

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x1, 0xcd0(%rax)
jne 0x1936ce
movq 0x10(%rsp), %rax
movq 0x340(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x348(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x370(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x378(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
cmpl $0x1, 0xcdc(%rax)
jne 0x1935ce
movq 0x10(%rsp), %rax
movq 0xcc8(%rax), %rdi
callq 0x8420
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xbf0(%rcx), %eax
jge 0x19360e
movq 0x10(%rsp), %rax
movq 0xbc0(%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 0x1935d6
movq 0x10(%rsp), %rax
movq 0xbc0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xc00(%rax), %rdi
callq 0x8420
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xbf0(%rcx), %eax
jge 0x19368a
movq 0x10(%rsp), %rax
movq 0xbd0(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xbd8(%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 0x193638
movq 0x10(%rsp), %rax
movq 0xbd0(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xbd8(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xbc8(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0xc10(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movw $0x0, 0x1e02(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_free_br_data
int distortions_free_br_data(struct distortions * psd){

  free(psd->br_exact_z);
  free(psd->f_g_exact);
  free(psd->ddf_g_exact);
  free(psd->f_y_exact);
  free(psd->ddf_y_exact);
  free(psd->f_mu_exact);
  free(psd->ddf_mu_exact);
  free(psd->E_vec);
  free(psd->ddE_vec);

  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0xc18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc28(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc30(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc38(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc40(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc48(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc50(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc58(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc60(%rax), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_free_sd_data
int distortions_free_sd_data(struct distortions * psd){

  free(psd->PCA_nu);
  free(psd->PCA_G_T);
  free(psd->ddPCA_G_T);
  free(psd->PCA_Y_SZ);
  free(psd->ddPCA_Y_SZ);
  free(psd->PCA_M_mu);
  free(psd->ddPCA_M_mu);
  free(psd->S_vec);
  free(psd->ddS_vec);

  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0xc70(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc80(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc88(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc90(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xc98(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xca0(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xca8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xcb0(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0xcb8(%rax), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_output_heat_titles
int distortions_output_heat_titles(struct distortions * psd,
                                   char titles[_MAXTITLESTRINGLENGTH_]){

  class_store_columntitle(titles,"Redshift z",_TRUE_);
  class_store_columntitle(titles,"Heat  [-]",_TRUE_);
  class_store_columntitle(titles,"LHeat [-]",_TRUE_);

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x72b08(%rip), %rsi     # 0x20c632
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x57203(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x72af1(%rip), %rsi     # 0x20c63d
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x571e1(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x72ad9(%rip), %rsi     # 0x20c647
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x571bf(%rip), %rsi     # 0x1f0d3e
callq 0x8660
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_output_heat_data
int distortions_output_heat_data(struct distortions * psd,
                                 int number_of_titles,
                                 double * data){
  int storeidx;
  double * dataptr;
  int index_z;

  for (index_z=0; index_z<psd->z_size; index_z++) {
    dataptr = data + index_z*number_of_titles;
    storeidx = 0;
    class_store_double(dataptr, psd->z[index_z], _TRUE_, storeidx);
    class_store_double(dataptr, psd->dQrho_dz_tot[index_z], _TRUE_, storeidx);
    class_store_double(dataptr, psd->dQrho_dz_tot[index_z]*(1.+psd->z[index_z]), _TRUE_, storeidx);
  }

  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x330(%rcx), %eax
jge 0x199ca2
movq -0x18(%rsp), %rax
movl -0x2c(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq 0x340(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0xc00(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0xc00(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq 0x340(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd 0x385d9(%rip), %xmm1    # 0x1d2248
addsd (%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x199ba6
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/distortions.c
// Function: distortions_output_sd_data
int distortions_output_sd_data(struct distortions * psd,
                               int number_of_titles,
                               double * data){
  int index_type;
  int storeidx;
  double * dataptr;
  int index_x;

  for (index_x=0; index_x<psd->x_size; index_x++) {
    dataptr = data + index_x*number_of_titles;
    storeidx = 0;

    class_store_double(dataptr, psd->x[index_x], _TRUE_,storeidx);
    class_store_double(dataptr, psd->x[index_x]*psd->x_to_nu, _TRUE_,storeidx);
    class_store_double(dataptr, psd->DI[index_x]*1.e26*psd->DI_units, _TRUE_,storeidx);
    for (index_type=0;index_type<psd->type_size;++index_type){
      class_store_double(dataptr, psd->sd_table[index_type][index_x]*1.e26*psd->DI_units, _TRUE_,storeidx);
    }
  }

  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x368(%rcx), %eax
jge 0x19a088
movq -0x18(%rsp), %rax
movl -0x2c(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq 0x370(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x20(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x370(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
mulsd 0x380(%rax), %xmm0
movq -0x28(%rsp), %rax
movl -0x20(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0xc10(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd 0x7055a(%rip), %xmm0    # 0x20a530
mulsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
mulsd 0x388(%rax), %xmm0
movq -0x28(%rsp), %rax
movl -0x20(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0xbf0(%rcx), %eax
jge 0x19a076
movq -0x8(%rsp), %rax
movq 0xbd8(%rax), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rsp), %rcx
movsd 0x704f3(%rip), %xmm0    # 0x20a530
mulsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
mulsd 0x388(%rax), %xmm0
movq -0x28(%rsp), %rax
movl -0x20(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x19a00a
jmp 0x19a078
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x199f16
xorl %eax, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/heating/injection.c
// Function: injection_free
int injection_free(struct thermodynamics* pth){

  /** - Define local variables */
  struct injection* pin = &(pth->in);
  int index_inj, index_dep;

  /* Redshift */
  free(pin->z_table);

  /* Energy injection */
  for(index_inj=0;index_inj<pin->inj_size;++index_inj){
    free(pin->injection_table[index_inj]);
  }
  free(pin->injection_table);

  if(pin->has_PBH_eva==_TRUE_){
    free(pin->PBH_table_z);
    free(pin->PBH_table_mass);
    free(pin->PBH_table_mass_dd);
    free(pin->PBH_table_F);
    free(pin->PBH_table_F_dd);
  }

  /* Injection efficiency */
  if(pin->f_eff_type == f_eff_from_file){
    free(pin->feff_table);
  }
  if(pin->chi_type == chi_from_z_file){
    free(pin->chiz_table);
  }
  if(pin->chi_type == chi_from_x_file || pin->chi_type == chi_Galli_file){
    free(pin->chix_table);
  }

  /* Deposition function */
  free(pin->chi);

  /* Energy deposition */
  for(index_dep=0;index_dep<pin->dep_size;++index_dep){
    free(pin->deposition_table[index_dep]);
  }
  free(pin->deposition_table);
  free(pin->pvecdeposition);

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0xc0, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x448(%rax), %rdi
callq 0x8420
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x4ec(%rcx), %eax
jge 0x19f90a
movq 0x8(%rsp), %rax
movq 0x4c8(%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 0x19f8d2
movq 0x8(%rsp), %rax
movq 0x4c8(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
cmpl $0x1, 0x564(%rax)
jne 0x19f97e
movq 0x8(%rsp), %rax
movq 0x498(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x4a0(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x4a8(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x4b0(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x4b8(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
cmpl $0x1, 0xa0(%rax)
jne 0x19f99d
movq 0x8(%rsp), %rax
movq 0x500(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
cmpl $0x6, 0x1a4(%rax)
jne 0x19f9bc
movq 0x8(%rsp), %rax
movq 0x508(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
cmpl $0x5, 0x1a4(%rax)
je 0x19f9d8
movq 0x8(%rsp), %rax
cmpl $0x2, 0x1a4(%rax)
jne 0x19f9e9
movq 0x8(%rsp), %rax
movq 0x518(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x530(%rax), %rdi
callq 0x8420
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x54c(%rcx), %eax
jge 0x19fa35
movq 0x8(%rsp), %rax
movq 0x528(%rax), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x19fa01
movq 0x8(%rsp), %rax
movq 0x528(%rax), %rdi
callq 0x8420
movq 0x8(%rsp), %rax
movq 0x550(%rax), %rdi
callq 0x8420
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/heating/injection.c
// Function: injection_rate_DM_decay
int injection_rate_DM_decay(struct injection * pin,
                            double z,
                            double * energy_rate){

  /** - Calculate injection rates */
  *energy_rate = pin->rho_cdm*pin->DM_decay_fraction*pin->DM_decay_Gamma*
                 exp(-pin->DM_decay_Gamma*pin->t);                                                  // [J/(m^3 s)]

  return _SUCCESS_;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x20(%rsp), %rax
movsd 0x410(%rax), %xmm0
movq 0x20(%rsp), %rax
mulsd 0x50(%rax), %xmm0
movq 0x20(%rsp), %rax
mulsd 0x58(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movsd 0x58(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x20(%rsp), %rax
mulsd 0x3f8(%rax), %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/heating/injection.c
// Function: injection_output_titles
int injection_output_titles(struct injection * pin, char titles[_MAXTITLESTRINGLENGTH_]){

  class_store_columntitle(titles,"Redshift z",_TRUE_);
  class_store_columntitle(titles,"Heat [-]",_TRUE_);
  class_store_columntitle(titles,"IonH [-]",_TRUE_);
  class_store_columntitle(titles,"IonHe [-]",_TRUE_);
  class_store_columntitle(titles,"Lya [-]",_TRUE_);

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x690b8(%rip), %rsi     # 0x20c632
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x4d7b3(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x690ac(%rip), %rsi     # 0x20c648
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x4d791(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x6aa9f(%rip), %rsi     # 0x20e05d
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x4d76f(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x6aa86(%rip), %rsi     # 0x20e066
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x4d74d(%rip), %rsi     # 0x1f0d3e
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x6aa6e(%rip), %rsi     # 0x20e070
callq 0x8660
movq 0x8(%rsp), %rdi
leaq 0x4d72b(%rip), %rsi     # 0x1f0d3e
callq 0x8660
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/heating/injection.c
// Function: injection_output_data
int injection_output_data(struct injection * pin,
                          int number_of_titles,
                          double * data){
  int storeidx;
  double * dataptr;
  int index_z;

  for (index_z=0; index_z<pin->z_size; index_z++) {
    dataptr = data + index_z*number_of_titles;
    storeidx = 0;
    class_store_double(dataptr, pin->z_table[index_z], _TRUE_, storeidx);
    class_store_double(dataptr, pin->deposition_table[pin->index_dep_heat][index_z], _TRUE_, storeidx);
    class_store_double(dataptr, pin->deposition_table[pin->index_dep_ionH][index_z], _TRUE_, storeidx);
    class_store_double(dataptr, pin->deposition_table[pin->index_dep_ionHe][index_z], _TRUE_, storeidx);
    class_store_double(dataptr, pin->deposition_table[pin->index_dep_lya][index_z], _TRUE_, storeidx);
  }

  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x450(%rcx), %eax
jge 0x1a37b0
movq -0x18(%rsp), %rax
movl -0x2c(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq 0x448(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x528(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x538(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x528(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x53c(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x528(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x540(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x528(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x544(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x1a3636
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/heating/noninjection.c
// Function: noninjection_free
int noninjection_free(struct noninjection* pni){

  free(pni->z_table);
  free(pni->photon_dep_table);

  free(pni->k);
  free(pni->k_weights);
  free(pni->pk_primordial_k);

  free(pni->z_table_coarse);
  free(pni->noninjection_table);
  free(pni->ddnoninjection_table);

  free(pni->integrand_approx);

  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x108(%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 0x38(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x30(%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/heating/noninjection.c
// Function: noninjection_photon_heating_at_z
int noninjection_photon_heating_at_z(struct noninjection* pni,
                                     double z,
                                     double* heat){

  /** Define local variables */
  double h,a,b;

  class_call(array_spline_hunt(pni->z_table,
                               pni->z_size,
                               z,
                               &(pni->last_index_z),
                               &h,&a,&b,
                               pni->error_message),
           pni->error_message,
           pni->error_message);

  * heat = ( a*pni->photon_dep_table[pni->last_index_z] + b*pni->photon_dep_table[pni->last_index_z+1] );

  return _SUCCESS_;
}

// Assembly:
subq $0x848, %rsp            # imm = 0x848
movq %rdi, 0x838(%rsp)
movsd %xmm0, 0x830(%rsp)
movq %rsi, 0x828(%rsp)
movq 0x838(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x838(%rsp), %rax
movl 0x60(%rax), %esi
movsd 0x830(%rsp), %xmm0
movq 0x838(%rsp), %rdx
addq $0x70, %rdx
movq 0x838(%rsp), %rax
addq $0x110, %rax            # imm = 0x110
leaq 0x820(%rsp), %rcx
leaq 0x818(%rsp), %r8
leaq 0x810(%rsp), %r9
movq %rax, (%rsp)
callq 0x27de0
cmpl $0x1, %eax
jne 0x1a54a4
leaq 0x10(%rsp), %rdi
movq 0x838(%rsp), %rcx
addq $0x110, %rcx            # imm = 0x110
leaq 0x2cf7d(%rip), %rsi     # 0x1d23d8
leaq 0x69020(%rip), %rdx     # 0x20e482
movb $0x0, %al
callq 0x5b9c0
movq 0x838(%rsp), %rdi
addq $0x110, %rdi            # imm = 0x110
leaq 0x10(%rsp), %r8
leaq 0x2cbb0(%rip), %rsi     # 0x1d2034
leaq 0x6905b(%rip), %rdx     # 0x20e4e6
movl $0x129, %ecx            # imm = 0x129
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x844(%rsp)
jmp 0x1a551a
movsd 0x818(%rsp), %xmm0
movq 0x838(%rsp), %rax
movq 0x108(%rax), %rax
movq 0x838(%rsp), %rcx
movslq 0x70(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x810(%rsp), %xmm1
movq 0x838(%rsp), %rax
movq 0x108(%rax), %rax
movq 0x838(%rsp), %rcx
movl 0x70(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
mulsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x828(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x0, 0x844(%rsp)
movl 0x844(%rsp), %eax
addq $0x848, %rsp            # imm = 0x848
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/heating/noninjection.c
// Function: noninjection_output_data
int noninjection_output_data(struct noninjection * pni,
                             int number_of_titles,
                             double * data){
  int storeidx;
  double * dataptr;
  int index_z;

  for (index_z=0; index_z<pni->z_size; index_z++) {
    dataptr = data + index_z*number_of_titles;
    storeidx = 0;
    class_store_double(dataptr, pni->z_table[index_z], _TRUE_, storeidx);
    class_store_double(dataptr, pni->photon_dep_table[index_z], _TRUE_, storeidx);
  }

  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x1a564a
movq -0x18(%rsp), %rax
movl -0x2c(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq 0x68(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x108(%rax), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x1a55a6
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/hyrectools.c
// Function: create_1D_array
double *create_1D_array(unsigned n1, int *error, char error_message[SIZE_ErrorM]){

  double *matrix = (double *) calloc(n1, sizeof(double));
  char sub_message[128];
  if (*error == 1) return matrix;
   
  if (matrix == NULL) {
    sprintf(sub_message, "unable to allocate memory in create_1D_array \n");
    strcat(error_message, sub_message);
    *error = 1;
  }
  return matrix;
}

// Assembly:
subq $0xa8, %rsp
movl %edi, 0x9c(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x8280
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x1a56e8
movq 0x80(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x1a5732
cmpq $0x0, 0x80(%rsp)
jne 0x1a5722
movq %rsp, %rdi
leaq 0x68eab(%rip), %rsi     # 0x20e5a8
movb $0x0, %al
callq 0x8090
movq 0x88(%rsp), %rdi
movq %rsp, %rsi
callq 0x8660
movq 0x90(%rsp), %rax
movl $0x1, (%rax)
movq 0x80(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/hyrectools.c
// Function: create_2D_array
double **create_2D_array(unsigned n1, unsigned n2, int *error, char error_message[SIZE_ErrorM]){
  
  unsigned i;
  double **matrix = (double **) calloc(n1, sizeof(double *));
  char sub_message[128];
  if (*error == 1) return matrix;
   
  if (matrix == NULL){
    sprintf(sub_message, "unable to allocate memory in create_2D_array \n");
    strcat(error_message, sub_message);
    *error = 1;
  }
  for (i = 0; i < n1; i++)  matrix[i] = create_1D_array(n2, error, error_message);
   
  return matrix;
}

// Assembly:
subq $0xb8, %rsp
movl %edi, 0xac(%rsp)
movl %esi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movl 0xac(%rsp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x8280
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x1a57b2
movq 0x88(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x1a585c
cmpq $0x0, 0x88(%rsp)
jne 0x1a57ec
movq %rsp, %rdi
leaq 0x68e10(%rip), %rsi     # 0x20e5d7
movb $0x0, %al
callq 0x8090
movq 0x98(%rsp), %rdi
movq %rsp, %rsi
callq 0x8660
movq 0xa0(%rsp), %rax
movl $0x1, (%rax)
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
cmpl 0xac(%rsp), %eax
jae 0x1a584c
movl 0xa8(%rsp), %edi
movq 0xa0(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x1a5690
movq %rax, %rdx
movq 0x88(%rsp), %rax
movl 0x94(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x1a57f7
movq 0x88(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../external/HyRec2020/hyrectools.c
// Function: create_3D_array
double ***create_3D_array(unsigned n1, unsigned n2, unsigned n3, int *error, char error_message[SIZE_ErrorM]){

  unsigned i;
  double ***matrix = (double ***) calloc(n1, sizeof(double **));
  char sub_message[128];
  if (*error == 1) return matrix;

  if (matrix == NULL) {
    sprintf(sub_message, "unable to allocate memory in create_3D_array \n");
    strcat(error_message, sub_message);
    *error = 1;
  }
  for (i = 0; i < n1; i++)  matrix[i] = create_2D_array(n2, n3, error, error_message);
         
  return matrix;
}

// Assembly:
subq $0xb8, %rsp
movl %edi, 0xac(%rsp)
movl %esi, 0xa8(%rsp)
movl %edx, 0xa4(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movl 0xac(%rsp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x8280
movq %rax, 0x80(%rsp)
movq 0x98(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x1a5929
movq 0x80(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x1a59da
cmpq $0x0, 0x80(%rsp)
jne 0x1a5963
movq %rsp, %rdi
leaq 0x68cc8(%rip), %rsi     # 0x20e606
movb $0x0, %al
callq 0x8090
movq 0x90(%rsp), %rdi
movq %rsp, %rsi
callq 0x8660
movq 0x98(%rsp), %rax
movl $0x1, (%rax)
movl $0x0, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
cmpl 0xac(%rsp), %eax
jae 0x1a59ca
movl 0xa8(%rsp), %edi
movl 0xa4(%rsp), %esi
movq 0x98(%rsp), %rdx
movq 0x90(%rsp), %rcx
callq 0x1a5750
movq %rax, %rdx
movq 0x80(%rsp), %rax
movl 0x8c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x1a596e
movq 0x80(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
nopw (%rax,%rax)