LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_tdfs
int sp_tdfs(int j, int k, int *head, const int *next, int *post, int *stack){
	int i, p, top =0;
	stack[0] = j;
	while(top>=0){
		p = stack[top];
		i = head[p];
		if (i==-1){
			top--;
			post[k++] = p;
		}
		else{
			head[p] = next[i];
			stack[++top] = i;
		}
	}
	return (k);
}

// Assembly:
pushq %rbx
movl %esi, %eax
movl %edi, (%r9)
xorl %esi, %esi
movl %esi, %edi
movl (%r9,%rdi,4), %r10d
movslq %r10d, %rbx
movslq (%rdx,%rbx,4), %r11
cmpq $-0x1, %r11
je 0xcf3a
movl (%rcx,%r11,4), %r10d
movl %r10d, (%rdx,%rbx,4)
incl %esi
movl %r11d, 0x4(%r9,%rdi,4)
jmp 0xcf45
decl %esi
movslq %eax, %rdi
incl %eax
movl %r10d, (%r8,%rdi,4)
testl %esi, %esi
jns 0xcf16
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: lubksb
int lubksb(double **a, int n, int *indx, double b[]){
  int i,ii=0,ip,j;
  double sum;
  for (i=1;i<=n;i++) {
    ip=indx[i];
    sum=b[ip];
    b[ip]=b[i];
    if (ii) for (j=ii;j<=i-1;j++) sum -= a[i][j]*b[j];
    else if (sum) ii=i;
    b[i]=sum;
  }
  for (i=n;i>=1;i--) {
    sum=b[i];
    for (j=i+1;j<=n;j++) sum -= a[i][j]*b[j];
    b[i]=sum/a[i][i];
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rbx
testl %esi, %esi
jle 0x116c1
leal 0x1(%rsi), %eax
xorl %r9d, %r9d
movl $0x1, %r8d
xorpd %xmm0, %xmm0
movslq (%rdx,%r8,4), %r10
movsd (%rcx,%r10,8), %xmm1
movsd (%rcx,%r8,8), %xmm2
movsd %xmm2, (%rcx,%r10,8)
testl %r9d, %r9d
je 0x116a3
movslq %r9d, %r10
cmpq %r10, %r8
jle 0x116b3
movq (%rdi,%r8,8), %r11
movsd (%r11,%r10,8), %xmm2
mulsd (%rcx,%r10,8), %xmm2
subsd %xmm2, %xmm1
incq %r10
cmpq %r10, %r8
jne 0x11689
jmp 0x116b3
ucomisd %xmm0, %xmm1
jne 0x116ab
jnp 0x116b0
movl %r8d, %r9d
jmp 0x116b3
xorl %r9d, %r9d
movsd %xmm1, (%rcx,%r8,8)
incq %r8
cmpq %rax, %r8
jne 0x11662
testl %esi, %esi
jle 0x1172f
movl %esi, %eax
leaq 0x8(,%rax,8), %rdx
leaq (%rcx,%rax,8), %r8
addq $0x8, %r8
movq %rax, %r9
movsd (%rcx,%r9,8), %xmm0
cmpq %rax, %r9
jge 0x1170a
movq (%rdi,%r9,8), %r10
addq %rdx, %r10
xorl %r11d, %r11d
movsd (%r10,%r11,8), %xmm1
mulsd (%r8,%r11,8), %xmm1
subsd %xmm1, %xmm0
incq %r11
leal (%r9,%r11), %ebx
cmpl %esi, %ebx
jl 0x116ef
movq (%rdi,%r9,8), %r10
divsd (%r10,%r9,8), %xmm0
movsd %xmm0, (%rcx,%r9,8)
leaq -0x1(%r9), %r10
addq $-0x8, %r8
addq $-0x8, %rdx
cmpq $0x1, %r9
movq %r10, %r9
jg 0x116da
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: interp_from_dif
int interp_from_dif(double tinterp,
                    double tnew,
                    double *ynew,
                    double h,
                    double **dif,
                    int k,
                    double *yinterp,
                    double *ypinterp,
                    double *yppinterp,
                    int* mask,
                    int neq,
                    int output){
  /* Output=1: only y_vector. Output=2: y and y prime. Output=3: y, yp and ypp*/
  double fact,prod,sumfrac;
  double vecy[5]={0.,0.,0.,0.,0.};
  double vecdy[5]={0.,0.,0.,0.,0.};
  int j, index_x;
  double s, sumtmp, sumtmp2;

  s = (tinterp - tnew)/h;

  prod = 1.0;
  sumfrac = 0.;
  fact = 1.0;
  for (j=0; j<k; j++){
    prod *= (s+j);
    fact *= (j+1);
    sumfrac += 1.0/(s+j);
    vecy[j] = prod/fact;
    vecdy[j] = prod*sumfrac/(h*fact);
  }

  for (index_x=1; index_x<=neq; index_x++){
    if (mask[index_x]==_TRUE_){
      sumtmp = 0;
      sumtmp2 = 0;
      for (j=0; j<k; j++){
        sumtmp += vecy[j]*dif[index_x][j+1];
        sumtmp2 += vecdy[j]*dif[index_x][j+1];
      }
      yinterp[index_x] = ynew[index_x] + sumtmp;
      ypinterp[index_x] = sumtmp2;
    }
  }
  return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x28(%rsp), %eax
xorpd %xmm3, %xmm3
movapd %xmm3, -0x20(%rsp)
movapd %xmm3, -0x30(%rsp)
xorl %r9d, %r9d
movq %r9, -0x10(%rsp)
movq %r9, -0x40(%rsp)
movapd %xmm3, -0x50(%rsp)
movapd %xmm3, -0x60(%rsp)
movl %edx, %r9d
testl %edx, %edx
jle 0x117e9
subsd %xmm1, %xmm0
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
movsd 0xdfae0(%rip), %xmm3    # 0xf1260
xorl %r10d, %r10d
movapd %xmm3, %xmm4
movapd %xmm3, %xmm5
xorps %xmm6, %xmm6
cvtsi2sd %r10d, %xmm6
addsd %xmm0, %xmm6
leaq 0x1(%r10), %r11
xorps %xmm7, %xmm7
cvtsi2sd %r11d, %xmm7
mulsd %xmm6, %xmm5
mulsd %xmm7, %xmm4
movapd %xmm3, %xmm7
divsd %xmm6, %xmm7
addsd %xmm7, %xmm1
movapd %xmm5, %xmm6
divsd %xmm4, %xmm6
movsd %xmm6, -0x30(%rsp,%r10,8)
movapd %xmm5, %xmm6
mulsd %xmm1, %xmm6
movapd %xmm4, %xmm7
mulsd %xmm2, %xmm7
divsd %xmm7, %xmm6
movsd %xmm6, -0x60(%rsp,%r10,8)
movq %r11, %r10
cmpq %r11, %r9
jne 0x1178b
testl %eax, %eax
jle 0x11861
movq 0x20(%rsp), %r10
incl %eax
movl $0x1, %r11d
cmpl $0x1, (%r10,%r11,4)
jne 0x11859
testl %edx, %edx
jle 0x1183f
movq (%rsi,%r11,8), %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movsd -0x30(%rsp,%r14,8), %xmm1
movhpd -0x60(%rsp,%r14,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movsd 0x8(%rbx,%r14,8), %xmm2
leaq 0x1(%r14), %r15
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
addpd %xmm2, %xmm0
movq %r15, %r14
cmpq %r15, %r9
jne 0x11810
jmp 0x11843
xorpd %xmm0, %xmm0
movsd (%rdi,%r11,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%r11,8)
movhpd %xmm0, (%r8,%r11,8)
incq %r11
cmpq %rax, %r11
jne 0x117fa
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: uninitialize_jacobian
int uninitialize_jacobian(struct jacobian *jac){
  free(jac->dfdy[1]);
  free(jac->dfdy);
  free(jac->LU[1]);
  free(jac->LU);

  free(jac->luidx);
  free(jac->LUw);
  free(jac->jacvec);

  if(jac->sparse_stuff_initialized){
    free(jac->xjac);
    free(jac->col_wi);
    free(jac->col_group);
    free(jac->Cp);
    free(jac->Ci);
    sp_mat_free(jac->spJ);
    sp_num_free(jac->Numerical);
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x8410
movq (%rbx), %rdi
callq 0x8410
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8410
movq 0x10(%rbx), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x8(%rbx), %rdi
callq 0x8410
cmpl $0x0, 0x2c(%rbx)
je 0x118fd
movq 0x70(%rbx), %rdi
callq 0x8410
movq 0x58(%rbx), %rdi
callq 0x8410
movq 0x50(%rbx), %rdi
callq 0x8410
movq 0x80(%rbx), %rdi
callq 0x8410
movq 0x88(%rbx), %rdi
callq 0x8410
movq 0x68(%rbx), %rdi
callq 0xb29a
movq 0x78(%rbx), %rdi
callq 0xb734
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: uninitialize_numjac_workspace
int uninitialize_numjac_workspace(struct numjac_workspace * nj_ws){
  /* Deallocate vectors and matrices: */
  free(nj_ws->yscale);
  free(nj_ws->del);
  free(nj_ws->Difmax);
  free(nj_ws->absFdelRm);
  free(nj_ws->absFvalue);
  free(nj_ws->absFvalueRm);
  free(nj_ws->Fscale);
  free(nj_ws->ffdel);
  free(nj_ws->yydel);
  free(nj_ws->tmp);

  free(nj_ws->ydel_Fdel[1]);
  free(nj_ws->ydel_Fdel);
  free(nj_ws->logj);
  free(nj_ws->Rowmax);
  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8410
movq 0x8(%rbx), %rdi
callq 0x8410
movq 0x10(%rbx), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movq 0x28(%rbx), %rdi
callq 0x8410
movq 0x30(%rbx), %rdi
callq 0x8410
movq 0x38(%rbx), %rdi
callq 0x8410
movq 0x40(%rbx), %rdi
callq 0x8410
movq 0x48(%rbx), %rdi
callq 0x8410
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8410
movq 0x50(%rbx), %rdi
callq 0x8410
movq 0x58(%rbx), %rdi
callq 0x8410
movq 0x60(%rbx), %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_spline_table_line_to_line
int array_integrate_spline_table_line_to_line(
					      double * x_array,
					      int n_lines,
					      double * array,
					      int n_columns,
					      int index_y,
					      int index_ddy,
					      int index_inty,
					      ErrorMsg errmsg) {

  int i;

  double h;

  *(array+0*n_columns+index_inty)  = 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)
    *(array+(i+1)*n_columns+index_inty) = *(array+i*n_columns+index_inty) +
      (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:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x20(%rsp), %rax
movq $0x0, (%rdx,%rax,8)
cmpl $0x2, %esi
jl 0x1342e
decl %esi
movslq %ecx, %rbx
movslq %r8d, %rcx
movslq %r9d, %r8
shlq $0x3, %r8
leaq (,%rbx,8), %r9
shlq $0x3, %rcx
shlq $0x3, %rax
leaq (%r8,%rbx,8), %r10
leaq (%rcx,%rbx,8), %r11
leaq (%rax,%rbx,8), %rbx
xorl %r14d, %r14d
movsd 0xde903(%rip), %xmm0    # 0xf1cd0
movsd 0xdf2a3(%rip), %xmm1    # 0xf2678
movsd 0x8(%rdi,%r14,8), %xmm2
subsd (%rdi,%r14,8), %xmm2
leaq 0x1(%r14), %r15
movsd (%rdx,%rcx), %xmm3
addsd (%rdx,%r11), %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm0, %xmm3
addsd (%rdx,%rax), %xmm3
movsd (%rdx,%r8), %xmm4
addsd (%rdx,%r10), %xmm4
mulsd %xmm2, %xmm4
mulsd %xmm2, %xmm4
mulsd %xmm2, %xmm4
divsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rdx,%rbx)
addq %r9, %rdx
movq %r15, %r14
cmpq %r15, %rsi
jne 0x133d5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rsp), %rax
movq $0x0, (%rax)
cmpl $0x2, %edx
jl 0x17496
decl %edx
movslq %esi, %rsi
movslq %ecx, %rcx
movslq %r8d, %r10
movslq %r9d, %r9
leaq (%rdi,%rcx,8), %r8
leaq (%rdi,%r10,8), %rcx
leaq (%rdi,%r9,8), %rdi
shlq $0x3, %rsi
xorpd %xmm0, %xmm0
movsd 0xda891(%rip), %xmm1    # 0xf1cd0
movsd 0xdb231(%rip), %xmm2    # 0xf2678
movsd (%r8,%rsi), %xmm3
subsd (%r8), %xmm3
addq %rsi, %r8
movsd (%rcx), %xmm4
addsd (%rcx,%rsi), %xmm4
movsd (%rdi), %xmm5
addsd (%rdi,%rsi), %xmm5
addq %rsi, %rcx
mulsd %xmm3, %xmm4
mulsd %xmm3, %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm1, %xmm4
mulsd %xmm3, %xmm5
divsd %xmm2, %xmm5
addsd %xmm4, %xmm5
addq %rsi, %rdi
addsd %xmm5, %xmm0
movsd %xmm0, (%rax)
decq %rdx
jne 0x17447
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
cmpl $0x2, %esi
jl 0x1753f
decl %esi
movslq %ecx, %r11
movslq %r8d, %rcx
movslq %r9d, %r8
shlq $0x3, %r8
leaq (,%r11,8), %r9
shlq $0x3, %rcx
leaq (%r8,%r11,8), %r10
leaq (%rcx,%r11,8), %r11
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
movsd 0xda7ee(%rip), %xmm1    # 0xf1cd0
movsd 0xdb18e(%rip), %xmm2    # 0xf2678
movsd 0x8(%rdi,%rbx,8), %xmm3
subsd (%rdi,%rbx,8), %xmm3
movsd (%rdx,%rcx), %xmm4
addsd (%rdx,%r11), %xmm4
leaq 0x1(%rbx), %r14
mulsd %xmm3, %xmm4
mulsd %xmm1, %xmm4
movsd (%rdx,%r8), %xmm5
addsd (%rdx,%r10), %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm3, %xmm5
divsd %xmm2, %xmm5
addsd %xmm4, %xmm5
addsd %xmm5, %xmm0
movsd %xmm0, (%rax)
addq %r9, %rdx
movq %r14, %rbx
cmpq %r14, %rsi
jne 0x174ea
xorl %eax, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate
int array_integrate(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y,
		   int index_int_y_dx,
		   ErrorMsg errmsg) {

  int i;
  double sum;

  if ((index_int_y_dx == index_x) || (index_int_y_dx == index_y)) {
    class_sprintf(errmsg,"%s(L:%d) : Output column %d must differ from input columns %d and %d",__func__,__LINE__,index_int_y_dx,index_x,index_y);
    return _FAILURE_;
  }

  sum=0.;
  *(array+0*n_columns+index_int_y_dx)=sum;

  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));

    *(array+i*n_columns+index_int_y_dx)=sum;
  }


  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %ebx
cmpl %ecx, %r9d
setne %al
cmpl %r8d, %r9d
setne %cl
testb %cl, %al
jne 0x1774f
movq 0x40(%rsp), %r15
leaq 0xdb679(%rip), %r12     # 0xf2d74
leaq 0xdb99e(%rip), %r13     # 0xf30a0
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rdx
movq %r13, %rcx
movl $0x62f, %r8d            # imm = 0x62F
movl %ebp, %r9d
xorl %eax, %eax
pushq %r14
pushq %rbx
callq 0x8550
addq $0x10, %rsp
incl %eax
movslq %eax, %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
movl $0x62f, %r8d            # imm = 0x62F
movl %ebp, %r9d
xorl %eax, %eax
pushq %r14
pushq %rbx
callq 0x8550
addq $0x10, %rsp
movl $0x1, %eax
jmp 0x177cc
movslq %ebp, %r9
movq $0x0, (%rdi,%r9,8)
xorl %eax, %eax
cmpl $0x2, %edx
jl 0x177cc
movslq %r14d, %rcx
movslq %ebx, %r8
movslq %esi, %r11
movl %edx, %edx
leaq (,%r11,8), %rsi
shlq $0x3, %r9
leaq (%r9,%r11,8), %r9
shlq $0x3, %r8
leaq (%r8,%r11,8), %r10
shlq $0x3, %rcx
leaq (%rcx,%r11,8), %r11
decq %rdx
xorpd %xmm0, %xmm0
movsd 0xda535(%rip), %xmm1    # 0xf1cd0
movsd (%rdi,%r11), %xmm2
addsd (%rdi,%rcx), %xmm2
mulsd %xmm1, %xmm2
movsd (%rdi,%r10), %xmm3
subsd (%rdi,%r8), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd %xmm0, (%rdi,%r9)
addq %rsi, %rdi
decq %rdx
jne 0x1779b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_ratio
int array_integrate_ratio(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y1,
		   int index_y2,
		   int index_int_y1_over_y2_dx,
		   ErrorMsg errmsg) {

  int i;
  double sum;

  if ((index_int_y1_over_y2_dx == index_x) || (index_int_y1_over_y2_dx == index_y1) || (index_int_y1_over_y2_dx == index_y2)) {
    class_sprintf(errmsg,"%s(L:%d) : Output column %d must differ from input columns %d, %d and %d",__func__,__LINE__,index_int_y1_over_y2_dx,index_x,index_y1,index_y2);
    return _FAILURE_;
  }

  sum=0.;

  *(array+0*n_columns+index_int_y1_over_y2_dx)=sum;

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

    sum += 0.5 * (*(array+i*n_columns+index_y1) / *(array+i*n_columns+index_y2)
		  + *(array+(i-1)*n_columns+index_y1) / *(array+(i-1)*n_columns+index_y2))
      * (*(array+i*n_columns+index_x) - *(array+(i-1)*n_columns+index_x));

    *(array+i*n_columns+index_int_y1_over_y2_dx)=sum;
  }


  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r14d
movl %ecx, %ebx
movl 0x40(%rsp), %ebp
cmpl %r9d, %ebp
je 0x178b5
cmpl %ebx, %ebp
je 0x178b5
cmpl %r14d, %ebp
je 0x178b5
movslq %ebp, %r10
movq $0x0, (%rdi,%r10,8)
xorl %eax, %eax
cmpl $0x2, %edx
jl 0x1791c
movslq %r14d, %rcx
movslq %r15d, %r8
movslq %ebx, %r9
movslq %esi, %r14
movl %edx, %edx
leaq (,%r14,8), %rsi
shlq $0x3, %r10
leaq (%r10,%r14,8), %r10
shlq $0x3, %r9
leaq (%r9,%r14,8), %r11
shlq $0x3, %r8
leaq (%r8,%r14,8), %rbx
shlq $0x3, %rcx
leaq (%rcx,%r14,8), %r14
decq %rdx
xorpd %xmm0, %xmm0
movsd 0xda469(%rip), %xmm1    # 0xf1cd0
movsd (%rdi,%r14), %xmm2
movhpd (%rdi,%rcx), %xmm2      # xmm2 = xmm2[0],mem[0]
movsd (%rdi,%rbx), %xmm3
movhpd (%rdi,%r8), %xmm3       # xmm3 = xmm3[0],mem[0]
divpd %xmm3, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
movsd (%rdi,%r11), %xmm2
subsd (%rdi,%r9), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, (%rdi,%r10)
addq %rsi, %rdi
decq %rdx
jne 0x17867
jmp 0x1791c
subq $0x8, %rsp
leaq 0xdb7f0(%rip), %r13     # 0xf30b0
leaq 0xdb832(%rip), %r12     # 0xf30f9
xorl %edi, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movl $0x653, %r8d            # imm = 0x653
movl %ebp, %r9d
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %rbx
callq 0x8550
addq $0x20, %rsp
incl %eax
movslq %eax, %rsi
subq $0x8, %rsp
movq 0x50(%rsp), %rdi
movq %r13, %rdx
movq %r12, %rcx
movl $0x653, %r8d            # imm = 0x653
movl %ebp, %r9d
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %rbx
callq 0x8550
addq $0x20, %rsp
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_interpolate_equal
int array_interpolate_equal(
			    double * array,
			    int n_columns,
			    int n_lines,
			    double x,
			    double x_min,
			    double x_max,
			    double * result,
			    ErrorMsg errmsg) {

  int index_minus,i;
  double x_step,x_minus,weight;

  if (x < x_min) {
    class_sprintf(errmsg,"%s(L:%d) : x out of bounds: x=%e,x_min=%e",__func__,__LINE__,x,x_min);
    return _FAILURE_;
  }

  if (x > x_max) {
    class_sprintf(errmsg,"%s(L:%d) : x out of bounds: x=%e,x_max=%e",__func__,__LINE__,x,x_max);
    return _FAILURE_;
  }

  x_step = (x_max-x_min)/(n_lines-1);
  index_minus = (int)((x-x_min)/x_step);
  x_minus = index_minus * x_step;
  weight = (x-x_minus) / x_step;

  for (i=0; i<n_columns; i++)
    result[i] = *(array+n_columns*index_minus+i)*(1.-weight)
      + *(array+n_columns*(index_minus+1)+i)*weight;

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
ucomisd %xmm0, %xmm1
jbe 0x1a85e
leaq 0xd8c47(%rip), %r14     # 0xf3466
leaq 0xd8c6a(%rip), %r15     # 0xf3490
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbb6, %r8d            # imm = 0xBB6
movb $0x2, %al
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
callq 0x8550
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbb6, %r8d            # imm = 0xBB6
jmp 0x1a8ac
ucomisd %xmm2, %xmm0
jbe 0x1a8cd
leaq 0xd8c3d(%rip), %r14     # 0xf34a8
leaq 0xd8c1e(%rip), %r15     # 0xf3490
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbbb, %r8d            # imm = 0xBBB
movapd %xmm2, %xmm1
movb $0x2, %al
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x8550
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbbb, %r8d            # imm = 0xBBB
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x2, %al
callq 0x8550
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
testl %esi, %esi
jle 0x1a95c
subsd %xmm1, %xmm2
decl %edx
cvtsi2sd %edx, %xmm3
divsd %xmm3, %xmm2
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
divsd %xmm2, %xmm3
cvttsd2si %xmm3, %eax
cvttpd2dq %xmm3, %xmm1
cvtdq2pd %xmm1, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
divsd %xmm2, %xmm0
movl %eax, %edx
imull %esi, %edx
movslq %edx, %rdx
leaq (%rdi,%rdx,8), %rdx
movsd 0xd6945(%rip), %xmm3    # 0xf1260
subsd %xmm0, %xmm3
incl %eax
imull %esi, %eax
cltq
leaq (%rdi,%rax,8), %rdi
movl %esi, %esi
xorl %eax, %eax
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm1
mulsd %xmm0, %xmm1
movsd (%rdx,%r8,8), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rcx,%r8,8)
incq %r8
cmpq %r8, %rsi
jne 0x1a931
jmp 0x1a8c3
xorl %eax, %eax
jmp 0x1a8c3
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_interpolate_parabola
int array_interpolate_parabola(double x1,
			       double x2,
			       double x3,
			       double x,
			       double y1,
			       double y2,
			       double y3,
			       double * y,
			       double * dy,
			       double * ddy,
			       ErrorMsg errmsg) {

  double a,b,c;

  /*
    a x_i**2 + b x_i + c = y_i

    a (x1**2-x2**2) + b (x1-x2) = y1-y2
    a (x3**2-x2**2) + b (x3-x2) = y3-y2

    a (x1**2-x2**2)(x3**2-x2**2) + b (x1-x2)(x3**2-x2**2) = (y1-y2)(x3**2-x2**2)
    a (x3**2-x2**2)(x1**2-x2**2) + b (x3-x2)(x1**2-x2**2) = (y3-y2)(x1**2-x2**2)

    b = [(y1-y2)(x3**2-x2**2) - (y3-y2)(x1**2-x2**2)]/(x1-x2)(x3-x2)(x3-x1)

  */

  b = ((y1-y2)*(x3-x2)*(x3+x2) - (y3-y2)*(x1-x2)*(x1+x2))/(x1-x2)/(x3-x2)/(x3-x1);

  a = (y1-y2-b*(x1-x2))/(x1-x2)/(x1+x2);

  c = y2 - b*x2 - a*x2*x2;

  *y = a*x*x + b*x + c;
  *dy = 2.*a*x + b;
  *ddy = 2.*a;

  return _SUCCESS_;

}

// Assembly:
subsd %xmm5, %xmm4
movapd %xmm2, %xmm8
subsd %xmm1, %xmm8
movapd %xmm8, %xmm9
mulsd %xmm4, %xmm9
movapd %xmm1, %xmm7
addsd %xmm2, %xmm7
mulsd %xmm9, %xmm7
subsd %xmm5, %xmm6
movapd %xmm0, %xmm9
subsd %xmm1, %xmm9
subsd %xmm0, %xmm2
addsd %xmm1, %xmm0
mulsd %xmm9, %xmm6
mulsd %xmm0, %xmm6
subsd %xmm6, %xmm7
divsd %xmm9, %xmm7
divsd %xmm8, %xmm7
divsd %xmm2, %xmm7
movapd %xmm7, %xmm2
mulsd %xmm9, %xmm2
subsd %xmm2, %xmm4
divsd %xmm9, %xmm4
divsd %xmm0, %xmm4
movapd 0xd65ec(%rip), %xmm2    # 0xf1230
xorpd %xmm4, %xmm2
movapd %xmm7, %xmm0
mulsd %xmm3, %xmm0
movapd %xmm4, %xmm6
movapd %xmm3, %xmm8
addsd %xmm4, %xmm4
mulsd %xmm4, %xmm3
addsd %xmm7, %xmm3
mulsd %xmm1, %xmm7
subsd %xmm7, %xmm5
unpcklpd %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0]
unpcklpd %xmm2, %xmm6            # xmm6 = xmm6[0],xmm2[0]
unpcklpd %xmm1, %xmm8            # xmm8 = xmm8[0],xmm1[0]
mulpd %xmm8, %xmm6
mulpd %xmm8, %xmm6
addpd %xmm0, %xmm6
movapd %xmm6, %xmm0
unpckhpd %xmm6, %xmm0            # xmm0 = xmm0[1],xmm6[1]
addsd %xmm6, %xmm0
movsd %xmm0, (%rdi)
movsd %xmm3, (%rsi)
movsd %xmm4, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorpd %xmm0, %xmm0
cmpl $0x2, %edx
jl 0x1ad04
movslq %r8d, %rax
movslq %ecx, %rcx
movslq %esi, %r10
movl %edx, %edx
leaq (,%r10,8), %rsi
shlq $0x3, %rcx
leaq (%rcx,%r10,8), %r8
shlq $0x3, %rax
leaq (%rax,%r10,8), %r10
decq %rdx
movsd 0xd6ff6(%rip), %xmm1    # 0xf1cd0
movsd (%rdi,%r10), %xmm2
addsd (%rdi,%rax), %xmm2
mulsd %xmm1, %xmm2
movsd (%rdi,%r8), %xmm3
subsd (%rdi,%rcx), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
addq %rsi, %rdi
decq %rdx
jne 0x1acda
movsd %xmm0, (%r9)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r13d
movq %rdi, %rbx
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x8460
testq %rax, %rax
je 0x1b32f
movslq %r13d, %rcx
movslq %ebp, %rdx
movq %rdx, (%rsp)
movl %r15d, %edx
testl %r15d, %r15d
jle 0x1b2fc
leal -0x1(%r15), %edi
movl %r14d, %r8d
negl %r8d
movq (%rsp), %rsi
leaq (%rbx,%rsi,8), %r9
leaq (,%rcx,8), %r10
xorl %r11d, %r11d
movsd 0xd5fe4(%rip), %xmm0    # 0xf1260
xorl %r12d, %r12d
testl %r8d, %r8d
movl $0x0, %r13d
cmovgl %r8d, %r13d
movq $0x0, (%rax,%r12,8)
movl %r12d, %ebp
subl %r14d, %ebp
testl %ebp, %ebp
cmovlel %r11d, %ebp
leal (%r12,%r14), %esi
cmpl %edi, %esi
cmovgel %edi, %esi
xorpd %xmm1, %xmm1
cmpl %esi, %ebp
jg 0x1b2e1
movq %r10, %rbp
imulq %r13, %rbp
decq %r13
addq %r9, %rbp
movsd (%rax,%r12,8), %xmm2
movslq %esi, %rsi
addsd (%rbp), %xmm2
addsd %xmm0, %xmm1
incq %r13
addq %r10, %rbp
cmpq %rsi, %r13
jl 0x1b2c7
movsd %xmm2, (%rax,%r12,8)
movsd (%rax,%r12,8), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, (%rax,%r12,8)
incq %r12
incl %r8d
cmpq %rdx, %r12
jne 0x1b27f
testl %r15d, %r15d
jle 0x1b323
movq (%rsp), %rsi
leaq (%rbx,%rsi,8), %rsi
shlq $0x3, %rcx
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm0
movsd %xmm0, (%rsi)
incq %rdi
addq %rcx, %rsi
cmpq %rdi, %rdx
jne 0x1b30f
movq %rax, %rdi
callq 0x8410
xorl %eax, %eax
jmp 0x1b374
leaq 0xd821e(%rip), %rbx     # 0xf3554
leaq 0xd8284(%rip), %r14     # 0xf35c1
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
movl $0xcc9, %r8d            # imm = 0xCC9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movl $0xcc9, %r8d            # imm = 0xCC9
xorl %eax, %eax
callq 0x8550
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b391
movq $0x0, (%rdx)
jmp 0x1b3ee
jle 0x1b3ee
movsd 0x8(%rdi), %xmm1
subsd (%rdi), %xmm1
movsd 0xd692c(%rip), %xmm0    # 0xf1cd0
mulsd %xmm0, %xmm1
leal -0x1(%rsi), %eax
movsd (%rdi,%rax,8), %xmm2
movl %esi, %ecx
subsd -0x10(%rdi,%rcx,8), %xmm2
movsd %xmm1, (%rdx)
mulsd %xmm0, %xmm2
movsd %xmm2, (%rdx,%rax,8)
cmpl $0x2, %esi
je 0x1b3ee
movl %eax, %eax
decq %rax
xorl %ecx, %ecx
movsd 0x10(%rdi,%rcx,8), %xmm1
subsd (%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1b3d1
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b405
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdx)
jmp 0x1b462
jle 0x1b462
movsd (%rdi), %xmm1
subsd 0x8(%rdi), %xmm1
movsd 0xd68b8(%rip), %xmm0    # 0xf1cd0
mulsd %xmm0, %xmm1
movl %esi, %eax
movsd -0x10(%rdi,%rax,8), %xmm2
leal -0x1(%rsi), %eax
subsd (%rdi,%rax,8), %xmm2
movsd %xmm1, (%rdx)
mulsd %xmm0, %xmm2
movsd %xmm2, (%rdx,%rax,8)
cmpl $0x2, %esi
je 0x1b462
movl %eax, %eax
decq %rax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
subsd 0x10(%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1b445
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x1b489
movl %esi, %eax
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rdi,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x1b471
jmp 0x1b48d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edx, %edx
jle 0x1b4bd
movl %edx, %eax
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm1
mulsd (%rsi,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x1b4a0
jmp 0x1b4c1
xorpd %xmm0, %xmm0
movsd %xmm0, (%r8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b80b
leaq 0xd7e59(%rip), %rbx     # 0xf3629
leaq 0xd7e9a(%rip), %r15     # 0xf3671
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xda8, %r8d            # imm = 0xDA8
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xda8, %r8d            # imm = 0xDA8
xorl %eax, %eax
callq 0x8550
jmp 0x1b87b
movapd %xmm0, %xmm3
movq %rdi, %rbx
ucomisd %xmm2, %xmm0
ja 0x1b81e
ucomisd %xmm3, %xmm1
jbe 0x1b88e
decq %r13
leaq 0xd7e5f(%rip), %r15     # 0xf3687
leaq 0xd7e42(%rip), %r12     # 0xf3671
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 0x8550
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 0x8550
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
cmpl $0x3, %esi
jl 0x1b8be
decl %esi
xorl %ecx, %ecx
leal (%rcx,%rsi), %edi
movl %edi, %eax
shrl $0x1f, %eax
addl %edi, %eax
sarl %eax
movslq %eax, %rdi
ucomisd (%rbx,%rdi,8), %xmm3
jbe 0x1b8b3
movl %eax, %esi
movl %ecx, %eax
movl %esi, %edi
subl %eax, %edi
movl %eax, %ecx
cmpl $0x1, %edi
jg 0x1b899
movl %eax, (%rdx)
movq 0x1306f1(%rip), %rcx    # 0x14bfb8
movq (%rcx), %rdi
movslq %eax, %rdx
leal 0x1(%rdx), %ecx
movsd (%rbx,%rdx,8), %xmm0
movsd 0x8(%rbx,%rdx,8), %xmm2
leaq 0xd7dcf(%rip), %rsi     # 0xf36b1
movapd %xmm3, %xmm1
movb $0x3, %al
callq 0x84e0
jmp 0x1b87b
// File: /workspace/github_c_makefile_star2_O1/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 0x1b958
leaq 0xd7dc0(%rip), %rbx     # 0xf36da
leaq 0xd7e00(%rip), %r15     # 0xf3721
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xddd, %r8d            # imm = 0xDDD
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movl $0xddd, %r8d            # imm = 0xDDD
xorl %eax, %eax
callq 0x8550
jmp 0x1b9fd
movq %rdi, %rbx
ucomisd %xmm0, %xmm1
ja 0x1b9a4
ucomisd %xmm2, %xmm0
ja 0x1b9a4
xorl %eax, %eax
movl $0x0, %ecx
cmpl $0x3, %esi
jl 0x1b9a0
decl %esi
xorl %ecx, %ecx
leal (%rcx,%rsi), %r8d
movl %r8d, %edi
shrl $0x1f, %edi
addl %r8d, %edi
sarl %edi
movslq %edi, %r8
ucomisd (%rbx,%r8,8), %xmm0
ja 0x1b995
movl %edi, %esi
jmp 0x1b997
movl %edi, %ecx
movl %esi, %edi
subl %ecx, %edi
cmpl $0x1, %edi
jg 0x1b977
movl %ecx, (%rdx)
jmp 0x1ba02
decq %r13
leaq 0xd7cd9(%rip), %r15     # 0xf3687
leaq 0xd7d6c(%rip), %r12     # 0xf3721
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 0x8550
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 0x8550
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x1028, %rsp           # imm = 0x1028
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x1bb4a
testl %ecx, %ecx
jle 0x1bb46
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0xd6c38(%rip), %xmm2    # 0xf2680
mulsd %xmm0, %xmm2
movl %ecx, %r12d
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
xorl %r13d, %r13d
movapd 0xd57da(%rip), %xmm4    # 0xf1240
movapd 0xd57c2(%rip), %xmm5    # 0xf1230
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, 0x10(%rsp)
movsd (%r15,%r13,8), %xmm0
movapd %xmm0, %xmm1
subsd (%r15), %xmm1
andpd %xmm4, %xmm1
ucomisd %xmm1, %xmm2
ja 0x1baa4
subsd -0x8(%r15,%r12,8), %xmm0
andpd %xmm4, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x1bab5
movsd (%r14,%r13,8), %xmm0
movsd %xmm0, (%rbx,%r13,8)
jmp 0x1bb3a
movq $0x0, (%rbx,%r13,8)
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
movsd %xmm1, 0x18(%rsp)
movsd (%r15,%r13,8), %xmm1
subsd (%r15,%rbp,8), %xmm1
movapd %xmm1, %xmm0
xorpd %xmm5, %xmm0
mulsd %xmm1, %xmm0
divsd %xmm3, %xmm0
callq 0x8670
movsd 0x18(%rsp), %xmm1
movapd 0xd5738(%rip), %xmm5    # 0xf1230
movsd 0x10(%rsp), %xmm3
addsd %xmm0, %xmm1
mulsd (%r14,%rbp,8), %xmm0
addsd (%rbx,%r13,8), %xmm0
movsd %xmm0, (%rbx,%r13,8)
incq %rbp
cmpq %rbp, %r12
jne 0x1bac3
movsd (%rbx,%r13,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%r13,8)
movsd 0x8(%rsp), %xmm2
movapd 0xd5706(%rip), %xmm4    # 0xf1240
incq %r13
cmpq %r12, %r13
jne 0x1ba7a
xorl %eax, %eax
jmp 0x1bbab
movq %r8, %r12
leaq 0xd7be2(%rip), %rsi     # 0xf3736
leaq 0x820(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x30c2c
leaq 0xd5515(%rip), %rsi     # 0xf1082
leaq 0xd7be8(%rip), %rdx     # 0xf375c
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xd54a7(%rip), %rsi     # 0xf1034
leaq 0xd7bd2(%rip), %rdx     # 0xf3766
movq %r12, %rdi
movl $0xe0b, %ecx            # imm = 0xE0B
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0x8480
movl %eax, %ebx
leaq 0xd7170(%rip), %rax     # 0xf377c
movq %rax, 0x8(%rsp)
leaq 0xd7174(%rip), %rax     # 0xf378c
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %r15
movq 0x8(%rsp,%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x8150
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x8430
testq %rax, %rax
je 0x1c665
movq %rax, %rdi
callq 0x8520
leal -0x1(%rax), %ecx
cmpl $0x2000, %ecx           # imm = 0x2000
setb %r13b
cmovbl %eax, %ebx
jmp 0x1c668
xorl %r13d, %r13d
leaq 0x28(%rsp), %rax
cmpq %rax, %r12
je 0x1c67a
movq %r12, %rdi
callq 0x8380
cmpq $0x8, %rbp
leaq 0x8(%rbp), %rbp
sete %al
orb %al, %r13b
cmpb $0x1, %r13b
jne 0x1c629
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %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)
movl (%r14), %ecx
testl %ecx, %ecx
je 0x1cf1f
movl $0x1, %r13d
leal (%rbx,%r13), %eax
decl %eax
xorl %edx, %edx
divl %ecx
imulq $0xb0, %rdx, %rdi
addq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x1cfb6
movl (%r14), %ecx
cmpl %ecx, %r13d
sete %dl
orb %dl, %al
incl %r13d
testb %al, %al
je 0x1cef0
cmpq $0x0, 0x10(%rsp)
jne 0x1cf3a
movq 0x28(%r14), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x1d00e
testb %al, %al
je 0x1cf6e
cmpq $0x0, 0x10(%rsp)
je 0x1cf81
movb $0x1, %bpl
movq %r15, %rdi
callq *0x18(%rsp)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1cf63
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
testb %bpl, %bpl
jne 0x1ced7
jmp 0x1cf72
xorl %ebp, %ebp
jmp 0x1cf4c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8140
jmp 0x1cfae
jmp 0x1cf8c
jmp 0x1cf8c
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1cfa6
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x8650
movq %rax, %rdi
callq 0x1c815
// File: /workspace/github_c_makefile_star2_O1/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 0x8080
testl %eax, %eax
sete 0x10(%rsp)
je 0x1cfde
xorl %ebx, %ebx
jmp 0x1cffa
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
je 0x1cfda
movq %r14, %rdi
callq 0x1d0a8
movq %rbx, %rdi
callq 0x1d13a
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x1d17a
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x1d20a
movb $0x1, 0x8(%r15)
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
setne %bpl
je 0x1d071
movq %r14, %rdi
callq 0x1d0a8
movq %rbx, %rdi
callq 0x1d13a
movq %rsp, %rdi
callq 0x1d17a
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x50(%rbx)
jne 0x1d0a0
leaq 0x80(%rbx), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x80f0
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
setne %bpl
jne 0x1d04a
cmpb $0x0, 0x50(%rbx)
je 0x1d081
testb %bpl, %bpl
jne 0x1d04a
jmp 0x1d05a
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1e67d
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movq %rdx, %rdi
callq 0x8180
leaq 0x1(%rax), %rdi
callq 0x8460
movq %rax, (%r14)
testq %rax, %rax
je 0x1e5c6
movq %rax, %rdi
movq %r15, %rsi
callq 0x8350
movl %r12d, %r15d
movq %r15, %r12
shlq $0xa, %r12
movq %r12, %rdi
callq 0x8460
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x1e604
movq %r12, %rdi
callq 0x8460
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x1e63a
addq %r15, %r15
movq %r15, %rdi
callq 0x8460
movq %rax, 0x20(%r14)
testq %rax, %rax
jne 0x1e67d
leaq 0xd2a70(%rip), %rsi     # 0xf1004
leaq 0xd553b(%rip), %rdx     # 0xf3ad6
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xd2a82(%rip), %rsi     # 0xf1034
leaq 0xd54fc(%rip), %rdx     # 0xf3ab5
movq %rbx, %rdi
movl $0x3c, %ecx
jmp 0x1e66e
movq %r15, %rdi
callq 0x8180
leal 0x1(%rax), %ecx
leaq 0xd2a2c(%rip), %rsi     # 0xf1004
leaq 0xd54c8(%rip), %rdx     # 0xf3aa7
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0xd2a41(%rip), %rsi     # 0xf1034
leaq 0xd54bb(%rip), %rdx     # 0xf3ab5
movq %rbx, %rdi
movl $0x38, %ecx
jmp 0x1e66e
leaq 0xd29f9(%rip), %rsi     # 0xf1004
leaq 0xd54af(%rip), %rdx     # 0xf3ac1
movq %rsp, %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xd2a0b(%rip), %rsi     # 0xf1034
leaq 0xd5485(%rip), %rdx     # 0xf3ab5
movq %rbx, %rdi
movl $0x3a, %ecx
jmp 0x1e66e
leaq 0xd29c3(%rip), %rsi     # 0xf1004
leaq 0xd5483(%rip), %rdx     # 0xf3acb
movq %rsp, %r14
movq %r14, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xd29d5(%rip), %rsi     # 0xf1034
leaq 0xd544f(%rip), %rdx     # 0xf3ab5
movq %rbx, %rdi
movl $0x3b, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebp
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_O1/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 0x1e6bd
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movq (%rbx), %rdi
callq 0x8410
popq %rbx
xorl %eax, %eax
retq