LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_smooth
int array_smooth(double * array,
		 int n_columns,
		 int n_lines,
		 int index, /** from 0 to (n_columns-1) */
		 int radius,
		 ErrorMsg errmsg) {

  double * smooth;
  int i,j,jmin,jmax;
  double weigth;

  smooth=(double*)malloc(n_lines*sizeof(double));
  if (smooth == NULL) {
    class_sprintf(errmsg,"%s(L:%d) Cannot allocate smooth",__func__,__LINE__);
    return _FAILURE_;
  }

  for (i=0; i<n_lines; i++) {
    smooth[i]=0.;
    weigth=0.;
    jmin = MAX(i-radius,0);
    jmax = MIN(i+radius,n_lines-1);
    for (j=jmin; j <= jmax; j++) {
      smooth[i] += array[j*n_columns+index];
      weigth += 1.;
    }
    smooth[i] /= weigth;
  }

  for (i=0; i<n_lines; i++)
    array[i*n_columns+index] = smooth[i];

  free(smooth);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r13d
movq %rdi, %r12
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x8490
testq %rax, %rax
je 0x1916c
leal -0x1(%rbx), %esi
movl %r14d, %edi
negl %edi
movslq %r13d, %rcx
xorl %r8d, %r8d
testl %ebx, %ebx
cmovlel %r8d, %ebx
movslq %ebp, %rdx
leaq (%r12,%rdx,8), %rdx
shlq $0x3, %rcx
movsd 0xcc17f(%rip), %xmm0    # 0xe5260
testl %edi, %edi
movl $0x0, %r9d
cmovgl %edi, %r9d
cmpq %rbx, %r8
je 0x19148
imulq %rcx, %r9
addq %rdx, %r9
testl %edi, %edi
movl $0x0, %r10d
cmovgl %edi, %r10d
leal (%r8,%r14), %r11d
cmpl %esi, %r11d
cmovgel %esi, %r11d
movslq %r11d, %r11
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
cmpq %r11, %r10
jg 0x19137
addsd (%r9), %xmm1
movsd %xmm1, (%rax,%r8,8)
addsd %xmm0, %xmm2
incq %r10
addq %rcx, %r9
jmp 0x1911b
divsd %xmm2, %xmm1
movsd %xmm1, (%rax,%r8,8)
incq %r8
incl %edi
jmp 0x190e1
xorl %esi, %esi
cmpq %rsi, %rbx
je 0x19160
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx)
incq %rsi
addq %rcx, %rdx
jmp 0x1914a
movq %rax, %rdi
callq 0x8430
xorl %eax, %eax
jmp 0x191af
leaq 0xce3b1(%rip), %rbx     # 0xe7524
leaq 0xce417(%rip), %r14     # 0xe7591
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
movl $0xcc9, %r8d            # imm = 0xCC9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movl $0xcc9, %r8d            # imm = 0xCC9
xorl %eax, %eax
callq 0x8580
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x1, %esi
jne 0x191c9
andq $0x0, (%rdx)
jmp 0x19221
jle 0x19221
movsd 0x8(%rdi), %xmm1
subsd (%rdi), %xmm1
movsd 0xccad4(%rip), %xmm0    # 0xe5cb0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx)
leal -0x1(%rsi), %eax
movsd (%rdi,%rax,8), %xmm1
movl %esi, %ecx
subsd -0x10(%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rax,8)
decq %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x19221
movsd 0x10(%rdi,%rcx,8), %xmm1
subsd (%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rcx,8)
incq %rcx
jmp 0x19202
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x1, %esi
jne 0x19238
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdx)
jmp 0x1928f
jle 0x1928f
movsd (%rdi), %xmm1
subsd 0x8(%rdi), %xmm1
movsd 0xcca65(%rip), %xmm0    # 0xe5cb0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx)
movl %esi, %eax
movsd -0x10(%rdi,%rax,8), %xmm1
decl %esi
subsd (%rdi,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
decq %rsi
xorl %eax, %eax
cmpq %rax, %rsi
je 0x1928f
movsd (%rdi,%rax,8), %xmm1
subsd 0x10(%rdi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rax,8)
incq %rax
jmp 0x19270
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorpd %xmm0, %xmm0
cmpq %rax, %rsi
je 0x192b5
movsd (%rdi,%rax,8), %xmm1
mulsd (%rdx,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1929d
movsd %xmm0, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm0, %xmm0
cmpq %rax, %rdx
je 0x192e4
movsd (%rdi,%rax,8), %xmm1
mulsd (%rsi,%rax,8), %xmm1
mulsd (%rcx,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x192c7
movsd %xmm0, (%r8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_hunt_descending
int array_hunt_descending(
                          double * array,
                          int size,
                          double value,
                          int * index,
                          ErrorMsg errmsg
                          ) {
  int i_inf,i_sup,i_mid;

  i_inf=0;
  i_sup=size-1;

  /* checks */
  if (array[i_inf] < array[i_sup]) {
    class_sprintf(errmsg,"%s(L:%d) array is not in descending order (checked only the boundaries)",__func__,__LINE__);
    return _FAILURE_;
  }
  if ((value > array[i_inf]) || (value < array[i_sup])) {
    class_sprintf(errmsg,"%s(L:%d) %e is outside the range [%e, %e]",__func__,__LINE__,value,array[size-1],array[0]);
    return _FAILURE_;
  }

  /* bisection */
  while (i_sup-i_inf>1) {
    i_mid = (i_sup+i_inf)/2;
    if (value > array[i_mid])
      i_sup=i_mid;
    else
      i_inf=i_mid;
  }

  /* result */
  *index = i_inf;

  /* check for debug */
  /* routine never used and tested before, be careful */
  fprintf(stderr,
          "Check that array[%d]=%e>%e>array[%d]=%e\n",
          *index,
          array[*index],
          value,
          *index+1,
          array[*index+1]);
  return _FAILURE_;

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movslq %esi, %r13
movsd (%rdi), %xmm2
movsd -0x8(%rdi,%r13,8), %xmm1
ucomisd %xmm2, %xmm1
jbe 0x19610
leaq 0xce024(%rip), %rbx     # 0xe75f9
leaq 0xce065(%rip), %r15     # 0xe7641
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xda8, %r8d            # imm = 0xDA8
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xda8, %r8d            # imm = 0xDA8
xorl %eax, %eax
callq 0x8580
jmp 0x19680
movapd %xmm0, %xmm3
movq %rdi, %rbx
ucomisd %xmm2, %xmm0
ja 0x19623
ucomisd %xmm3, %xmm1
jbe 0x19691
decq %r13
leaq 0xce02a(%rip), %r15     # 0xe7657
leaq 0xce00d(%rip), %r12     # 0xe7641
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movl $0xdac, %r8d            # imm = 0xDAC
movapd %xmm3, %xmm0
movb $0x3, %al
movsd %xmm3, 0x8(%rsp)
callq 0x8580
incl %eax
movslq %eax, %rsi
movsd (%rbx,%r13,8), %xmm1
movsd (%rbx), %xmm2
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl $0xdac, %r8d            # imm = 0xDAC
movsd 0x8(%rsp), %xmm0
movb $0x3, %al
callq 0x8580
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rcx
decl %esi
xorl %r8d, %r8d
pushq $0x2
popq %rdi
movl %esi, %eax
subl %r8d, %eax
cmpl $0x2, %eax
jl 0x196c0
leal (%r8,%rsi), %eax
cltd
idivl %edi
cltq
ucomisd (%rbx,%rax,8), %xmm3
cmoval %eax, %esi
cmoval %r8d, %eax
movl %eax, %r8d
jmp 0x1969c
movl %r8d, (%rcx)
movq 0x1298e6(%rip), %rax    # 0x142fb0
movq (%rax), %rdi
movslq %r8d, %rax
leal 0x1(%r8), %ecx
movsd (%rbx,%rax,8), %xmm0
movsd 0x8(%rbx,%rax,8), %xmm2
leaq 0xcdf9b(%rip), %rsi     # 0xe7681
movl %r8d, %edx
movapd %xmm3, %xmm1
movb $0x3, %al
callq 0x8510
jmp 0x19680
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_hunt_ascending
int array_hunt_ascending(
                          double * array,
                          int size,
                          double value,
                          int * index,
                          ErrorMsg errmsg
                          ) {
  int i_inf,i_sup,i_mid;

  i_inf=0;
  i_sup=size-1;

  /* checks */
  if (array[i_inf] > array[i_sup]) {
    class_sprintf(errmsg,"%s(L:%d) array is not in ascending order (checked only the boundaries)",__func__,__LINE__);
    return _FAILURE_;
  }
  if ((value < array[i_inf]) || (value > array[i_sup])) {
    class_sprintf(errmsg,"%s(L:%d) %e is outside the range [%e, %e]",__func__,__LINE__,value,array[0],array[size-1]);
    return _FAILURE_;
  }

  /* bisection */
  while (i_sup-i_inf>1) {
    i_mid = (i_sup+i_inf)/2;
    if (value > array[i_mid])
      i_inf=i_mid;
    else
      i_sup=i_mid;
  }

  /* result */
  *index = i_inf;

  /* check for debug */
  /*
  fprintf(stderr,
          "Check that array[%d]=%e<%e<array[%d]=%e\n",
          *index,
          array[*index],
          value,
          *index+1,
          array[*index+1]);
  return _FAILURE_;
  */

  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movslq %esi, %r13
movsd (%rdi), %xmm1
movsd -0x8(%rdi,%r13,8), %xmm2
ucomisd %xmm2, %xmm1
jbe 0x1975f
leaq 0xcdf89(%rip), %rbx     # 0xe76aa
leaq 0xcdfc9(%rip), %r15     # 0xe76f1
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xddd, %r8d            # imm = 0xDDD
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xddd, %r8d            # imm = 0xDDD
xorl %eax, %eax
callq 0x8580
jmp 0x197f1
movq %rdi, %rbx
ucomisd %xmm0, %xmm1
ja 0x19798
ucomisd %xmm2, %xmm0
ja 0x19798
movq %rdx, %rcx
decl %esi
xorl %edi, %edi
pushq $0x2
popq %r8
movl %esi, %eax
subl %edi, %eax
cmpl $0x2, %eax
jl 0x197f6
leal (%rdi,%rsi), %eax
cltd
idivl %r8d
cltq
ucomisd (%rbx,%rax,8), %xmm0
cmovbel %eax, %esi
cmoval %eax, %edi
jmp 0x19779
decq %r13
leaq 0xcdeb5(%rip), %r15     # 0xe7657
leaq 0xcdf48(%rip), %r12     # 0xe76f1
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movl $0xde1, %r8d            # imm = 0xDE1
movsd %xmm0, 0x8(%rsp)
movb $0x3, %al
callq 0x8580
incl %eax
movslq %eax, %rsi
movsd (%rbx), %xmm1
movsd (%rbx,%r13,8), %xmm2
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl $0xde1, %r8d            # imm = 0xDE1
movsd 0x8(%rsp), %xmm0
movb $0x3, %al
callq 0x8580
pushq $0x1
popq %rax
jmp 0x197fa
movl %edi, (%rcx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_smooth_Gaussian
int array_smooth_Gaussian(double * x,
                          double * y,
                          double * ysmooth,
                          int length,
                          double sigma,
                          ErrorMsg errmsg){
  int i,j;
  double weight, total;
  double nsig = 3.;

  class_test(sigma<=0.,errmsg,"Cannot smooth with sigma<0 (sigma=%e)",sigma);

  for ( i=0;i<length;++i){
    total = 0.;
    if(abs(x[i]-x[0]) < nsig*sigma || abs(x[i]-x[length-1]) < nsig*sigma){
      ysmooth[i] = y[i];
    }
    else{
      ysmooth[i] = 0.;
      for( j=0;j<length;++j){
        weight = exp(-(x[i]-x[j])*(x[i]-x[j])/(2.*sigma*sigma));
        ysmooth[i] += y[j]*weight;
        total +=weight;
      }
      ysmooth[i]/=total;
    }
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x19949
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0xccf10(%rip), %xmm2    # 0xe6748
mulsd %xmm0, %xmm2
movslq %ecx, %rax
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movl %eax, %r12d
movapd 0xcb9da(%rip), %xmm3    # 0xe5240
xorl %r13d, %r13d
movsd %xmm2, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq %rcx, %r13
je 0x199aa
movsd (%r15,%r13,8), %xmm0
movapd %xmm0, %xmm1
subsd (%r15), %xmm1
andpd %xmm3, %xmm1
ucomisd %xmm1, %xmm2
ja 0x198ac
subsd -0x8(%r15,%rax,8), %xmm0
andpd %xmm3, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x198bd
movsd (%r14,%r13,8), %xmm0
movsd %xmm0, (%rbx,%r13,8)
jmp 0x19941
andq $0x0, (%rbx,%r13,8)
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
cmpq %rbp, %r12
je 0x1991f
movsd %xmm1, 0x28(%rsp)
movsd (%r15,%r13,8), %xmm1
subsd (%r15,%rbp,8), %xmm1
movapd %xmm1, %xmm0
xorpd 0xcb941(%rip), %xmm0    # 0xe5230
mulsd %xmm1, %xmm0
divsd 0x20(%rsp), %xmm0
callq 0x86a0
movsd 0x28(%rsp), %xmm1
addsd %xmm0, %xmm1
mulsd (%r14,%rbp,8), %xmm0
addsd (%rbx,%r13,8), %xmm0
movsd %xmm0, (%rbx,%r13,8)
incq %rbp
jmp 0x198cc
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%r13,8)
movsd 0x18(%rsp), %xmm2
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movapd 0xcb8ff(%rip), %xmm3    # 0xe5240
incq %r13
jmp 0x19879
movq %r8, %r12
leaq 0xcddb3(%rip), %rsi     # 0xe7706
leaq 0x830(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2e014
leaq 0xcb716(%rip), %rsi     # 0xe5082
leaq 0xcddb9(%rip), %rdx     # 0xe772c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xcb6a8(%rip), %rsi     # 0xe5034
leaq 0xcdda3(%rip), %rdx     # 0xe7736
movq %r12, %rdi
movl $0xe0b, %ecx            # imm = 0xE0B
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0x199ac
xorl %eax, %eax
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
callq 0x84b0
movl %eax, %ebx
leaq 0xcd492(%rip), %rax     # 0xe774c
movq %rax, 0x10(%rsp)
leaq 0xcd496(%rip), %rax     # 0xe775c
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
leaq 0x20(%rsp), %r14
leaq 0xf(%rsp), %r15
cmpq $0x10, %r12
je 0x1a32e
movq 0x10(%rsp,%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x8160
movq 0x20(%rsp), %rdi
callq 0x8450
testq %rax, %rax
je 0x1a31a
movq %rax, %rdi
callq 0x8550
leal -0x2001(%rax), %ecx
cmpl $0xffffe000, %ecx       # imm = 0xFFFFE000
setb %bpl
cmovael %eax, %ebx
jmp 0x1a31d
movb $0x1, %bpl
movq %r14, %rdi
callq 0x81a0
addq $0x8, %r12
testb %bpl, %bpl
jne 0x1a2d8
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x58, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1add8
movb %al, 0x10(%rsp)
testb %al, %al
je 0x1ac8f
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
je 0x1ac8f
movq %r14, %rdi
callq 0x1ad36
movq %rbx, %rdi
callq 0x1ad98
movb $0x1, %bl
jmp 0x1ac91
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x1adc2
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
imulq $0xb0, %rax, %r12
movq %rsp, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
xorl %r13d, %r13d
movl (%r14), %ecx
cmpl %ecx, %r13d
je 0x1abf5
leal (%rbx,%r13), %eax
xorl %edx, %edx
divl %ecx
imulq $0xb0, %rdx, %rdi
addq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x1ac4e
incl %r13d
testb %al, %al
je 0x1abcb
cmpq $0x0, 0x10(%rsp)
jne 0x1ac10
movq 0x28(%r14), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x1aca6
testb %al, %al
je 0x1ac22
movq %r15, %rdi
callq 0x1ad26
movq %r15, %rdi
callq 0x1b366
jmp 0x1abbc
movq %rsp, %rdi
callq 0x1b366
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1ac3a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1b366
movq %rbx, %rdi
callq 0x8680
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1ae48
leaq 0x80(%rbx), %r13
movq 0x10(%rbx), %r12
movq 0x30(%rbx), %rbp
cmpq %r12, %rbp
jne 0x1acf2
cmpb $0x0, 0x50(%rbx)
jne 0x1ad05
movq %r13, %rdi
movq %r15, %rsi
callq 0x8100
jmp 0x1acd2
movq %r14, %rdi
movq %r12, %rsi
callq 0x1ad36
movq %rbx, %rdi
callq 0x1ad98
cmpq %r12, %rbp
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x1adc2
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/parser.c
// Function: parser_init
int parser_init(struct file_content * pfc,
                int size,
                char * filename,
                ErrorMsg errmsg) {

  if (size > 0) {
    pfc->size=size;
    class_alloc(pfc->filename,(strlen(filename)+1)*sizeof(char),errmsg);
    strcpy(pfc->filename,filename);
    class_alloc(pfc->name,size*sizeof(FileArg),errmsg);
    class_alloc(pfc->value,size*sizeof(FileArg),errmsg);
    class_alloc(pfc->read,size*sizeof(short),errmsg);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
xorl %ebp, %ebp
testl %esi, %esi
jle 0x1c581
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movq %rdx, %rdi
callq 0x8190
leaq 0x1(%rax), %rdi
callq 0x8490
movq %rax, (%r14)
testq %rax, %rax
je 0x1c4da
movq %rax, %rdi
movq %r15, %rsi
callq 0x8370
movl %r12d, %r15d
movq %r15, %r12
shlq $0xa, %r12
movq %r12, %rdi
callq 0x8490
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x1c512
movq %r12, %rdi
callq 0x8490
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x1c542
addq %r15, %r15
movq %r15, %rdi
callq 0x8490
movq %rax, 0x20(%r14)
testq %rax, %rax
jne 0x1c581
leaq 0xc8b56(%rip), %rsi     # 0xe5004
leaq 0xcb5f1(%rip), %rdx     # 0xe7aa6
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xc8b68(%rip), %rsi     # 0xe5034
leaq 0xcb5b2(%rip), %rdx     # 0xe7a85
pushq $0x3c
jmp 0x1c570
movq %r15, %rdi
callq 0x8190
leal 0x1(%rax), %ecx
leaq 0xc8b18(%rip), %rsi     # 0xe5004
leaq 0xcb584(%rip), %rdx     # 0xe7a77
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xc8b2d(%rip), %rsi     # 0xe5034
leaq 0xcb577(%rip), %rdx     # 0xe7a85
pushq $0x38
jmp 0x1c570
leaq 0xc8aeb(%rip), %rsi     # 0xe5004
leaq 0xcb571(%rip), %rdx     # 0xe7a91
movq %rsp, %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xc8afd(%rip), %rsi     # 0xe5034
leaq 0xcb547(%rip), %rdx     # 0xe7a85
pushq $0x3a
jmp 0x1c570
leaq 0xc8abb(%rip), %rsi     # 0xe5004
leaq 0xcb54b(%rip), %rdx     # 0xe7a9b
movq %rsp, %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xc8acd(%rip), %rsi     # 0xe5034
leaq 0xcb517(%rip), %rdx     # 0xe7a85
pushq $0x3b
popq %rcx
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x8(%rdi)
jle 0x1c5c1
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq 0x20(%rbx), %rdi
callq 0x8430
movq (%rbx), %rdi
callq 0x8430
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/parser.c
// Function: parser_read_string
int parser_read_string(struct file_content * pfc,
                       char * name,
                       FileArg * value,
                       int * found,
                       ErrorMsg errmsg) {
  int index;
  int i;

  /* intialize the 'found' flag to false */

  * found = _FALSE_;

  /* search parameter */

  index=0;
  while ((index < pfc->size) && (strcmp(pfc->name[index],name) != 0)){
		// printf("reading %s \n", pfc->name[index]);
		index++;

	}

  /* if parameter not found, return with 'found' flag still equal to false */

  if (index == pfc->size)
    return _SUCCESS_;

  /* read parameter value. */

  strcpy(*value,pfc->value[index]);

  /* Set 'found' flag to true, as well as the flag
     associated with this parameter in the file_content structure */

  * found = _TRUE_;
  pfc->read[index] = _TRUE_;

  /* check for multiple entries of the same parameter. If another occurence is found,
     return an error. */

  for (i=index+1; i < pfc->size; i++) {
    class_test(strcmp(pfc->name[i],name) == 0,
               errmsg,
               "multiple entry of parameter '%s' in file '%s'\n",name,pfc->filename);
  }

  /* if everything proceeded normally, return with 'found' flag equal to true */

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %r8, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rcx, 0x18(%rsp)
andl $0x0, (%rcx)
movq %rdi, %r15
movl 0x8(%rdi), %ebx
xorl %ebp, %ebp
testl %ebx, %ebx
movl $0x0, %r12d
cmovgl %ebx, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x1cb5d
movq 0x10(%r15), %rdi
addq %rbp, %rdi
movq %r14, %rsi
callq 0x84e0
testl %eax, %eax
je 0x1cb5a
incq %r13
addq $0x400, %rbp            # imm = 0x400
jmp 0x1cb36
movl %r13d, %r12d
xorl %eax, %eax
cmpl %ebx, %r12d
je 0x1cc35
movl %r12d, %r13d
movq %r13, %rbx
shlq $0xa, %rbx
movq 0x18(%r15), %rsi
addq %rbx, %rsi
movq 0x10(%rsp), %rdi
callq 0x8370
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movq 0x20(%r15), %rax
movw $0x1, (%rax,%r13,2)
movl 0x8(%r15), %r13d
addq $0x400, %rbx            # imm = 0x400
incl %r12d
cmpl %r12d, %r13d
jle 0x1cc33
leaq 0x400(%rbx), %rbp
addq 0x10(%r15), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e0
movq %rbp, %rbx
testl %eax, %eax
jne 0x1cba4
movq (%r15), %rcx
leaq 0xcb079(%rip), %rsi     # 0xe7c50
leaq 0x820(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2e014
leaq 0xc848f(%rip), %rsi     # 0xe5082
leaq 0xcb085(%rip), %rdx     # 0xe7c7f
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xc8421(%rip), %rsi     # 0xe5034
leaq 0xcb0e2(%rip), %rdx     # 0xe7cfc
movq 0x8(%rsp), %rdi
movl $0x167, %ecx            # imm = 0x167
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
jmp 0x1cc35
xorl %eax, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/parser.c
// Function: parser_extend
int parser_extend(struct file_content * pfc, int N_extend, ErrorMsg errmsg) {
  // Append N_extend empty entries in the vectors of pfc
  pfc->size += N_extend;
  class_realloc(pfc->name,  pfc->size*sizeof(FileArg), errmsg);
  class_realloc(pfc->value, pfc->size*sizeof(FileArg), errmsg);
  class_realloc(pfc->read,  pfc->size*sizeof(short),   errmsg);
  for (int index = pfc->size - N_extend; index < pfc->size; index++) {
    pfc->name[index][0] = '\0';
    pfc->value[index][0] = '\0';
    pfc->read[index] = _FALSE_;
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x8(%rdi), %rax
movslq %esi, %rsi
addq %rax, %rsi
movl %esi, 0x8(%rdi)
movq 0x10(%rdi), %rdi
shlq $0xa, %rsi
callq 0x85c0
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x1dba4
movq 0x18(%r14), %rdi
movslq 0x8(%r14), %rsi
shlq $0xa, %rsi
callq 0x85c0
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x1dbde
movq 0x20(%r14), %rdi
movslq 0x8(%r14), %rsi
addq %rsi, %rsi
callq 0x85c0
movq %rax, 0x20(%r14)
movl 0x8(%r14), %ecx
testq %rax, %rax
je 0x1dc18
movl %ecx, %eax
subl %ebp, %eax
movslq %eax, %rdx
movq %rdx, %rsi
shlq $0xa, %rsi
xorl %eax, %eax
movslq %ecx, %rcx
cmpq %rcx, %rdx
jge 0x1dc58
movq 0x10(%r14), %rcx
movb %al, (%rcx,%rsi)
movq 0x18(%r14), %rcx
movb %al, (%rcx,%rsi)
movq 0x20(%r14), %rcx
andw $0x0, (%rcx,%rdx,2)
incq %rdx
movl 0x8(%r14), %ecx
addq $0x400, %rsi            # imm = 0x400
jmp 0x1db71
movl 0x8(%r14), %ecx
shll $0xa, %ecx
leaq 0xc7452(%rip), %rsi     # 0xe5004
leaq 0xc9ed8(%rip), %rdx     # 0xe7a91
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xc7467(%rip), %rsi     # 0xe5034
leaq 0xca2e5(%rip), %rdx     # 0xe7eb9
movq %rbx, %rdi
movl $0x2ec, %ecx            # imm = 0x2EC
jmp 0x1dc4b
movl 0x8(%r14), %ecx
shll $0xa, %ecx
leaq 0xc7418(%rip), %rsi     # 0xe5004
leaq 0xc9ea8(%rip), %rdx     # 0xe7a9b
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xc742d(%rip), %rsi     # 0xe5034
leaq 0xca2ab(%rip), %rdx     # 0xe7eb9
movq %rbx, %rdi
movl $0x2ed, %ecx            # imm = 0x2ED
jmp 0x1dc4b
addl %ecx, %ecx
leaq 0xc73e3(%rip), %rsi     # 0xe5004
leaq 0xc9e7e(%rip), %rdx     # 0xe7aa6
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xc73f8(%rip), %rsi     # 0xe5034
leaq 0xca276(%rip), %rdx     # 0xe7eb9
movq %rbx, %rdi
movl $0x2ee, %ecx            # imm = 0x2EE
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %rbx
movq %rbx, %r13
shlq $0xa, %r13
movq 0x10(%rsi), %rdi
addq %r13, %rdi
movq 0x10(%r14), %rsi
addq %r13, %rsi
subl %ebx, %ecx
movslq %ecx, %r12
movq %r12, %rbp
shlq $0xa, %rbp
movq %rbp, %rdx
callq 0x82f0
movq 0x18(%r15), %rdi
addq %r13, %rdi
addq 0x18(%r14), %r13
movq %r13, %rsi
movq %rbp, %rdx
callq 0x82f0
addq %rbx, %rbx
movq 0x20(%r15), %rdi
addq %rbx, %rdi
addq 0x20(%r14), %rbx
addq %r12, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x82f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %esi
movq (%rdi), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1c40b
testl %eax, %eax
je 0x1dd51
leaq 0xc76db(%rip), %rsi     # 0xe53f0
leaq 0xca1ab(%rip), %rdx     # 0xe7ec7
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xc7301(%rip), %rsi     # 0xe5034
leaq 0xca1da(%rip), %rdx     # 0xe7f14
movq %rbx, %rdi
movl $0x304, %ecx            # imm = 0x304
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbx
jmp 0x1dd64
movl 0x8(%r15), %ecx
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1dc64
movl %ebx, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1f33c
callq 0x1f311
movq 0x30(%rbx), %rdi
callq 0x1f311
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movl 0x20(%rax), %eax
addl 0x20(%rcx), %eax
jmp 0x1f33f
pushq $0x1
popq %rax
movl %eax, 0x20(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl %esi, 0x20(%rdi)
jle 0x1f374
movl %esi, %ebx
movq 0x28(%r14), %rdi
callq 0x1f346
movsd %xmm0, (%rsp)
movq 0x30(%r14), %rdi
movl %ebx, %esi
callq 0x1f346
addsd (%rsp), %xmm0
jmp 0x1f379
movsd (%r14), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl %ebp, 0x20(%rbx)
je 0x1f3a1
jle 0x1f3ba
movq 0x28(%rbx), %rdi
movl %ebp, %esi
callq 0x1f381
movq 0x30(%rbx), %rbx
jmp 0x1f389
movq 0x28(%rbx), %rdi
callq 0x1f460
movq 0x30(%rbx), %rdi
callq 0x1f460
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
cmpl $0x1, 0x20(%r12)
je 0x1f3ff
movq 0x28(%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x1f3c3
movq 0x30(%r12), %r12
jmp 0x1f3da
movq 0x10(%r12), %rax
movq 0x18(%r12), %rcx
xorl %edx, %edx
cmpl $0x1, %ebp
setne %dl
leaq -0x1(,%rdx,2), %rsi
movslq (%rbx), %rdi
movl %edi, %edx
leaq (%r15,%rdi,8), %r8
leaq (%r14,%rdi,8), %r9
xorl %edi, %edi
xorl %r10d, %r10d
cmpq $0xf, %r10
je 0x1f451
movsd (%rax,%r10,8), %xmm0
movsd %xmm0, (%r8,%rdi,8)
movsd (%rcx,%r10,8), %xmm0
movsd %xmm0, (%r9,%rdi,8)
incq %r10
addq %rsi, %rdi
jmp 0x1f42b
addl %edi, %edx
movl %edx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x1f4a0
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1f477
callq 0x1f460
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1f485
callq 0x1f460
movq 0x10(%rbx), %rdi
callq 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x8430
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/quadrature.c
// Function: sort_x_and_w
int sort_x_and_w(double *x, double *w, double *workx, double *workw, int startidx, int endidx){
  int i,top=endidx,bot=startidx;
  double pivot;
  /* End recursion if only one element left in array: */
  if ((endidx-startidx)<1){
    return _SUCCESS_;
  }
  else{
    /*Copy x and w to workarray: */
    for (i=startidx; i<=endidx; i++){
      workx[i] = x[i];
      workw[i] = w[i];
    }
    pivot = x[endidx];
    //printf("pivot chosen: x[%d] = %g\n",endidx,pivot);
    for (i=startidx; i<endidx; i++){
      if (workx[i]<=pivot){
	//printf("<--%g  ",workx[i]);
	x[bot] = workx[i];
	w[bot++] = workw[i];
      }
      else{
	//printf("  %g-->",workx[i]);
	x[top] = workx[i];
	w[top--] = workw[i];
      }
    }
    //printf("\n top=%d, bot=%d, left=%d, right=%d\n",top,bot,startidx,endidx);
    x[top] = pivot;
    w[top] = workw[endidx];
    /* Recursive call: */
    sort_x_and_w(x,w,workx,workw,startidx,bot-1);
    sort_x_and_w(x,w,workx,workw,top+1,endidx);
    return _SUCCESS_;
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movslq %r9d, %rbp
movl %r9d, 0x4(%rsp)
cmpl %r9d, %r8d
jge 0x1f575
movslq %r8d, %rax
movq %rax, %rcx
cmpq %rbp, %rcx
jg 0x1f4f4
movsd (%r13,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rcx,8)
movsd (%r12,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
jmp 0x1f4d1
movsd (%r13,%rbp,8), %xmm0
movl %r9d, %ecx
movl %r8d, %r9d
movslq %ecx, %rbx
cmpq %rbp, %rax
jge 0x1f53f
movsd (%r15,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
jae 0x1f521
movsd %xmm1, (%r13,%rbx,8)
leal -0x1(%rbx), %ecx
jmp 0x1f52e
movslq %r9d, %rbx
movsd %xmm1, (%r13,%rbx,8)
incl %r9d
movsd (%r14,%rax,8), %xmm1
movsd %xmm1, (%r12,%rbx,8)
incq %rax
jmp 0x1f501
movsd %xmm0, (%r13,%rbx,8)
movsd (%r14,%rbp,8), %xmm0
movsd %xmm0, (%r12,%rbx,8)
decl %r9d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1f4a3
incl %ebx
movl %ebx, %r8d
movl 0x4(%rsp), %r9d
jmp 0x1f4c2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r10d
movq %rsi, %rbx
pushq $0x2
popq %rsi
movl %edx, %eax
cltd
idivl %esi
movl %eax, %r14d
movslq %r10d, %rax
andq $0x0, -0x8(%rbx,%rax,8)
movq %rdi, %r15
movl %ecx, 0x4(%rsp)
cvtsi2sd %ecx, %xmm0
addsd 0xc604d(%rip), %xmm0    # 0xe57e8
mulsd 0xc650d(%rip), %xmm0    # 0xe5cb0
movslq %r14d, %r12
leaq (%rdi,%r12,8), %rdi
leaq (%rbx,%r12,8), %rsi
movl %r12d, %edx
movq %r8, %rcx
movq %r9, %r8
xorl %r9d, %r9d
callq 0x1e002
leal (%r12,%r12), %r13d
movslq %r13d, %rbp
xorpd %xmm1, %xmm1
movsd 0xc64de(%rip), %xmm2    # 0xe5cb0
cmpq %rbp, %r12
jge 0x1f815
movsd (%r15,%r12,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x1f7e9
sqrtsd %xmm0, %xmm0
jmp 0x1f7fa
callq 0x82d0
movsd 0xc64ba(%rip), %xmm2    # 0xe5cb0
xorpd %xmm1, %xmm1
movsd %xmm0, (%r15,%r12,8)
movsd (%rbx,%r12,8), %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, (%rbx,%r12,8)
incq %r12
jmp 0x1f7d2
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
decl %r13d
movapd 0xc5a07(%rip), %xmm0    # 0xe5230
movl 0x4(%rsp), %edx
cmpq %rax, %r14
je 0x1f860
movslq %r13d, %rcx
movsd (%r15,%rcx,8), %xmm1
xorpd %xmm0, %xmm1
movlpd %xmm1, (%r15,%rax,8)
movsd (%rbx,%rcx,8), %xmm1
testb $0x1, %dl
je 0x1f853
xorpd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
decl %r13d
jmp 0x1f82d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/quadrature.c
// Function: quadrature_in_rectangle
int quadrature_in_rectangle(
			    double xl,
			    double xr,
			    double yl,
			    double yr,
			    int *n,
			    double ** x,
			    double ** y,
			    double ** w,
			    ErrorMsg error_message) {


  double xl_tile,xr_tile,yl_tile,yr_tile;
  int N;

  N=24;
  xl_tile = xl;
  xr_tile = xr;
  yl_tile = yl;
  yr_tile = yr;

  *n = N;


  class_alloc(*x,sizeof(double)*N,error_message);
  class_alloc(*y,sizeof(double)*N,error_message);
  class_alloc(*w,sizeof(double)*N,error_message);
  class_call(cubature_order_eleven(xl_tile,
				   xr_tile,
				   yl_tile,
				   yr_tile,
				   *x+0,
				   *y+0,
				   *w+0,
				   error_message),
	     error_message,
	     error_message);


  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl $0x18, (%rdi)
movl $0xc0, %edi
callq 0x8490
movq %rax, (%r15)
testq %rax, %rax
je 0x1fb58
movl $0xc0, %edi
callq 0x8490
movq %rax, (%r14)
testq %rax, %rax
je 0x1fb92
movl $0xc0, %edi
callq 0x8490
movq %rax, (%r12)
testq %rax, %rax
je 0x1fbcc
movq (%r15), %rdi
movq (%r14), %rsi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
movq %rax, %rdx
callq 0x1fc20
xorl %eax, %eax
jmp 0x1fc11
leaq 0xc54a5(%rip), %rsi     # 0xe5004
leaq 0xc5a8b(%rip), %rdx     # 0xe55f1
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0xc0, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xc54b3(%rip), %rsi     # 0xe5034
leaq 0xc883d(%rip), %rdx     # 0xe83c5
movq %rbx, %rdi
movl $0x327, %ecx            # imm = 0x327
jmp 0x1fc04
leaq 0xc546b(%rip), %rsi     # 0xe5004
leaq 0xc883d(%rip), %rdx     # 0xe83dd
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0xc0, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xc5479(%rip), %rsi     # 0xe5034
leaq 0xc8803(%rip), %rdx     # 0xe83c5
movq %rbx, %rdi
movl $0x328, %ecx            # imm = 0x328
jmp 0x1fc04
leaq 0xc5431(%rip), %rsi     # 0xe5004
leaq 0xc8806(%rip), %rdx     # 0xe83e0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0xc0, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xc543f(%rip), %rsi     # 0xe5034
leaq 0xc87c9(%rip), %rdx     # 0xe83c5
movq %rbx, %rdi
movl $0x329, %ecx            # imm = 0x329
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: hyperspherical_get_xmin_from_approx
int hyperspherical_get_xmin_from_approx(int K,
                                        int l,
                                        double nu,
                                        double ignore1,
                                        double phiminabs,
                                        double *xmin,
                                        int *ignore2){

  double l_plus_half;
  double lhs;
  double alpha;
  double ldbl = l;
  double x;

  l_plus_half = l+0.5;
  lhs = 1.0/l_plus_half*log(2*phiminabs*l_plus_half);
  //Using Chebyshev cubic root, much cleaner:
  alpha = -2.0*lhs/5.0*(1.0+2.0*cosh(1.0/3.0*acosh(1.0+375.0/(16.0*lhs*lhs))));
  x = l_plus_half/cosh(alpha)/nu;
  if (K==-1){
    //%Correct for open case:
    x *= asinh(ldbl/nu)/(ldbl/nu);
    //...and fudge for small nu:
    x *=((nu+0.4567)/(nu+1.24)-2.209e-3);
  }
  else if(K==1){
    //Correct for closed case if possible
    x *= asin(ldbl/nu)/(ldbl/nu);
  }
  *xmin = x;
  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movaps %xmm0, 0x20(%rsp)
cvtsi2sd %esi, %xmm0
movl %edi, %ebp
movsd 0xc4f5e(%rip), %xmm1    # 0xe5cb0
movapd %xmm0, 0x10(%rsp)
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0xc44f7(%rip), %xmm0    # 0xe5260
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
addsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
movapd %xmm2, %xmm0
callq 0x82e0
mulsd 0x8(%rsp), %xmm0
movsd 0xc59a6(%rip), %xmm1    # 0xe6738
mulsd %xmm0, %xmm1
divsd 0xc44d2(%rip), %xmm1    # 0xe5270
movsd %xmm1, 0x8(%rsp)
movsd 0xc4a4c(%rip), %xmm1    # 0xe57f8
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd 0xc7644(%rip), %xmm0    # 0xe8400
divsd %xmm1, %xmm0
addsd 0xc4498(%rip), %xmm0    # 0xe5260
callq 0x8660
mulsd 0xc7633(%rip), %xmm0    # 0xe8408
callq 0x84d0
addsd %xmm0, %xmm0
addsd 0xc447a(%rip), %xmm0    # 0xe5260
mulsd 0x8(%rsp), %xmm0
callq 0x84d0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd 0x20(%rsp), %xmm2
divsd %xmm2, %xmm1
cmpl $0x1, %ebp
je 0x20e79
cmpl $-0x1, %ebp
jne 0x20ea2
movapd 0x10(%rsp), %xmm0
divsd %xmm2, %xmm0
movapd %xmm0, 0x10(%rsp)
movsd %xmm1, (%rsp)
callq 0x84a0
movsd 0xc75dc(%rip), %xmm1    # 0xe8410
movapd 0x20(%rsp), %xmm2
addsd %xmm2, %xmm1
addsd 0xc75d2(%rip), %xmm2    # 0xe8418
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
unpcklpd 0x10(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
divpd %xmm2, %xmm1
movsd 0xc75c4(%rip), %xmm0    # 0xe8420
addsd %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
movsd (%rsp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd (%rsp), %xmm1
jmp 0x20e9e
movapd 0x10(%rsp), %xmm0
divsd %xmm2, %xmm0
movapd %xmm0, 0x10(%rsp)
movsd %xmm1, (%rsp)
callq 0x85d0
movsd (%rsp), %xmm1
divsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x8430
movq 0x28(%rbx), %rdi
callq 0x8430
movq 0x38(%rbx), %rdi
callq 0x8430
movq 0x40(%rbx), %rdi
callq 0x8430
movq 0x48(%rbx), %rdi
callq 0x8430
movq 0x50(%rbx), %rdi
callq 0x8430
movq 0x58(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq