LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: reachr
int reachr(sp_mat *G, sp_mat *B,int k, int *xik,int *pinv){
	int p, n, top, *Bp, *Bi, *Gp;
	n=G->ncols; Bp = B->Ap; Bi = B->Ai;Gp = G->Ap;
	top = n;
	for (p=Bp[k];p<Bp[k+1];p++){ /* For each entry in the k'th column of B */
		if (!SPMARKED(Gp,Bi[p])){ /* If node is not marked... */
			dfsr(Bi[p],G,&top,xik,pinv); /* ...start a depth first search at this entry.*/
		}
	}
	for (p=top; p<n; p++) SPMARK(Gp, xik[p]);
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movl (%rdi), %eax
movq 0x10(%rsi), %r12
movq 0x18(%rsi), %rbp
movq %rdi, 0x18(%rsp)
movq 0x10(%rdi), %r13
movl %eax, 0x8(%rsp)
movslq %edx, %r14
movslq (%r12,%r14,4), %r15
movl 0x4(%r12,%r14,4), %edx
cmpl %edx, %r15d
jge 0xb82d
movq %rcx, %rbx
movl %eax, 0xc(%rsp)
cltq
movq %rax, 0x10(%rsp)
movslq (%rbp,%r15,4), %rdi
cmpl $0x0, (%r13,%rdi,4)
js 0xb7f5
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
movq 0x20(%rsp), %r8
callq 0xb83c
movl 0x4(%r12,%r14,4), %edx
incq %r15
movslq %edx, %rcx
cmpq %rcx, %r15
jl 0xb7cc
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xb82d
movslq %eax, %rcx
movq 0x10(%rsp), %rdi
movslq (%rbx,%rcx,4), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
subl (%r13,%rdx,4), %esi
movl %esi, (%r13,%rdx,4)
incq %rcx
cmpq %rcx, %rdi
jne 0xb812
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_splsolve
int sp_splsolve(sp_mat *G, sp_mat *B, int k, int*xik, int top, double *x, int *pinv){
	int j, J, p, q, px, n, *Gp, *Gi, *Bp, *Bi;
	double *Gx, *Bx;
	Gp = G->Ap; Gi = G->Ai; Gx = G->Ax;
	Bp = B->Ap; Bi = B->Ai; Bx = B->Ax;
	n = G->ncols;

	for (p=top; p<n; p++) x[xik[p]] = 0;
	for (p=Bp[k];p<Bp[k+1];p++) x[Bi[p]] = Bx[p];
	for (px=top; px<n; px++){
		j=xik[px];
		J = pinv[j];
		if (J<0) continue;
		x[j] /= Gx[Gp[J]];
		p = Gp[J]+1;
		q = Gp[J+1];
		for( ;p<q; p++){
			x[Gi[p]] -=Gx[p] * x[j];
		}
	}
	return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r10
movq 0x20(%rdi), %r11
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rbx
movq 0x20(%rsi), %r14
movslq (%rdi), %rsi
cmpl %r8d, %esi
jle 0xb93f
movslq %r8d, %rdi
movslq (%rcx,%rdi,4), %r12
movq $0x0, (%r9,%r12,8)
incq %rdi
cmpq %rdi, %rsi
jne 0xb92b
movslq %edx, %rdi
movslq (%r15,%rdi,4), %rdx
movslq 0x4(%r15,%rdi,4), %rdi
cmpl %edi, %edx
jge 0xb967
movsd (%r14,%rdx,8), %xmm0
movslq (%rbx,%rdx,4), %r15
movsd %xmm0, (%r9,%r15,8)
incq %rdx
cmpq %rdx, %rdi
jne 0xb94f
cmpl %r8d, %esi
jle 0xb9d9
movq 0x30(%rsp), %rdx
movslq %r8d, %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r14
testq %r14, %r14
js 0xb9d1
movslq (%rax,%r14,4), %rbx
movsd (%r9,%r8,8), %xmm0
divsd (%r11,%rbx,8), %xmm0
movsd %xmm0, (%r9,%r8,8)
movl 0x4(%rax,%r14,4), %r14d
leal 0x1(%rbx), %ebp
cmpl %r14d, %ebp
jge 0xb9d1
decl %r14d
movsd 0x8(%r11,%rbx,8), %xmm0
movslq 0x4(%r10,%rbx,4), %r15
movsd (%r9,%r15,8), %xmm1
mulsd (%r9,%r8,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r15,8)
incq %rbx
cmpl %ebx, %r14d
jne 0xb9a7
incq %rdi
cmpq %rsi, %rdi
jne 0xb974
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_lusolve
int sp_lusolve(sp_num *N, double *b, double *x){
	int p, j, n, *Ap, *Ai;
	double *Ax, *w;
	n=N->n;
	/* permute b and initialize x:*/
	for (j=0; j<n; j++) x[N->pinv[j]] = b[j];
	/* lower solve: */
	Ap = N->L->Ap; Ai = N->L->Ai; Ax = N->L->Ax;
	for (j=0; j<n; j++){
		x[j] /=Ax[Ap[j]];
		for (p=Ap[j]+1; p<Ap[j+1]; p++){
			x[Ai[p]] -=Ax[p]*x[j];
		}
	}
	/* upper solve: */
	Ap = N->U->Ap; Ai = N->U->Ai; Ax = N->U->Ax;
	for (j=n-1; j>=0; j--){
		x[j] /=Ax[Ap[j+1]-1];
		for (p=Ap[j];p<Ap[j+1]-1; p++){
			x[Ai[p]] -= Ax[p]*x[j];
		}
	}
	if (N->q!=NULL){
		/* We must permute once more..*/
		w = N->w;
		for(j=0;j<n;j++) w[j] = x[j];
		for(j=0; j<n; j++) x[N->q[j]] = w[j];
	}
	return _SUCCESS_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq (%rdi), %rax
testq %rax, %rax
jle 0xbe3d
movq 0x28(%rdi), %rcx
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm0
movslq (%rcx,%r8,4), %r9
movsd %xmm0, (%rdx,%r9,8)
incq %r8
cmpq %r8, %rax
jne 0xbd34
testl %eax, %eax
jle 0xbe3d
movq 0x8(%rdi), %r8
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rsi
movq 0x20(%r8), %r8
movl (%rcx), %r10d
xorl %r9d, %r9d
movslq %r10d, %r11
movsd (%rdx,%r9,8), %xmm0
divsd (%r8,%r11,8), %xmm0
movsd %xmm0, (%rdx,%r9,8)
movl 0x4(%rcx,%r9,4), %r10d
leal 0x1(%r11), %ebx
cmpl %r10d, %ebx
jge 0xbdbb
leal -0x1(%r10), %ebx
movsd 0x8(%r8,%r11,8), %xmm0
movslq 0x4(%rsi,%r11,4), %r14
movsd (%rdx,%r14,8), %xmm1
mulsd (%rdx,%r9,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%r14,8)
incq %r11
cmpl %r11d, %ebx
jne 0xbd91
incq %r9
cmpq %rax, %r9
jne 0xbd6a
testl %eax, %eax
jle 0xbe3d
movq 0x10(%rdi), %r8
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rsi
movq 0x20(%r8), %r8
movl (%rcx,%rax,4), %r10d
movq %rax, %r9
movq %r9, %r11
decq %r9
movslq %r10d, %r14
movsd -0x8(%rdx,%r11,8), %xmm0
divsd -0x8(%r8,%r14,8), %xmm0
movsd %xmm0, -0x8(%rdx,%r11,8)
movl -0x4(%rcx,%r11,4), %r10d
decl %r14d
cmpl %r14d, %r10d
jge 0xbe37
movslq %r10d, %rbx
movslq %r14d, %r14
movsd (%r8,%rbx,8), %xmm0
movslq (%rsi,%rbx,4), %r15
movsd (%rdx,%r15,8), %xmm1
mulsd (%rdx,%r9,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%r15,8)
incq %rbx
cmpq %rbx, %r14
jne 0xbe0f
cmpq $0x2, %r11
jge 0xbdde
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0xbe7f
testl %eax, %eax
jle 0xbe7f
movq 0x48(%rdi), %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0xbe50
testl %eax, %eax
jle 0xbe7f
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
movslq (%rcx,%rdi,4), %r8
movsd %xmm0, (%rdx,%r8,8)
incq %rdi
cmpq %rdi, %rax
jne 0xbe68
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: column_grouping
int column_grouping(sp_mat *G, int *col_g, int *filled){
  int testcol,groupnum,fitted,neq;
  int i, *Ap, *Ai,done;

  neq = G->ncols;
  Ai = G->Ai; Ap = G->Ap;
  for(i=0;i<neq;i++)
    col_g[i]=-1;

  for(groupnum=0; groupnum<neq; groupnum++){
    //Reset filled vector:
    for (i=0; i<neq; i++){
      filled[i] = 0;
    }
    //Try to assign remaining columns to current group:
    done = _TRUE_;
    for (testcol=0; testcol<neq; testcol++){
      if (col_g[testcol]!=-1){
	continue;
      }
      done = _FALSE_;
      //Is current testcol in conflict with the groups filling vector?
      fitted = _TRUE_;
      for (i=Ap[testcol]; i<Ap[testcol+1]; i++){
	if (filled[Ai[i]] != 0){
	  fitted = _FALSE_;
	  break;
	}
      }
      if (fitted == _TRUE_){
	//Test succesfull
	col_g[testcol] = groupnum;
	for (i=Ap[testcol]; i<Ap[testcol+1]; i++){
	  filled[Ai[i]] = 1;
	}
      }
    }
    if (done == _TRUE_){
      //No columns remaining.
      //No column belongs to current groupnum.
      break;
    }
  }
  return (groupnum-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rdi), %r13
testq %r13, %r13
jle 0xc195
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rbp
movq 0x18(%rdi), %r12
leaq (,%r13,4), %rdx
movq %rsi, %rdi
movl $0xff, %esi
movq %rdx, (%rsp)
callq 0x8200
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x8200
movl $0x1, %ecx
xorl %eax, %eax
cmpl $-0x1, (%r14,%rax,4)
je 0xc127
incq %rax
cmpq %r13, %rax
jne 0xc116
jmp 0xc17c
movslq (%rbp,%rax,4), %rsi
movl 0x4(%rbp,%rax,4), %ecx
cmpl %esi, %ecx
jle 0xc14d
leaq (%r12,%rsi,4), %rdx
subl %esi, %ecx
xorl %esi, %esi
movslq (%rdx,%rsi,4), %rdi
cmpl $0x0, (%rbx,%rdi,4)
jne 0xc178
incq %rsi
cmpl %esi, %ecx
jne 0xc13c
movl %r15d, (%r14,%rax,4)
movslq (%rbp,%rax,4), %rdx
xorl %ecx, %ecx
cmpl 0x4(%rbp,%rax,4), %edx
jge 0xc11d
movslq (%r12,%rdx,4), %rsi
movl $0x1, (%rbx,%rsi,4)
incq %rdx
movslq 0x4(%rbp,%rax,4), %rsi
cmpq %rsi, %rdx
jl 0xc15e
jmp 0xc11d
xorl %ecx, %ecx
jmp 0xc11d
cmpl $0x1, %ecx
je 0xc190
incl %r15d
cmpl %r13d, %r15d
jne 0xc101
movl %r13d, %r15d
decl %r15d
jmp 0xc19b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_wclear
int sp_wclear(int mark, int lemax, int *w, int n){
	int k;
	if (mark<2 || (mark+lemax<0)){
		for(k=0; k<n; k++) if(w[k]!=0) w[k] = 1;
		mark = 2;
	}
	return (mark);
}

// Assembly:
movl %edi, %eax
cmpl $0x2, %edi
setl %dil
addl %eax, %esi
sets %sil
orb %dil, %sil
cmpb $0x1, %sil
jne 0xcff2
movl $0x2, %eax
testl %ecx, %ecx
jle 0xcff2
movl %ecx, %ecx
xorl %esi, %esi
cmpl $0x0, (%rdx,%rsi,4)
je 0xcfea
movl $0x1, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0xcfdd
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd01f
movl (%rcx,%r11,4), %r10d
movl %r10d, (%rdx,%rbx,4)
incl %esi
movl %r11d, 0x4(%r9,%rdi,4)
jmp 0xd02a
decl %esi
movslq %eax, %rdi
incl %eax
movl %r10d, (%r8,%rdi,4)
testl %esi, %esi
jns 0xcffb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x1187b
pushq %rbp
pushq %rbx
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 0x117f5
movslq %r9d, %r10
cmpq %r10, %r8
jle 0x11805
movq (%rdi,%r8,8), %r11
movsd (%r11,%r10,8), %xmm2
mulsd (%rcx,%r10,8), %xmm2
subsd %xmm2, %xmm1
incq %r10
cmpq %r10, %r8
jne 0x117db
jmp 0x11805
ucomisd %xmm0, %xmm1
jne 0x117fd
jnp 0x11802
movl %r8d, %r9d
jmp 0x11805
xorl %r9d, %r9d
movsd %xmm1, (%rcx,%r8,8)
incq %r8
cmpq %rax, %r8
jne 0x117b4
movl %esi, %eax
leaq 0x8(,%rax,8), %rdx
leaq (%rcx,%rax,8), %r8
addq $0x8, %r8
movq %rax, %r9
movsd (%rcx,%r9,8), %xmm0
movq (%rdi,%r9,8), %r10
cmpq %rax, %r9
jge 0x11858
leaq (%r10,%rdx), %r11
xorl %ebx, %ebx
movsd (%r11,%rbx,8), %xmm1
mulsd (%r8,%rbx,8), %xmm1
subsd %xmm1, %xmm0
incq %rbx
leal (%r9,%rbx), %ebp
cmpl %esi, %ebp
jl 0x1183d
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 0x11828
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11934
subsd %xmm1, %xmm0
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
movsd 0xdc995(%rip), %xmm3    # 0xee260
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 0x118d6
testl %eax, %eax
jle 0x119ac
movq 0x20(%rsp), %r10
incl %eax
movl $0x1, %r11d
cmpl $0x1, (%r10,%r11,4)
jne 0x119a4
testl %edx, %edx
jle 0x1198a
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 0x1195b
jmp 0x1198e
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 0x11945
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11a48
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 0xb27a
movq 0x78(%rbx), %rdi
callq 0xb716
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x135a7
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 0xdb78a(%rip), %xmm0    # 0xeecd0
movsd 0xdc12a(%rip), %xmm1    # 0xef678
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 0x1354e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17625
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 0xd7702(%rip), %xmm1    # 0xeecd0
movsd 0xd80a2(%rip), %xmm2    # 0xef678
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 0x175d6
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x176ce
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 0xd765f(%rip), %xmm1    # 0xeecd0
movsd 0xd7fff(%rip), %xmm2    # 0xef678
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 0x17679
xorl %eax, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x178e2
movq 0x40(%rsp), %r15
leaq 0xd84f6(%rip), %r12     # 0xefd84
leaq 0xd881b(%rip), %r13     # 0xf00b0
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 0x1795f
movslq %ebp, %r9
movq $0x0, (%rdi,%r9,8)
xorl %eax, %eax
cmpl $0x2, %edx
jl 0x1795f
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 0xd73a2(%rip), %xmm1    # 0xeecd0
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 0x1792e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17a48
cmpl %ebx, %ebp
je 0x17a48
cmpl %r14d, %ebp
je 0x17a48
movslq %ebp, %r10
movq $0x0, (%rdi,%r10,8)
xorl %eax, %eax
cmpl $0x2, %edx
jl 0x17aaf
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 0xd72d6(%rip), %xmm1    # 0xeecd0
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 0x179fa
jmp 0x17aaf
subq $0x8, %rsp
leaq 0xd866d(%rip), %r13     # 0xf00c0
leaq 0xd86af(%rip), %r12     # 0xf0109
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_O3/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 0x1a97f
leaq 0xd5b36(%rip), %r14     # 0xf0476
leaq 0xd5b59(%rip), %r15     # 0xf04a0
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 0x1a9cd
ucomisd %xmm2, %xmm0
jbe 0x1a9ee
leaq 0xd5b2c(%rip), %r14     # 0xf04b8
leaq 0xd5b0d(%rip), %r15     # 0xf04a0
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 0x1aa7d
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 0xd3824(%rip), %xmm3    # 0xee260
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 0x1aa52
jmp 0x1a9e4
xorl %eax, %eax
jmp 0x1a9e4
// File: /workspace/github_c_makefile_star2_O3/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 0x1adfc
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 0xd3efe(%rip), %xmm1    # 0xeecd0
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 0x1add2
movsd %xmm0, (%r9)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r13d
movq %rdi, %r12
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x8460
testq %rax, %rax
je 0x1b3e6
testl %r14d, %r14d
jle 0x1b3da
leal -0x1(%r14), %edi
movl %ebx, %r8d
negl %r8d
movslq %r13d, %rcx
movslq %ebp, %rsi
movl %r14d, %edx
leaq (%r12,%rsi,8), %rsi
shlq $0x3, %rcx
xorl %r9d, %r9d
movsd 0xd4429(%rip), %xmm0    # 0xef770
movsd 0xd2f11(%rip), %xmm1    # 0xee260
xorl %r10d, %r10d
testl %r8d, %r8d
movl $0x0, %r11d
cmovgl %r8d, %r11d
movl %r10d, %r15d
subl %ebx, %r15d
testl %r15d, %r15d
cmovlel %r9d, %r15d
leal (%r10,%rbx), %ebp
cmpl %edi, %ebp
cmovgel %edi, %ebp
movapd %xmm0, %xmm2
cmpl %ebp, %r15d
jg 0x1b3ae
movq %rcx, %r15
imulq %r11, %r15
decq %r11
addq %rsi, %r15
movl %ebp, %r12d
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
addsd (%r15), %xmm2
addsd %xmm1, %xmm3
incq %r11
addq %rcx, %r15
cmpq %r12, %r11
jb 0x1b396
divsd %xmm3, %xmm2
movsd %xmm2, (%rax,%r10,8)
incq %r10
incl %r8d
cmpq %rdx, %r10
jne 0x1b352
testl %r14d, %r14d
jle 0x1b3da
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm0
movsd %xmm0, (%rsi)
incq %rdi
addq %rcx, %rsi
cmpq %rdi, %rdx
jne 0x1b3c6
movq %rax, %rdi
callq 0x8410
xorl %eax, %eax
jmp 0x1b42b
leaq 0xd5177(%rip), %rbx     # 0xf0564
leaq 0xd51dd(%rip), %r14     # 0xf05d1
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 %r15, %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_O3/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 0x1b448
movq $0x0, (%rdx)
jmp 0x1b4a3
jle 0x1b4a3
movsd 0x8(%rdi), %xmm1
subsd (%rdi), %xmm1
movsd 0xd3875(%rip), %xmm0    # 0xeecd0
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 0x1b4a3
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 0x1b486
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b4ba
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdx)
jmp 0x1b515
jle 0x1b515
movsd (%rdi), %xmm1
subsd 0x8(%rdi), %xmm1
movsd 0xd3803(%rip), %xmm0    # 0xeecd0
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 0x1b515
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 0x1b4f8
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b53c
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 0x1b524
jmp 0x1b540
xorpd %xmm0, %xmm0
movsd %xmm0, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b570
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 0x1b553
jmp 0x1b574
xorpd %xmm0, %xmm0
movsd %xmm0, (%r8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ba15
leaq 0xd4d13(%rip), %rbx     # 0xf06ea
leaq 0xd4d53(%rip), %r15     # 0xf0731
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 0x1baba
movq %rdi, %rbx
ucomisd %xmm0, %xmm1
ja 0x1ba61
ucomisd %xmm2, %xmm0
ja 0x1ba61
xorl %eax, %eax
movl $0x0, %ecx
cmpl $0x3, %esi
jl 0x1ba5d
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 0x1ba52
movl %edi, %esi
jmp 0x1ba54
movl %edi, %ecx
movl %esi, %edi
subl %ecx, %edi
cmpl $0x1, %edi
jg 0x1ba34
movl %ecx, (%rdx)
jmp 0x1babf
decq %r13
leaq 0xd4c2c(%rip), %r15     # 0xf0697
leaq 0xd4cbf(%rip), %r12     # 0xf0731
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_O3/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 0x1bbfe
testl %ecx, %ecx
jle 0x1bbfa
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0xd3b7b(%rip), %xmm2    # 0xef680
mulsd %xmm0, %xmm2
movl %ecx, %r12d
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
xorl %r13d, %r13d
movapd 0xd271d(%rip), %xmm4    # 0xee240
movapd 0xd2705(%rip), %xmm5    # 0xee230
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 0x1bb61
subsd -0x8(%r15,%r12,8), %xmm0
andpd %xmm4, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x1bb6f
movsd (%r14,%r13,8), %xmm0
movsd %xmm0, (%rbx,%r13,8)
jmp 0x1bbee
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 0xd267e(%rip), %xmm5    # 0xee230
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 0x1bb7d
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%r13,8)
movsd 0x8(%rsp), %xmm2
movapd 0xd2652(%rip), %xmm4    # 0xee240
incq %r13
cmpq %r12, %r13
jne 0x1bb37
xorl %eax, %eax
jmp 0x1bc5f
movq %r8, %r12
leaq 0xd4b3e(%rip), %rsi     # 0xf0746
leaq 0x820(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x30af0
leaq 0xd2461(%rip), %rsi     # 0xee082
leaq 0xd4b44(%rip), %rdx     # 0xf076c
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xd23f3(%rip), %rsi     # 0xee034
leaq 0xd4b2e(%rip), %rdx     # 0xf0776
movq %r12, %rdi
movl $0xe0b, %ecx            # imm = 0xE0B
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
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_O3/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 0xd40ea(%rip), %rax     # 0xf078c
movq %rax, 0x8(%rsp)
leaq 0xd40ee(%rip), %rax     # 0xf079c
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 0x1c6fb
movq %rax, %rdi
callq 0x8520
leal -0x1(%rax), %ecx
cmpl $0x2000, %ecx           # imm = 0x2000
setb %r13b
cmovbl %eax, %ebx
jmp 0x1c6fe
xorl %r13d, %r13d
leaq 0x28(%rsp), %rax
cmpq %rax, %r12
je 0x1c710
movq %r12, %rdi
callq 0x8380
cmpq $0x8, %rbp
leaq 0x8(%rbp), %rbp
sete %al
orb %al, %r13b
cmpb $0x1, %r13b
jne 0x1c6bf
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_O3/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 0x1cfc5
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 0x1d052
movl (%r14), %ecx
cmpl %ecx, %r13d
sete %dl
orb %dl, %al
incl %r13d
testb %al, %al
je 0x1cf8e
cmpq $0x0, 0x10(%rsp)
jne 0x1cfe0
movq 0x28(%r14), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x1d0aa
testb %al, %al
je 0x1cfec
cmpq $0x0, 0x10(%rsp)
je 0x1d01d
movb $0x1, %bpl
movq %r15, %rdi
callq *0x18(%rsp)
jmp 0x1cfee
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1d005
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
testb %bpl, %bpl
jne 0x1cf75
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8140
jmp 0x1d028
jmp 0x1d04a
jmp 0x1d028
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1d042
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x8650
movq %rax, %rdi
callq 0x1c8b1
// File: /workspace/github_c_makefile_star2_O3/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 0x1d07a
xorl %ebx, %ebx
jmp 0x1d096
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
je 0x1d076
movq %r14, %rdi
callq 0x1d138
movq %rbx, %rdi
callq 0x1d1bc
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x1d204
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rdi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x1d294
movb $0x1, 0x8(%r15)
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
jne 0x1d10a
leaq 0x80(%rbx), %r15
leaq 0x8(%rsp), %r12
cmpb $0x0, 0x50(%rbx)
jne 0x1d134
movq %r15, %rdi
movq %r12, %rsi
callq 0x80f0
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
je 0x1d0ef
movq %r14, %rdi
callq 0x1d138
movq %rbx, %rdi
callq 0x1d1bc
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x1d204
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x1d11c