LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../include/parallel.h
// Function: std::future<std::result_of<array_spline_table_columns2::$_0 ()>::type> Tools::TaskSystem::AsyncTask<array_spline_table_columns2::$_0>(array_spline_table_columns2::$_0&&)
std::future<typename std::result_of<F()>::type> AsyncTask(F&& f) {
    using return_type = typename std::result_of<F()>::type;
    auto task = std::make_shared<std::packaged_task<return_type()>>(f);
    std::future<return_type> res = task->get_future();

    auto work = [task](){ (*task)(); };
    unsigned int i = index_++;
    for(unsigned int n = 0; n < count_; ++n) {
      if(queues_[(i + n) % count_].TryPush(work)){
        return res;
      }
    }
    queues_[i % count_].Push(work);

    return res;
  }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2bd50
movq 0x18(%rsp), %rdi
movb $0x0, 0x5f(%rsp)
callq 0x32d70
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x32d80
jmp 0x20db2
leaq 0x38(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x32e00
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x32e30
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl (%rcx), %eax
jae 0x20e89
movq 0x10(%rsp), %rcx
movq %rcx, %rdi
addq $0x28, %rdi
movl 0x34(%rsp), %eax
movl 0x30(%rsp), %edx
addl %edx, %eax
movl (%rcx), %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %esi
callq 0x31460
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2bdd0
movb %al, 0x7(%rsp)
jmp 0x20e24
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x20e2e
jmp 0x20e77
movb $0x1, 0x5f(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x20ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x20ef4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2bf10
movq 0x20(%rsp), %rdi
callq 0x2f0b0
jmp 0x20ef4
jmp 0x20e79
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x20ddd
movq 0x10(%rsp), %rcx
movq %rcx, %rdi
addq $0x28, %rdi
movl 0x34(%rsp), %eax
movl (%rcx), %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %esi
callq 0x31460
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2be90
jmp 0x20eb5
movb $0x1, 0x5f(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2bf10
testb $0x1, 0x5f(%rsp)
jne 0x20edd
movq 0x20(%rsp), %rdi
callq 0x2f0b0
leaq 0x60(%rsp), %rdi
callq 0x32ef0
movq 0x8(%rsp), %rax
addq $0x88, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x32ef0
movq 0x50(%rsp), %rdi
callq 0x8640
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_all_spline
int array_integrate_all_spline(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y,
		   int index_ddy,
		   double * result,
		   ErrorMsg errmsg) {

  int i;
  double h;

  *result = 0;

  for (i=0; i < n_lines-1; i++) {

    h = (array[(i+1)*n_columns+index_x]-array[i*n_columns+index_x]);

    // the second line ended with an incorrect + sign until v3.2 included (Credits: C. Radermacher)
    *result +=
      (array[i*n_columns+index_y]+array[(i+1)*n_columns+index_y])*h/2. -
      (array[i*n_columns+index_ddy]+array[(i+1)*n_columns+index_ddy])*h*h*h/24.;

  }

  return _SUCCESS_;
}

// Assembly:
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x22d68
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
addl $0x1, %ecx
imull -0xc(%rsp), %ecx
addl -0x14(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
imull -0xc(%rsp), %ecx
addl -0x14(%rsp), %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
imull -0xc(%rsp), %ecx
addl -0x18(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
addl $0x1, %ecx
imull -0xc(%rsp), %ecx
addl -0x18(%rsp), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
mulsd -0x28(%rsp), %xmm0
movsd 0x1aff92(%rip), %xmm1   # 0x1d2c80
divsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
imull -0xc(%rsp), %ecx
addl -0x1c(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
addl $0x1, %ecx
imull -0xc(%rsp), %ecx
addl -0x1c(%rsp), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm1
mulsd -0x28(%rsp), %xmm1
mulsd -0x28(%rsp), %xmm1
mulsd -0x28(%rsp), %xmm1
movsd 0x1b094d(%rip), %xmm2   # 0x1d3690
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movq 0x8(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x22c59
xorl %eax, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_all_spline_table_line_to_line
int array_integrate_all_spline_table_line_to_line(
                  double * x_array,
                  int n_lines,
                  double * array,
                  int n_columns,
                  int index_y,
                  int index_ddy,
                  double * result,
                  ErrorMsg errmsg){

  int i;
  double h;

  *result = 0;

  for (i=0; i < n_lines-1; i++) {

    h = (x_array[i+1]-x_array[i]);

    // the second line ended with an incorrect + sign until v3.2 included (Credits: C. Radermacher)
    *result +=
      (array[i*n_columns+index_y]+array[(i+1)*n_columns+index_y])*h/2. -
      (array[i*n_columns+index_ddy]+array[(i+1)*n_columns+index_ddy])*h*h*h/24.;

  }

  return _SUCCESS_;
}

// Assembly:
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl %r8d, -0x20(%rsp)
movl %r9d, -0x24(%rsp)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x22ea5
movq -0x8(%rsp), %rax
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movslq -0x28(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
imull -0x1c(%rsp), %ecx
addl -0x20(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
imull -0x1c(%rsp), %ecx
addl -0x20(%rsp), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
mulsd -0x30(%rsp), %xmm0
movsd 0x1afe55(%rip), %xmm1   # 0x1d2c80
divsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
imull -0x1c(%rsp), %ecx
addl -0x24(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
imull -0x1c(%rsp), %ecx
addl -0x24(%rsp), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm1
mulsd -0x30(%rsp), %xmm1
mulsd -0x30(%rsp), %xmm1
mulsd -0x30(%rsp), %xmm1
movsd 0x1b0810(%rip), %xmm2   # 0x1d3690
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movq 0x8(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x22daa
xorl %eax, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_all
int array_integrate_all(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y,
		   double *result) {

  int i;
  double sum;

  sum=0.;

  for (i=1; i<n_lines; i++) {

    sum += 0.5 * (*(array+i*n_columns+index_y) + *(array+(i-1)*n_columns+index_y))
               * (*(array+i*n_columns+index_x) - *(array+(i-1)*n_columns+index_x));

  }

  *result = sum;

  return _SUCCESS_;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movq %r9, -0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rsp)
movl $0x1, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x10(%rsp), %eax
jge 0x29d68
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
subl $0x1, %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm1
movsd 0x1a8f8f(%rip), %xmm0   # 0x1d2c88
mulsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
subl $0x1, %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd -0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x29c9c
movsd -0x30(%rsp), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_trapezoidal_weights
int array_trapezoidal_weights(
                              double * __restrict__ x,
                              int n,
                              double * __restrict__ w_trapz,
                              ErrorMsg errmsg
                              ) {
  int i;

  /* Case with just one point, w would normally be 0. */
  if (n==1){
    w_trapz[0] = 0.0;
  }
  else if (n>1){
    //Set edgeweights:
    w_trapz[0] = 0.5*(x[1]-x[0]);
    w_trapz[n-1] = 0.5*(x[n-1]-x[n-2]);
    //Set inner weights:
    for (i=1; i<(n-1); i++){
      w_trapz[i] = 0.5*(x[i+1]-x[i-1]);
    }
  }
  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
cmpl $0x1, -0xc(%rsp)
jne 0x2a8fb
movq -0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x2a9e1
cmpl $0x1, -0xc(%rsp)
jle 0x2a9df
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq -0x8(%rsp), %rax
subsd (%rax), %xmm1
movsd 0x1a8367(%rip), %xmm0   # 0x1d2c88
mulsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm1
movsd 0x1a832a(%rip), %xmm0   # 0x1d2c88
mulsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x24(%rsp)
movl -0x24(%rsp), %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2a9dd
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm1
movsd 0x1a82cb(%rip), %xmm0   # 0x1d2c88
mulsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x2a97e
jmp 0x2a9df
jmp 0x2a9e1
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_trapezoidal_mweights
int array_trapezoidal_mweights(
                              double * __restrict__ x,
                              int n,
                              double * __restrict__ w_trapz,
                              ErrorMsg errmsg
                              ) {
  int i;

  /* Case with just one point. */
  if (n==1){
    w_trapz[0] = 1.0;
  }
  else if (n>1){
    //Set edgeweights:
    w_trapz[0] = 0.5*(x[0]-x[1]);
    w_trapz[n-1] = 0.5*(x[n-2]-x[n-1]);
    //Set inner weights:
    for (i=1; i<(n-1); i++){
      w_trapz[i] = 0.5*(x[i-1]-x[i+1]);
    }
  }
  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
cmpl $0x1, -0xc(%rsp)
jne 0x2aa20
movq -0x18(%rsp), %rax
movsd 0x1a7831(%rip), %xmm0   # 0x1d2248
movsd %xmm0, (%rax)
jmp 0x2ab06
cmpl $0x1, -0xc(%rsp)
jle 0x2ab04
movq -0x8(%rsp), %rax
movsd (%rax), %xmm1
movq -0x8(%rsp), %rax
subsd 0x8(%rax), %xmm1
movsd 0x1a8242(%rip), %xmm0   # 0x1d2c88
mulsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm1
movsd 0x1a8205(%rip), %xmm0   # 0x1d2c88
mulsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x24(%rsp)
movl -0x24(%rsp), %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2ab02
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rsp), %rax
movl -0x24(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm1
movsd 0x1a81a6(%rip), %xmm0   # 0x1d2c88
mulsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x2aaa3
jmp 0x2ab04
jmp 0x2ab06
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_trapezoidal_integral
int array_trapezoidal_integral(
                                  double * __restrict__ integrand,
                                  int n,
                                  double * __restrict__ w_trapz,
                                  double * __restrict__ I,
                                  ErrorMsg errmsg
                                  ) {
  int i;
  double res=0.0;
  for (i=0; i<n; i++){
    res += integrand[i]*w_trapz[i];
  }
  *I = res;
  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x2ab82
movq -0x8(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rsp)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x2ab39
movsd -0x38(%rsp), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_trapezoidal_convolution
int array_trapezoidal_convolution(
                                     double * __restrict__ integrand1,
                                     double * __restrict__ integrand2,
                                     int n,
                                     double * __restrict__ w_trapz,
                                     double * __restrict__ I,
                                     ErrorMsg errmsg
                                     ) {
  int i;
  double res=0.0;
  for (i=0; i<n; i++){
    res += integrand1[i]*integrand2[i]*w_trapz[i];
  }
  *I = res;
  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x2ac26
movq -0x8(%rsp), %rax
movslq -0x34(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movslq -0x34(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movslq -0x34(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x40(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rsp)
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x2abce
movsd -0x40(%rsp), %xmm0
movq -0x28(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../include/parallel.h
// Function: bool Tools::NotificationQueue::TryPush<std::future<std::result_of<array_spline_table_columns2::$_0 ()>::type> Tools::TaskSystem::AsyncTask<array_spline_table_columns2::$_0>(array_spline_table_columns2::$_0&&)::'lambda'()&>(array_spline_table_columns2::$_0&&)
bool TryPush(F&& f) {
    {
      std::unique_lock<std::mutex> lock(mutex_, std::try_to_lock);
      if (!lock) {
        return false;
      }
      queue_.emplace_back(std::forward<F>(f));
    }
    ready_.notify_one();
    return true;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x58, %rsi
leaq 0x20(%rsp), %rdi
callq 0x31690
leaq 0x20(%rsp), %rdi
callq 0x316d0
testb $0x1, %al
jne 0x2be12
movb $0x0, 0x47(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x2be2a
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2e7d0
jmp 0x2be22
movl $0x0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x31800
movl 0x18(%rsp), %eax
testl %eax, %eax
je 0x2be40
jmp 0x2be3e
jmp 0x2be71
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x81d0
movb $0x1, 0x47(%rsp)
jmp 0x2be71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x31800
jmp 0x2be7c
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x8640
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../include/parallel.h
// Function: Tools::TaskSystem::GetNumThreads()
static unsigned int GetNumThreads() {
    unsigned int number_of_threads = std::thread::hardware_concurrency();
    for (const std::string& env_var_name : {"OMP_NUM_THREADS", "SLURM_CPUS_PER_TASK"}) {
      if (char* s = std::getenv(env_var_name.c_str())) {
        int threads = std::atoi(s);
        if ((threads > 0) && (threads <= 8192)) {
          number_of_threads = threads;
          break;
        }
      }
    }
    return number_of_threads;
  }

// Assembly:
subq $0xa8, %rsp
callq 0x8490
movl %eax, 0xa4(%rsp)
leaq 0x1a5999(%rip), %rax    # 0x1d4773
movq %rax, 0x78(%rsp)
leaq 0x1a599d(%rip), %rax    # 0x1d4783
movq %rax, 0x80(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x88(%rsp)
movq $0x2, 0x90(%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2f3c0
movq %rax, 0x70(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2f3d0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
je 0x2ef33
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8650
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x8470
jmp 0x2ee7d
leaq 0x3f(%rsp), %rdi
callq 0x83f0
leaq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x8170
movq %rax, %rdi
callq 0x8440
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2ef00
movq 0x20(%rsp), %rdi
callq 0x8510
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x2eefe
cmpl $0x2000, 0x1c(%rsp)     # imm = 0x2000
jg 0x2eefe
movl 0x1c(%rsp), %eax
movl %eax, 0xa4(%rsp)
movl $0x2, 0x18(%rsp)
jmp 0x2ef08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x83f0
jmp 0x2ef42
jmp 0x2ef00
movl $0x0, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8260
movl 0x18(%rsp), %eax
testl %eax, %eax
je 0x2ef1e
jmp 0x2ef1c
jmp 0x2ef33
jmp 0x2ef20
movq 0x70(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x70(%rsp)
jmp 0x2ee3b
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x8640
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../include/parallel.h
// Function: Tools::TaskSystem::Run(unsigned int)
void Run(unsigned int i) {
    while (true) {
      std::function<void()> f;
      for (unsigned n = 0; n != count_; ++n) {
        if (queues_[(i + n) % count_].TryPop(f)) {
          break;
        }
      }
      if (!f && !queues_[i].Pop(f)) {
        break;
      }
      f();
    }
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x31420
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl (%rcx), %eax
je 0x31394
movq 0x8(%rsp), %rcx
movq %rcx, %rdi
addq $0x28, %rdi
movl 0x4c(%rsp), %eax
movl 0x24(%rsp), %edx
addl %edx, %eax
movl (%rcx), %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %esi
callq 0x31460
movq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x31480
movb %al, 0x7(%rsp)
jmp 0x3135c
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x31366
jmp 0x31385
jmp 0x31394
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x30b00
jmp 0x31411
jmp 0x31387
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x31319
leaq 0x28(%rsp), %rdi
callq 0x31520
testb $0x1, %al
jne 0x313dd
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x31460
movq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x31550
movb %al, 0x6(%rsp)
jmp 0x313c9
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x313dd
jmp 0x313d3
movl $0x3, 0x10(%rsp)
jmp 0x313f1
leaq 0x28(%rsp), %rdi
callq 0x31630
jmp 0x313e9
movl $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x30b00
movl 0x10(%rsp), %eax
testl %eax, %eax
je 0x31407
jmp 0x31405
jmp 0x3140c
jmp 0x31307
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8640
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../include/parallel.h
// Function: Tools::NotificationQueue::TryPop(std::function<void ()>&)
bool TryPop(std::function<void()>& x) {
    std::unique_lock<std::mutex> lock(mutex_, std::try_to_lock);
    if (!lock || queue_.empty()) {
      return false;
    }
    x = std::move(queue_.front());
    queue_.pop_front();
    return true;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x58, %rsi
leaq 0x10(%rsp), %rdi
callq 0x31690
leaq 0x10(%rsp), %rdi
callq 0x316d0
testb $0x1, %al
jne 0x314b5
jmp 0x314c4
movq (%rsp), %rdi
callq 0x316f0
testb $0x1, %al
jne 0x314c4
jmp 0x314d3
movb $0x0, 0x37(%rsp)
movl $0x1, 0x8(%rsp)
jmp 0x314ff
movq (%rsp), %rdi
callq 0x31710
movq %rax, %rsi
movq 0x20(%rsp), %rdi
callq 0x31740
movq (%rsp), %rdi
callq 0x31790
movb $0x1, 0x37(%rsp)
movl $0x1, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x31800
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../include/parallel.h
// Function: Tools::NotificationQueue::Pop(std::function<void ()>&)
bool Pop(std::function<void()>& x) {
    std::unique_lock<std::mutex> lock(mutex_);
    while (queue_.empty() && !done_) {
      ready_.wait(lock);
    }
    if (queue_.empty()) {
      return false;
    }
    x = std::move(queue_.front());
    queue_.pop_front();
    return true;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x58, %rsi
leaq 0x20(%rsp), %rdi
callq 0x31bc0
movq 0x10(%rsp), %rdi
callq 0x316f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x3158f
jmp 0x3159d
movq 0x10(%rsp), %rax
movb 0x50(%rax), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x315a7
jmp 0x315bf
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
leaq 0x20(%rsp), %rsi
callq 0x8100
jmp 0x31576
movq 0x10(%rsp), %rdi
callq 0x316f0
testb $0x1, %al
jne 0x315cf
jmp 0x315de
movb $0x0, 0x47(%rsp)
movl $0x1, 0x1c(%rsp)
jmp 0x3160c
movq 0x10(%rsp), %rdi
callq 0x31710
movq %rax, %rsi
movq 0x30(%rsp), %rdi
callq 0x31740
movq 0x10(%rsp), %rdi
callq 0x31790
movb $0x1, 0x47(%rsp)
movl $0x1, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x31800
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/parser.c
// Function: parser_free
int parser_free(struct file_content * pfc) {

  if (pfc->size > 0) {
    free(pfc->name);
    free(pfc->value);
    free(pfc->read);
    free(pfc->filename);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x382f2
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq (%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/../tools/parser.c
// Function: parser_copy
int parser_copy(struct file_content * pfc_source, struct file_content * pfc_destination, int index_start, int index_end) {
  // Copy the entries from index_start to index_end from pfc_source to pfc_destination
  memcpy(pfc_destination->name  + index_start, pfc_source->name  + index_start, (index_end - index_start)*sizeof(FileArg));
  memcpy(pfc_destination->value + index_start, pfc_source->value + index_start, (index_end - index_start)*sizeof(FileArg));
  memcpy(pfc_destination->read  + index_start, pfc_source->read  + index_start, (index_end - index_start)*sizeof(short));
  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x4(%rsp), %rax
shlq $0xa, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movslq 0x4(%rsp), %rax
shlq $0xa, %rax
addq %rax, %rsi
movl (%rsp), %eax
subl 0x4(%rsp), %eax
movslq %eax, %rdx
shlq $0xa, %rdx
callq 0x8300
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movslq 0x4(%rsp), %rax
shlq $0xa, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movslq 0x4(%rsp), %rax
shlq $0xa, %rax
addq %rax, %rsi
movl (%rsp), %eax
subl 0x4(%rsp), %eax
movslq %eax, %rdx
shlq $0xa, %rdx
callq 0x8300
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movslq 0x4(%rsp), %rax
shlq %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movslq 0x4(%rsp), %rax
shlq %rax
addq %rax, %rsi
movl (%rsp), %eax
subl 0x4(%rsp), %eax
movslq %eax, %rdx
shlq %rdx
callq 0x8300
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/parser.c
// Function: parser_init_from_pfc
int parser_init_from_pfc(struct file_content * pfc_source, struct file_content * pfc_destination, ErrorMsg errmsg) {
  class_call(parser_init(pfc_destination,
                         pfc_source->size,
                         pfc_source->filename,
                         errmsg),
             errmsg,errmsg);
  parser_copy(pfc_source, pfc_destination, 0, pfc_source->size);
  return _SUCCESS_;
}

// Assembly:
subq $0x828, %rsp            # imm = 0x828
movq %rdi, 0x818(%rsp)
movq %rsi, 0x810(%rsp)
movq %rdx, 0x808(%rsp)
movq 0x810(%rsp), %rdi
movq 0x818(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x818(%rsp), %rax
movq (%rax), %rdx
movq 0x808(%rsp), %rcx
callq 0x37fb0
cmpl $0x1, %eax
jne 0x3ae11
movq %rsp, %rdi
movq 0x808(%rsp), %rcx
leaq 0x197607(%rip), %rsi    # 0x1d23d8
leaq 0x19a117(%rip), %rdx    # 0x1d4eef
movb $0x0, %al
callq 0x5b9c0
movq 0x808(%rsp), %rdi
movq %rsp, %r8
leaq 0x197243(%rip), %rsi    # 0x1d2034
leaq 0x19a144(%rip), %rdx    # 0x1d4f3c
movl $0x304, %ecx            # imm = 0x304
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x824(%rsp)
jmp 0x3ae3e
movq 0x818(%rsp), %rdi
movq 0x810(%rsp), %rsi
movq 0x818(%rsp), %rax
movl 0x8(%rax), %ecx
xorl %edx, %edx
callq 0x3aca0
movl $0x0, 0x824(%rsp)
movl 0x824(%rsp), %eax
addq $0x828, %rsp            # imm = 0x828
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/quadrature.c
// Function: leaf_count
int leaf_count(qss_node *node){
  /* Count the amount of leafs under a given node and write the number in the node. */
  /* We call recursively, until a node is a leaf - then we add the numbers on our
     way back:*/
  if (node->left!=NULL){
    /* This is not a leaf, do recursive call: */
    leaf_count(node->left);
    leaf_count(node->right);
    node->leaf_childs = node->left->leaf_childs + node->right->leaf_childs;
    return _SUCCESS_;
  }
  else{
    /* This is a leaf, by definition leaf_childs = 1: */
    node->leaf_childs = 1;
    return _SUCCESS_;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3d14b
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x3d0f0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x3d0f0
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x20(%rax), %ecx
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
addl 0x20(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, 0x14(%rsp)
jmp 0x3d15f
movq 0x8(%rsp), %rax
movl $0x1, 0x20(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/quadrature.c
// Function: get_integral
double get_integral(qss_node *node, int level){
  /* Traverse the tree and return the estimate of the integral at a given level.
     level 1 is the best estimate. */
  double IL,IR;
  /* An updated leaf_count is assumed. */
  if (node->leaf_childs<=level){
    return node->I;
  }
  else{
    IL = get_integral(node->left, level);
    IR = get_integral(node->right, level);
    /* Combine the integrals: */
    return (IL+IR);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x20(%rax), %eax
cmpl 0x14(%rsp), %eax
jg 0x3d19c
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3d1dc
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x3d170
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x3d170
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/quadrature.c
// Function: reduce_tree
int reduce_tree(qss_node *node, int level){
  /* Reduce the tree to a given level. Make all nodes with
     node->leaf_childs==level into leafs.
     If we call reduce_tree(root,1), nothing happens.*/
  if(node->leaf_childs==level){
    burn_tree(node->left);
    burn_tree(node->right);
    node->left = NULL;
    node->right = NULL;
  }
  else if(node->leaf_childs>level){
    /* else try to see if children nodes can be simplified: */
    reduce_tree(node->left,level);
    reduce_tree(node->right,level);
  }
  /* If called on a node which has leaf_childs<level, it does nothing. */
  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0x3d243
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x3d380
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x3d380
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
jmp 0x3d277
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
cmpl 0xc(%rsp), %eax
jle 0x3d275
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x3d1f0
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x3d1f0
jmp 0x3d277
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/quadrature.c
// Function: get_leaf_x_and_w
int get_leaf_x_and_w(qss_node *node, int *ind, double *x, double *w,int isindefinite){
  /* x and w should be exactly 15*root_node->leafchilds, and a leaf count should have
     been performed. Or perhaps I just use the fact that a leaf won't have children.
     Nah, let me use the leaf-count then. */
  int k;
  if (node->leaf_childs==1){
    for(k=0;k<15;k++){
      x[*ind] = node->x[k];
      w[*ind] = node->w[k];
      if (isindefinite == _TRUE_){
	(*ind)--;
      }
      else{
	(*ind)++;
      }
    }
  }
  else{
    /* Do recursive call: */
    get_leaf_x_and_w(node->left,ind,x,w,isindefinite);
    get_leaf_x_and_w(node->right,ind,x,w,isindefinite);
  }
  return _SUCCESS_;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x3d331
movl $0x0, (%rsp)
cmpl $0xf, (%rsp)
jge 0x3d32f
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq (%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
cmpl $0x1, 0x4(%rsp)
jne 0x3d316
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x3d322
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3d324
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x3d2b3
jmp 0x3d375
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x3d280
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x3d280
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/quadrature.c
// Function: burn_tree
int burn_tree(qss_node *node){
  /* Burn node and all subnodes. */
  /* Call burn_branch recursively on children nodes: */
  /* This node and all its subnodes */
  if (node!=NULL){
    if (node->left!=NULL) burn_tree(node->left);
    if (node->right!=NULL) burn_tree(node->right);

    if (node->x!=NULL) free(node->x);
    if (node->w!=NULL) free(node->w);
    free(node);
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x3d3f5
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3d3a4
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x3d380
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3d3bc
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x3d380
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3d3d4
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3d3ec
movq (%rsp), %rax
movq 0x18(%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/../tools/quadrature.c
// Function: compute_Hermite
int compute_Hermite(double *x, double *w, int N, int alpha, double *b, double *c){
  int NLag,i;
  double alpha_Lag;

  NLag = N/2;
  /* In case N is uneven, zero the N'th weight:*/
  w[N-1] = 0.0;
  alpha_Lag = (alpha-1.0)/2.0;

  /* Compute the positive roots and weights (up to some simple manipulation): */
  compute_Laguerre(x+NLag,w+NLag,NLag,alpha_Lag,b,c,_FALSE_);

  /* Do manipulations:*/
  for(i=NLag; i<2*NLag; i++){
    x[i] = sqrt(x[i]);
    w[i] *=0.5;
  }

  /* Set the negative roots and weights:*/
  for(i=0; i<NLag; i++){
    x[i] = -x[2*NLag-i-1];
    w[i] = w[2*NLag-i-1];
    if (alpha%2!=0){
      w[i] = -w[i];
    }
  }
  return _SUCCESS_;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movl 0x24(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
cvtsi2sdl 0x20(%rsp), %xmm0
movsd 0x194873(%rip), %xmm1   # 0x1d2248
subsd %xmm1, %xmm0
movsd 0x19529f(%rip), %xmm1   # 0x1d2c80
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0xc(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movslq 0xc(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movl 0xc(%rsp), %edx
movsd (%rsp), %xmm0
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
xorl %r9d, %r9d
callq 0x3b360
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x3da89
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x82e0
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd 0x195216(%rip), %xmm0   # 0x1d2c88
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3da2f
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x3db60
movq 0x30(%rsp), %rax
movl 0xc(%rsp), %ecx
shll %ecx
subl 0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
shll %ecx
subl 0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x20(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x3db4e
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x3db50
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3da91
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: hyperspherical_update_pointers
int hyperspherical_update_pointers(HyperInterpStruct *pHIS_local,
                                   void * HIS_storage_shared){
  /** Assign pointers in pHIS: (Remember that pointer incrementation moves
      the number of bytes taken up by 1 variable of the type that the
      pointer points to. */
  int nx=pHIS_local->x_size;
  int nl=pHIS_local->l_size;
  pHIS_local->l = (int *) (HIS_storage_shared);
  pHIS_local->chi_at_phimin = (double *) (pHIS_local->l+nl);
  pHIS_local->x = pHIS_local->chi_at_phimin+nl;
  pHIS_local->sinK = pHIS_local->x + nx;
  pHIS_local->cotK = pHIS_local->sinK + nx;
  pHIS_local->phi = pHIS_local->cotK +nx;
  pHIS_local->dphi = pHIS_local->phi+nx*nl;

  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movslq -0x18(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movslq -0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movslq -0x14(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rcx
movslq -0x14(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rsp), %rax
movq 0x48(%rax), %rcx
movslq -0x14(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rcx
movl -0x14(%rsp), %eax
imull -0x18(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: hyperspherical_HIS_free
int hyperspherical_HIS_free(HyperInterpStruct *pHIS,
                            ErrorMsg error_message){
  /** Free the Hyperspherical Interpolation Structure. */
  free(pHIS->l);
  free(pHIS->chi_at_phimin);
  free(pHIS->x);
  free(pHIS->sinK);
  free(pHIS->cotK);
  free(pHIS->phi);
  free(pHIS->dphi);

  return _SUCCESS_;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x8420
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8420
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: ClosedModY
int ClosedModY(int l, int beta, double *y, int * phisign, int * dphisign){

  *phisign = 1;
  *dphisign = 1;


  while (*y > _TWOPI_)
    *y -= _TWOPI_;

  if ((*y) > _PI_){
    *y = 2.0*_PI_-(*y);
    //phisign *= pow(-1,l)
    if (l%2==1) //l is odd
      *phisign = -*phisign;
    else        //l is even
      *dphisign = -*dphisign;
  }
  if ((*y)>0.5*_PI_){
    *y = _PI_-(*y);
    //phisign *= pow(-1,beta-l-1)
    if ((beta-l)%2==0) //beta-l-1 odd
      *phisign = -*phisign;
    else               //beta-l-1 even
      *dphisign = -*dphisign;
  }
  return _SUCCESS_;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl $0x1, (%rax)
movq -0x20(%rsp), %rax
movl $0x1, (%rax)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x193aaa(%rip), %xmm1   # 0x1d5488
ucomisd %xmm1, %xmm0
jbe 0x419ff
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x193a93(%rip), %xmm1   # 0x1d5488
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
jmp 0x419cd
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x1935d0(%rip), %xmm1   # 0x1d4fe0
ucomisd %xmm1, %xmm0
jbe 0x41a65
movq -0x10(%rsp), %rax
movsd 0x193a65(%rip), %xmm0   # 0x1d5488
subsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movl -0x4(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x41a53
movq -0x18(%rsp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x41a63
movq -0x20(%rsp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x41a65
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x193a7a(%rip), %xmm1   # 0x1d54f0
ucomisd %xmm1, %xmm0
jbe 0x41acf
movq -0x10(%rsp), %rax
movsd 0x193557(%rip), %xmm0   # 0x1d4fe0
subsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movl -0x8(%rsp), %eax
subl -0x4(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x41abd
movq -0x18(%rsp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x41acd
movq -0x20(%rsp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x41acf
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: hyperspherical_forwards_recurrence
int hyperspherical_forwards_recurrence(int K,
                                       int lmax,
                                       double beta,
                                       double x,
                                       double sinK,
                                       double cotK,
                                       double * __restrict__ sqrtK,
                                       double * __restrict__ one_over_sqrtK,
                                       double * __restrict__ PhiL){
  int l;
  PhiL[0] = 1.0/beta*sin(beta*x)/sinK;
  PhiL[1] = PhiL[0]*(cotK-beta/tan(beta*x))*one_over_sqrtK[1];
  for (l=2; l<=lmax; l++){
    PhiL[l] = ((2*l-1)*cotK*PhiL[l-1]-PhiL[l-2]*sqrtK[l-1])*one_over_sqrtK[l];
  }
  return _SUCCESS_;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movsd %xmm2, 0x48(%rsp)
movsd %xmm3, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movsd 0x19072d(%rip), %xmm0   # 0x1d2248
divsd 0x58(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x58(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm0
callq 0x80a0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
divsd 0x48(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x58(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm0
callq 0x8220
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
mulsd 0x8(%rax), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x2, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x60(%rsp), %eax
jg 0x41c71
movl 0x24(%rsp), %eax
shll %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x40(%rsp), %xmm0
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x38(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
mulsd (%rax,%rcx,8), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x41bc7
xorl %eax, %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: airy_cheb_approx
double airy_cheb_approx(double z){
  double Ai;
  if (z<=-7){
    Ai = coef1(z);
    return Ai;
  }
  if (z<=0){
    Ai = coef2(z);
    return Ai;
  }
  if (z<7){
    Ai = coef3(z);
  return Ai;
  }
  Ai = coef4(z);
  return Ai;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd 0x191e46(%rip), %xmm0   # 0x1d5528
ucomisd 0x8(%rsp), %xmm0
jb 0x43707
movsd 0x8(%rsp), %xmm0
callq 0x43fb0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x43777
xorps %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
jb 0x4372f
movsd 0x8(%rsp), %xmm0
callq 0x441e0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x43777
movsd 0x190051(%rip), %xmm0   # 0x1d3788
ucomisd 0x8(%rsp), %xmm0
jbe 0x4375c
movsd 0x8(%rsp), %xmm0
callq 0x44340
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x43777
movsd 0x8(%rsp), %xmm0
callq 0x44400
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)