LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Chain_coup
double **Chain_coup(float **Coupling, double **norm, float **Proximity,
		    int Nchain, char *ch, int Na)
{
  if(Coupling==NULL)return(NULL);
  double **Chain_coup=Allocate_mat2_d(Nchain, Nchain);
  int ichain, jchain;
  for(ichain=0; ichain<Nchain; ichain++){
    for(jchain=0; jchain<=ichain; jchain++)norm[ichain][jchain]=0;
  }

  char ch_old_i=ch[0]; ichain=0;
  for(int ia=0; ia<Na; ia++){
    if(ch[ia]!=ch_old_i){ch_old_i=ch[ia]; ichain++;}
    char ch_old_j=ch[0]; jchain=0;
    for(int ja=0; ja<ia; ja++){
      if(ch[ja]!=ch_old_j){ch_old_j=ch[ja]; jchain++;}
      float w=Proximity[ia][ja];
      Chain_coup[ichain][jchain]+=w*Coupling[ia][ja];
      norm[ichain][jchain]+=w;
    }
  }
  for(ichain=0; ichain<Nchain; ichain++){
    for(jchain=0; jchain<=ichain; jchain++){
      Chain_coup[ichain][jchain]/=norm[ichain][jchain];
      if(jchain!=ichain){
	Chain_coup[jchain][ichain]=Chain_coup[ichain][jchain];
	norm[jchain][ichain]=norm[ichain][jchain];
      }
    }
  }
  return(Chain_coup);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x40320
movq %r8, %r12
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
movl %ecx, %edi
movl %ecx, %esi
callq 0x43878
testl %ebx, %ebx
cmovlel %r15d, %ebx
pushq $0x1
popq %rcx
cmpq %rbx, %r15
je 0x40228
movq (%r14,%r15,8), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x40220
andq $0x0, (%rdx,%rsi,8)
incq %rsi
jmp 0x40211
incq %r15
incq %rcx
jmp 0x40206
movb (%r12), %dil
xorl %ecx, %ecx
movq (%rsp), %r15
testl %r15d, %r15d
cmovlel %ecx, %r15d
xorl %edx, %edx
cmpq %r15, %rcx
je 0x402c4
movb (%r12,%rcx), %sil
xorl %r8d, %r8d
cmpb %dil, %sil
setne %r8b
addl %r8d, %edx
movb (%r12), %r9b
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rdi, %rcx
je 0x402ba
movb (%r12,%rdi), %r10b
xorl %r11d, %r11d
cmpb %r9b, %r10b
setne %r11b
addl %r11d, %r8d
movq (%r13,%rcx,8), %r9
movss (%r9,%rdi,4), %xmm0
movq (%rbp,%rcx,8), %r9
cvtss2sd %xmm0, %xmm1
mulss (%r9,%rdi,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq (%rax,%rdx,8), %r9
addsd (%r9,%r8,8), %xmm0
movsd %xmm0, (%r9,%r8,8)
movq (%r14,%rdx,8), %r9
addsd (%r9,%r8,8), %xmm1
movsd %xmm1, (%r9,%r8,8)
incq %rdi
movl %r10d, %r9d
jmp 0x4025e
incq %rcx
movl %esi, %edi
jmp 0x4023b
xorl %edx, %edx
xorl %ecx, %ecx
cmpq %rbx, %rcx
je 0x40322
movq (%r14,%rcx,8), %rdi
movq (%rax,%rcx,8), %r8
leaq 0x8(%rdx), %rsi
xorl %r9d, %r9d
cmpq %r9, %rsi
je 0x40318
movsd (%r8,%r9), %xmm0
divsd (%rdi,%r9), %xmm0
movsd %xmm0, (%r8,%r9)
cmpq %r9, %rdx
je 0x40312
movq (%rax,%r9), %r10
movsd %xmm0, (%r10,%rcx,8)
movsd (%rdi,%r9), %xmm0
movq (%r14,%r9), %r10
movsd %xmm0, (%r10,%rcx,8)
addq $0x8, %r9
jmp 0x402dc
incq %rcx
movq %rsi, %rdx
jmp 0x402c8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: PE_profile
float PE_profile(float *PE, double **Mat, int N)
{
  float eigenval[N];
  float **eigenvec=malloc(N*sizeof(float *));
  for(int i=0; i<N; i++)eigenvec[i]=malloc(N*sizeof(float));
  d_Diagonalize(N, Mat, eigenval, eigenvec, 1);
  float *v=eigenvec[0];
  for(int i=0; i<N; i++)PE[i]=v[i];
  Empty_matrix_f(eigenvec, N);
  return(eigenval[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
movl %edx, %eax
movl %edx, -0x2c(%rbp)
movq %rsp, %rcx
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movslq %edx, %rbx
leaq (,%rbx,8), %rdi
callq 0x21d0
movq %rax, %r12
leaq (,%rbx,4), %r13
xorl %r15d, %r15d
testl %ebx, %ebx
movl $0x0, %ebx
cmovgl -0x2c(%rbp), %ebx
cmpq %r15, %rbx
je 0x410c4
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r12,%r15,8)
incq %r15
jmp 0x410ae
pushq $0x1
popq %r8
movl -0x2c(%rbp), %r15d
movl %r15d, %edi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %r13
movq %r13, %rdx
movq %r12, %rcx
callq 0x444de
movq (%r12), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x410fd
movss (%rax,%rcx,4), %xmm0
movss %xmm0, (%r14,%rcx,4)
incq %rcx
jmp 0x410e8
movq %r12, %rdi
movl %r15d, %esi
callq 0x436f0
movss (%r13), %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Singvalue_main
float Singvalue_main(double **A, int Na, int Nb)
{
  int i, j, k, N1, N2;
  if(Na<Nb){N1=Na; N2=Nb;}else{N1=Nb; N2=Na;}
  float *eigenval=malloc(N1*sizeof(float));
  float **eigenvec=Allocate_mat2_f(N1, N1);
  double **Mat=Allocate_mat2_d(N1, N1);
  for(i=0; i<N1; i++){
    for(j=0; j<N1; j++){
      for(k=0; k<N2; k++)Mat[i][j]+=A[i][k]*A[j][k];
    }
  }

  d_Diagonalize(N1, Mat, eigenval, eigenvec, 1);
  float Ev=sqrt(eigenval[0]);
  Empty_matrix_d(Mat, Na);
  Empty_matrix_f(eigenvec, Na);
  //for(i=0; i<N1; i++)printf("%.3g ", eigenval[i]); printf("\n");
  free(eigenval);
  return(Ev);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %rbp
cmpl %edx, %esi
movl %edx, %r12d
cmovll %esi, %r12d
movslq %r12d, %r14
leaq (,%r14,4), %rdi
callq 0x21d0
movq %rax, 0x10(%rsp)
movl %r14d, %edi
movl %r14d, %esi
callq 0x4379e
movq %rax, 0x8(%rsp)
movl %r14d, %edi
movl %r14d, %esi
callq 0x43878
cmpl %ebx, %r13d
cmovlel %ebx, %r13d
xorl %ecx, %ecx
testl %r13d, %r13d
cmovlel %ecx, %r13d
movq %rax, %r15
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %r14, %rcx
je 0x411ca
xorl %eax, %eax
cmpq %r12, %rax
je 0x411c5
xorl %edx, %edx
cmpq %rdx, %r13
je 0x411c0
movq (%rbp,%rcx,8), %rsi
movsd (%rsi,%rdx,8), %xmm0
movq (%rbp,%rax,8), %rsi
movq (%r15,%rcx,8), %rdi
mulsd (%rsi,%rdx,8), %xmm0
addsd (%rdi,%rax,8), %xmm0
movsd %xmm0, (%rdi,%rax,8)
incq %rdx
jmp 0x41194
incq %rax
jmp 0x4118d
incq %rcx
jmp 0x41186
pushq $0x1
popq %r8
movl %r12d, %edi
movq %r15, %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdx
movq 0x8(%rsp), %r12
movq %r12, %rcx
callq 0x444de
movss (%r14), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x411fc
sqrtss %xmm0, %xmm0
jmp 0x41201
callq 0x21c0
movss %xmm0, 0x4(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x4372a
movq %r12, %rdi
movl %ebx, %esi
callq 0x436f0
movq %r14, %rdi
callq 0x2050
movss 0x4(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Normalize_profile
void Normalize_profile(double *v, int N){
  double sum=0; int i;
  for(i=0; i<N; i++)sum+=v[i]*v[i];
  sum=sqrt(sum/N);
  for(i=0; i<N; i++)v[i]/=sum;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %r14d
cmovgl %esi, %r14d
xorpd %xmm0, %xmm0
cmpq %rax, %r14
je 0x41268
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x41251
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x41280
sqrtsd %xmm0, %xmm0
jmp 0x41285
callq 0x2290
xorl %eax, %eax
cmpq %rax, %r14
je 0x4129f
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x41287
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Count_chains
int Count_chains(int *ichain, int *min_chain, int *max_chain, char *chain_lab,
		 char *chain_res, int *site_res, int nr)
{
  int nc=0, j, k;
  for(int i=0; i<nr; i++){
    for(j=0; j<nc; j++){
      if(chain_lab[j]==chain_res[i])break;
    }
    ichain[i]=j;
    //num_chain[j]++;
    if(site_res){k=site_res[i];}
    else{k=i;}
    if(j==nc){
      chain_lab[nc]=chain_res[i];
      min_chain[j]=k;
      max_chain[j]=k;
      nc++;
    }else{
      if(k<min_chain[j])min_chain[j]=k;
      if(k>max_chain[j])max_chain[j]=k;
    }
  }
  return(nc);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x20(%rsp), %r10d
xorl %r11d, %r11d
testl %r10d, %r10d
cmovlel %r11d, %r10d
xorl %eax, %eax
cmpq %r10, %r11
je 0x41329
testl %eax, %eax
movl $0x0, %ebx
cmovgl %eax, %ebx
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x412e5
movb (%rcx,%r14), %bpl
cmpb (%r8,%r11), %bpl
je 0x412e2
incq %r14
jmp 0x412ce
movl %r14d, %ebx
movl %ebx, (%rdi,%r11,4)
testq %r9, %r9
je 0x412f4
movl (%r9,%r11,4), %ebp
jmp 0x412f7
movl %r11d, %ebp
cmpl %eax, %ebx
jne 0x41312
movb (%r8,%r11), %bl
movslq %eax, %r14
movb %bl, (%rcx,%r14)
movl %eax, %ebx
movl %ebp, (%rsi,%rbx,4)
movl %ebp, (%rdx,%rbx,4)
incl %eax
jmp 0x41324
movl %ebx, %ebx
cmpl (%rsi,%rbx,4), %ebp
jge 0x4131c
movl %ebp, (%rsi,%rbx,4)
cmpl (%rdx,%rbx,4), %ebp
jle 0x41324
movl %ebp, (%rdx,%rbx,4)
incq %r11
jmp 0x412bc
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Identify_chains
void Identify_chains(int *all_chain, char *chain_lab, int nchain,
		     char *lab_chain, int Nchain)
{
  for(int nc=0; nc<nchain; nc++){
    all_chain[nc]=-1;
    for(int k=0; k<Nchain; k++){
      if(chain_lab[nc]==lab_chain[k]){all_chain[nc]=k; break;}
    }
    if(all_chain[nc]<0){
      printf("ERROR, chain %c not found among the %d chains\n",
	     chain_lab[nc], Nchain); exit(8);
    }
  }
}

// Assembly:
xorl %r9d, %r9d
testl %r8d, %r8d
movl $0x0, %r10d
cmovgl %r8d, %r10d
testl %edx, %edx
cmovlel %r9d, %edx
cmpq %rdx, %r9
je 0x4136f
orl $-0x1, (%rdi,%r9,4)
movsbl (%rsi,%r9), %eax
xorl %r11d, %r11d
cmpq %r11, %r10
je 0x41370
cmpb (%rcx,%r11), %al
je 0x41366
incq %r11
jmp 0x41356
movl %r11d, (%rdi,%r9,4)
incq %r9
jmp 0x41344
retq
pushq %rax
leaq 0x15eb6(%rip), %rdi     # 0x5722e
movl %eax, %esi
movl %r8d, %edx
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Ave_site
float Ave_site(double *sigprof, double *ave_pair,
	       double *sigpair, int *n_notfound,
	       int *site, int *atomres, int nr, int *atom_site,
	       float *profile, float **coupling, int Na)
{
  double sum_prof=0; 
  *sigprof=0; *ave_pair=0; *sigpair=0; *n_notfound=0;
  int npair=0;
  for(int i1=0; i1<nr; i1++){
    int j1=atomres[site[i1]];
    if((j1<0)||(j1>=Na)){
      if(atom_site)atom_site[j1]=-site[i1];
      (*n_notfound)++;
      continue;
    }
    if(atom_site)atom_site[j1]=1;
    sum_prof+=profile[j1];
    *sigprof+=profile[j1]*profile[j1];
    for(int i2=0; i2<i1; i2++){
      int j2=atomres[site[i2]];
      if((j2<0)||(j2>=Na)||(j2==j1))continue;
      float x=coupling[j1][j2];
      *ave_pair+=x; *sigpair+=x*x;
      npair++;
    }
  } // end of the site
  Ave_St_dev(&sum_prof, sigprof, nr-*n_notfound);
  Ave_St_dev(ave_pair, sigpair, npair);
  return(sum_prof);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movl 0x60(%rsp), %eax
andq $0x0, (%rdi)
movq 0x58(%rsp), %rdi
andq $0x0, (%r14)
andq $0x0, (%rdx)
andl $0x0, (%rcx)
movl 0x40(%rsp), %edx
xorl %r15d, %r15d
testl %edx, %edx
movl $0x0, %r12d
cmovgl %edx, %r12d
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x41b69
movslq (%r8,%r15,4), %r10
movslq (%r9,%r10,4), %r13
testl %r13d, %r13d
setns %dl
cmpl %eax, %r13d
setl %r11b
testb %r11b, %dl
je 0x41b48
movq 0x48(%rsp), %rdx
testq %rdx, %rdx
je 0x41add
movl $0x1, (%rdx,%r13,4)
movq 0x50(%rsp), %rdx
movss (%rdx,%r13,4), %xmm2
cvtss2sd %xmm2, %xmm1
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd (%rsi), %xmm2
movsd %xmm2, (%rsi)
xorl %r10d, %r10d
cmpq %r10, %r15
je 0x41b5d
movslq (%r8,%r10,4), %rdx
movl (%r9,%rdx,4), %edx
cmpl %r13d, %edx
je 0x41b43
testl %edx, %edx
js 0x41b43
cmpl %eax, %edx
jge 0x41b43
movq (%rdi,%r13,8), %r11
movss (%r11,%rdx,4), %xmm2
cvtss2sd %xmm2, %xmm3
addsd (%r14), %xmm3
movsd %xmm3, (%r14)
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd (%rbx), %xmm2
movsd %xmm2, (%rbx)
incl %ebp
incq %r10
jmp 0x41aff
movq 0x48(%rsp), %rdx
testq %rdx, %rdx
je 0x41b59
negl %r10d
movl %r10d, (%rdx,%r13,4)
incl (%rcx)
jmp 0x41b61
addsd %xmm1, %xmm0
incq %r15
jmp 0x41aa8
movq %rsp, %r15
movsd %xmm0, (%r15)
movl 0x40(%rsp), %edx
subl (%rcx), %edx
movq %r15, %rdi
callq 0x41ba0
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x41ba0
cvtsd2ss (%r15), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Ave_St_dev
void Ave_St_dev(double *sum1, double *sum2, int n){
  if(n<=0)return;
  if(n==1){*sum2=0; return;}
  (*sum1)/=n;
  (*sum2)=*sum2-n*(*sum1)*(*sum1);
  (*sum2)=sqrt((*sum2)/(n-1));
}

// Assembly:
testl %edx, %edx
jle 0x41bf5
pushq %rbx
movq %rsi, %rbx
xorpd %xmm0, %xmm0
cmpl $0x1, %edx
je 0x41bf0
cvtsi2sd %edx, %xmm1
movsd (%rdi), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, (%rdi)
movsd (%rbx), %xmm0
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
decl %edx
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x41beb
sqrtsd %xmm0, %xmm0
jmp 0x41bf0
callq 0x2290
movsd %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Pair_site
float Pair_site(double *sigpair, int *n_notfound,
		int *coupled_site, int n1, int n12,
		int *atomres, int *atom_site,
		float **coupling, int Na)
{
  double ave_pair=0; *sigpair=0; *n_notfound=0;
  int npair=0;
  for(int i1=0; i1<n1; i1++){
    int j1=atomres[coupled_site[i1]];
    if((j1<0)||(j1>=Na)){
      if(atom_site)atom_site[j1]=-coupled_site[i1];
      (*n_notfound)++;
      continue;
    }
    if(atom_site)atom_site[j1]=1;
    for(int i2=n1; i2<n12; i2++){
      int j2=atomres[coupled_site[i2]];
      if((j2<0)||(j2>=Na)){
	if(atom_site)atom_site[j1]=-coupled_site[i2];
	(*n_notfound)++;
	continue;
      }
      if(j2==j1)continue;
      float x=coupling[j1][j2];
      ave_pair+=x; *sigpair+=x*x;
      npair++;
    }
  } // end of the site
  Ave_St_dev(&ave_pair, sigpair, npair);
  return(ave_pair);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rax
movl 0x60(%rsp), %edi
movq 0x50(%rsp), %r11
andq $0x0, (%rax)
andl $0x0, (%rsi)
movslq %ecx, %rcx
movslq %r8d, %r8
xorl %r14d, %r14d
testl %ecx, %ecx
movl $0x0, %r10d
movq %rcx, (%rsp)
cmovgl %ecx, %r10d
movq %r10, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq 0x8(%rsp), %r14
je 0x41ec1
movslq (%rdx,%r14,4), %r13
movslq (%r9,%r13,4), %r12
testl %r12d, %r12d
setns %bl
cmpl %edi, %r12d
setl %bpl
testb %bpl, %bl
je 0x41eab
testq %r11, %r11
je 0x41e4a
movl $0x1, (%r11,%r12,4)
movq (%rsp), %r13
cmpq %r8, %r13
jge 0x41eb9
movslq (%rdx,%r13,4), %rbp
movl (%r9,%rbp,4), %ebx
testl %ebx, %ebx
setns %r15b
cmpl %edi, %ebx
setl %r10b
testb %r10b, %r15b
je 0x41e99
cmpl %r12d, %ebx
je 0x41ea6
movq 0x58(%rsp), %r10
movq (%r10,%r12,8), %r10
movss (%r10,%rbx,4), %xmm1
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtps2pd %xmm2, %xmm1
addpd %xmm1, %xmm0
movlpd %xmm0, (%rax)
incl %ecx
jmp 0x41ea6
testq %r11, %r11
je 0x41ea4
negl %ebp
movl %ebp, (%r11,%r12,4)
incl (%rsi)
incq %r13
jmp 0x41e4e
testq %r11, %r11
je 0x41eb7
negl %r13d
movl %r13d, (%r11,%r12,4)
incl (%rsi)
incq %r14
jmp 0x41e18
leaq 0x10(%rsp), %rbx
movhpd %xmm0, (%rbx)
movq %rbx, %rdi
movq %rax, %rsi
movl %ecx, %edx
callq 0x41ba0
cvtsd2ss (%rbx), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Cont_ave
double *Cont_ave(float *v, int N, int **clist, int *nc)
{
  double *Ave=malloc(N*sizeof(double)); int i, j;
  for(i=0; i<N; i++){
    Ave[i]=v[i];
    for(j=0; j<nc[i]; j++)Ave[i]+=v[clist[i][j]];
    Ave[i]/=(nc[i]+1);
  }
  return(Ave);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movslq %esi, %r12
leaq (,%r12,8), %rdi
callq 0x21d0
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
cmpq %r12, %rcx
je 0x42130
cvtss2sd (%r15,%rcx,4), %xmm0
movslq (%rbx,%rcx,4), %rdx
xorl %esi, %esi
cmpq %rdx, %rsi
jge 0x4211c
movq (%r14,%rcx,8), %rdi
movslq (%rdi,%rsi,4), %rdi
cvtss2sd (%r15,%rdi,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rsi
jmp 0x420fb
incl %edx
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x420ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Get_matrix_positive
double **Get_matrix_positive(float **Mat, int N)
{
  double **Mat2=malloc(N*sizeof(double *)); int i, j;
  double min=0;
  for(i=0; i<N; i++){
    Mat2[i]=malloc(N*sizeof(double));
    for(j=0; j<N; j++){
      Mat2[i][j]=Mat[i][j];
      if(Mat2[i][j]<min)min=Mat2[i][j];
    }
  }
  // Transform into positive
  if(min<0){
    for(i=0; i<N; i++){
      for(j=0; j<N; j++)Mat2[i][j]-=min;
    }
  }
  return(Mat2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq %esi, %r13
leaq (,%r13,8), %r15
movq %r15, %rdi
callq 0x21d0
movq %rax, %rbx
xorl %ebp, %ebp
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
movl %r13d, %r13d
xorpd %xmm1, %xmm1
cmpq %r12, %rbp
je 0x421b8
movq %r15, %rdi
movsd %xmm1, (%rsp)
callq 0x21d0
movsd (%rsp), %xmm1
movq %rax, (%rbx,%rbp,8)
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x421b3
movq (%r14,%rbp,8), %rdx
cvtss2sd (%rdx,%rcx,4), %xmm0
movsd %xmm0, (%rax,%rcx,8)
minsd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
jmp 0x42193
incq %rbp
jmp 0x42176
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x421ec
xorl %eax, %eax
cmpq %r12, %rax
je 0x421ec
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x421e7
movq (%rbx,%rax,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x421cb
incq %rax
jmp 0x421c4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Print_sites
void Print_sites(int **site_res, int *nres_site,
		 char **description, int nsites, 
		 struct residue *seq, char *pdb, char *chain)
{
  // Printing
  char pdbid[80], nameout[200], amm[5]; int k, j;
  GetPdbId(pdb,pdbid);
  sprintf(nameout, "%s%s_sites.in", pdbid, chain);
  printf("Writing binding sites in %s\n", nameout);
  FILE *file_out=fopen(nameout, "w");
  for(k=0; k<nsites; k++){
    if(description[k])
      fprintf(file_out, "SITE_DESCRIPTION: %s", description[k]);
    for(j=0; j<nres_site[k]; j++){
      struct residue *res=seq+site_res[k][j];
      Name3(amm, res->i_aa);
      fprintf(file_out, "%d\t%s\t%c\t%s\n",
	      k+1, amm, res->chain, res->pdbres);
    }
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r8, 0x18(%rsp)
movl %ecx, %r12d
movq %rdx, (%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x180(%rsp), %r14
leaq 0x30(%rsp), %r15
movq %r9, %rdi
movq %r15, %rsi
callq 0xd366
leaq 0x15138(%rip), %rsi     # 0x5758c
xorl %ebx, %ebx
leaq 0x80(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x15125(%rip), %rdi     # 0x5759a
movq %rbp, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0xecca(%rip), %rsi      # 0x51150
movq %rbp, %rdi
callq 0x2210
movq %rax, %rbp
testl %r12d, %r12d
cmovlel %ebx, %r12d
movq %r12, 0x8(%rsp)
leaq 0x2b(%rsp), %r15
xorl %r14d, %r14d
cmpq 0x8(%rsp), %r14
je 0x42539
movq (%rsp), %rax
movq (%rax,%r14,8), %rdx
testq %rdx, %rdx
je 0x424ce
movq %rbp, %rdi
leaq 0x150f0(%rip), %rsi     # 0x575b7
xorl %eax, %eax
callq 0x2190
leaq 0x1(%r14), %r13
xorl %r12d, %r12d
movq 0x20(%rsp), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r12
jge 0x42531
movq 0x10(%rsp), %rax
movq (%rax,%r14,8), %rax
movslq (%rax,%r12,4), %rax
shlq $0x5, %rax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %rbx
addq $0xd, %rbx
movswl 0x7(%rbx), %esi
movq %r15, %rdi
callq 0x24647
movsbl -0x1(%rbx), %r8d
movq %rbp, %rdi
leaq 0x150b0(%rip), %rsi     # 0x575cc
movl %r13d, %edx
movq %r15, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x2190
incq %r12
jmp 0x424d5
movq %r13, %r14
jmp 0x424a5
movq %rbp, %rdi
callq 0x20c0
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/site_dynamics.c
// Function: Read_site
int Read_site(char *resnum, char *resnam, char *reschain,
	      char *string, char *chain){
  if(string[0]==' ')return(-2);
  char *c=chain; int inum;
  sscanf(string, "%s", resnam);
  *reschain=string[4];
  sscanf(string+5, "%d", &inum);
  //sprintf(resnum, "%4d%c", inum, string[9]); 
  sprintf(resnum, "%d", inum);
  if(string[9]!=' '){
    char tmp[2]; sprintf(tmp, "%c", string[9]); strcat(resnum, tmp);
  }
  if(*c=='*')return(0);
  while(*c!='\0'){if(*c==*reschain)return(0); c++;}
  if(VERBOSE)
    printf("Residue %s %s_%c discarded, chain: %s\n",
	   resnam,resnum,*reschain,chain);
  return(-1);
}

// Assembly:
cmpb $0x20, (%rcx)
jne 0x43516
pushq $-0x2
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r12
leaq 0xdc45(%rip), %rsi      # 0x5117c
movq %rcx, %rdi
xorl %eax, %eax
callq 0x21f0
movb 0x4(%r13), %al
movb %al, (%r15)
leaq 0x5(%r13), %rdi
leaq 0x13cd8(%rip), %rbp     # 0x5722b
leaq 0x4(%rsp), %rbx
movq %rbp, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21f0
movl (%rbx), %edx
movq %r12, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2260
movb 0x9(%r13), %al
cmpb $0x20, %al
je 0x4358f
leaq 0x2(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %r12, %rdi
callq 0x2240
movb (%r14), %al
cmpb $0x2a, %al
jne 0x4359a
xorl %eax, %eax
jmp 0x435b3
incq %r14
pushq $-0x1
popq %rcx
testb %al, %al
je 0x435b1
cmpb (%r15), %al
je 0x43596
movb (%r14), %al
incq %r14
jmp 0x435a0
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/site_dynamics.c
// Function: Find_residue
int Find_residue(char *resnum, char chain,
		 struct residue *seq, int Nres, int i_ini)
{
  int i, ini=0; if(i_ini>0){ini=i_ini;}else{ini=0;}
  for(i=ini; i<Nres; i++){
    if((strcmp(seq[i].pdbres, resnum)==0)&&(seq[i].chain==chain))return(i);
  }
  for(i=0; i<ini; i++){
    if((strcmp(seq[i].pdbres, resnum)==0)&&(seq[i].chain==chain))return(i);
  }
  return(-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, 0x4(%rsp)
movq %rdi, %r14
xorl %r13d, %r13d
testl %r8d, %r8d
cmovgl %r8d, %r13d
movslq %ecx, %rbp
movq %r13, %rax
shlq $0x5, %rax
leaq (%rax,%rdx), %r12
addq $0xd, %r12
movq %r13, %r15
cmpq %rbp, %r15
jge 0x4361e
movq %r12, %rdi
movq %r14, %rsi
callq 0x2180
testl %eax, %eax
jne 0x43615
movl 0x4(%rsp), %eax
cmpb %al, -0x1(%r12)
je 0x43652
incq %r15
addq $0x20, %r12
jmp 0x435f6
addq $0xd, %rbx
xorl %r12d, %r12d
pushq $-0x1
popq %r15
cmpq %r12, %r13
je 0x43652
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
testl %eax, %eax
jne 0x43646
movl 0x4(%rsp), %eax
cmpb %al, -0x1(%rbx)
je 0x4364f
incq %r12
addq $0x20, %rbx
jmp 0x43629
movl %r12d, %r15d
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_O2/ugobas[P]tnm/site_dynamics.c
// Function: New_site
int New_site(int *nsite, int *sres, int *nres_site, char **description,
	      int NMAX)
{
  if(*nsite>=0)nres_site[*nsite]=*sres;
  *sres=0; (*nsite)++;
  if(*nsite > NMAX){
    printf("ERROR, too many sites > %d\n", NMAX); return(-1);
  }
  description[*nsite]=malloc(100*sizeof(char));
  return(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movslq (%rdi), %rax
testq %rax, %rax
js 0x43678
movl (%rsi), %ecx
movl %ecx, (%rdx,%rax,4)
andl $0x0, (%rsi)
movslq (%rdi), %r14
leal 0x1(%r14), %eax
movl %eax, (%rdi)
cmpl %r8d, %r14d
jge 0x4369a
pushq $0x64
popq %rdi
callq 0x21d0
movq %rax, 0x8(%rbx,%r14,8)
xorl %eax, %eax
jmp 0x436ae
leaq 0x146a9(%rip), %rdi     # 0x57d4a
movl %r8d, %esi
xorl %eax, %eax
callq 0x20f0
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/site_dynamics.c
// Function: Site_overlap
int Site_overlap(int *isite, int n1, int *jsite, int n2){
  int nc=0;
  for(int i=0; i<n1; i++){
    int i1=isite[i];
    for(int j=0; j<n2; j++){
      if(i1==jsite[j]){nc++; break;}
    }
  }
  return(nc);
}

// Assembly:
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %r8d, %ecx
testl %esi, %esi
cmovlel %r8d, %esi
xorl %eax, %eax
cmpq %rsi, %r8
je 0x436ec
movl (%rdi,%r8,4), %r9d
xorl %r10d, %r10d
cmpq %r10, %rcx
je 0x436e7
leaq 0x1(%r10), %r11
cmpl (%rdx,%r10,4), %r9d
movq %r11, %r10
jne 0x436d3
incl %eax
incq %r8
jmp 0x436c7
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allocate.c
// Function: Allocate_mat2_f
float **Allocate_mat2_f(int n1, int n2){
  int i, j;
  float **matrix=malloc(n1*sizeof(float *));
  for(i=0; i<n1; i++){
    matrix[i]=malloc(n2*sizeof(float));
    for(j=0; j<n2; j++)matrix[i][j]=0;
  }
  return(matrix);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movslq %ebx, %r12
leaq (,%r12,4), %rbx
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %rax, %r14
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r15, %r13
je 0x437fe
movq %rbx, %rdi
callq 0x21d0
movq %rax, (%r14,%r13,8)
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x437f9
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x437eb
incq %r13
jmp 0x437d8
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allocate.c
// Function: Allocate_mat2_i
int ** Allocate_mat2_i(int n1, int n2){
  int i, j;
  int **matrix=malloc(n1*sizeof(int *));
  for(i=0; i<n1; i++){
    matrix[i]=malloc(n2*sizeof(int));
    for(j=0; j<n2; j++)matrix[i][j]=0;
  }
  return(matrix);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movslq %ebx, %r12
leaq (,%r12,4), %rbx
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %rax, %r14
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r15, %r13
je 0x4386b
movq %rbx, %rdi
callq 0x21d0
movq %rax, (%r14,%r13,8)
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x43866
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x43858
incq %r13
jmp 0x43845
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allocate.c
// Function: Allocate_mat2_d
double **Allocate_mat2_d(int n1, int n2){
  int i, j;
  double **matrix=malloc(n1*sizeof(double *));
  for(i=0; i<n1; i++){
    matrix[i]=malloc(n2*sizeof(double));
    for(j=0; j<n2; j++)matrix[i][j]=(double)0;
  }
  return(matrix);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movslq %ebx, %r12
leaq (,%r12,8), %rbx
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %rax, %r14
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r15, %r13
je 0x438d9
movq %rbx, %rdi
callq 0x21d0
movq %rax, (%r14,%r13,8)
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x438d4
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x438c5
incq %r13
jmp 0x438b2
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/choldc.c
// Function: choldc
int choldc(double **L, double **a, int N)
{
  int i, j, k, ik, jk;
  double sum, diag[N];
  for(i=0; i<N; i++){
    for(j=i; j<N; j++){
      sum=a[i][j];
      for(k=i-1; k>=0; k--)sum-=L[i][k]*L[j][k];
      if(j==i){
	if(sum<EPS){
	  printf("WARNING, Choldc failed L_ii^2= %.2g i=%d\n", sum, i);
	  if(L==a){
	    // Ugo: Same matrix, restore lower diagonal
	    for(ik=0; ik<i; ik++){
	      a[ik][ik]=diag[ik];
	      for(jk=ik+1; jk<N; jk++)a[jk][ik]=a[ik][jk];
	    }
	  }
	  //exit(8);
	  return(-1);
	}
	diag[i]=a[i][i]; L[i][i]=sqrt(sum);
      }else{
	L[j][i]=sum/L[i][i]; // j<=i 
      }
    }
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r8
movl %edx, %r9d
movq %rsp, %rdi
leaq 0xf(,%r9,8), %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
movsd 0x145fd(%rip), %xmm2    # 0x57f28
xorpd %xmm3, %xmm3
xorl %r15d, %r15d
movq %rdi, -0x30(%rbp)
movq %r8, -0x48(%rbp)
movq %r9, -0x40(%rbp)
movq %rax, -0x38(%rbp)
cmpq %rax, %r15
je 0x43a67
leaq (%r8,%r15,8), %r12
movq %r15, %r13
cmpq %r9, %r13
je 0x439ed
movq (%r14,%r15,8), %rcx
movsd (%rcx,%r13,8), %xmm0
leaq (%r8,%r13,8), %rax
movq %r15, %rdx
testq %rdx, %rdx
jle 0x4398d
movq (%r12), %rsi
movsd -0x8(%rsi,%rdx,8), %xmm1
movq (%rax), %rsi
mulsd -0x8(%rsi,%rdx,8), %xmm1
decq %rdx
subsd %xmm1, %xmm0
jmp 0x4396c
cmpq %r15, %r13
jne 0x439b0
ucomisd %xmm0, %xmm2
ja 0x439f9
movsd (%rcx,%r15,8), %xmm1
movsd %xmm1, (%rdi,%r15,8)
ucomisd %xmm3, %xmm0
jb 0x439bc
sqrtsd %xmm0, %xmm0
jmp 0x439d9
movq (%r12), %rcx
divsd (%rcx,%r15,8), %xmm0
jmp 0x439dc
callq 0x2290
xorpd %xmm3, %xmm3
movsd 0x1455b(%rip), %xmm2    # 0x57f28
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %rdi
movq %r12, %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r13
jmp 0x43952
incq %r15
movq -0x38(%rbp), %rax
jmp 0x43942
leaq 0x14530(%rip), %rdi     # 0x57f30
movl %r15d, %esi
movb $0x1, %al
movq %r8, %r12
callq 0x20f0
pushq $-0x1
popq %rax
cmpq %r14, %r12
je 0x43a24
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %r10d
pushq $0x1
popq %rcx
xorl %edx, %edx
movq -0x30(%rbp), %r9
cmpq %r10, %rdx
je 0x43a15
movsd (%r9,%rdx,8), %xmm0
movq (%r14,%rdx,8), %rsi
movsd %xmm0, (%rsi,%rdx,8)
movq %rcx, %rdi
cmpl %ebx, %edi
jge 0x43a5f
movsd (%rsi,%rdi,8), %xmm0
movq (%r14,%rdi,8), %r8
movsd %xmm0, (%r8,%rdx,8)
incq %rdi
jmp 0x43a47
incq %rdx
incq %rcx
jmp 0x43a30
xorl %eax, %eax
jmp 0x43a15
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/choldc.c
// Function: Forward_substitution
void Forward_substitution(double *X, double **L, double *Y, int N){
  // Solve the matrix equation LX=Y, with L=lower diagonal (only i>=j)
  // X_i = (Y_i - sum_j<i L_ij X_j)/L_ii
  int i, j; double *XX=X;
  for(i=0; i<N; i++){
    double *XY=X, *LL=L[i];
    *XX=Y[i]; for(j=0; j<i; j++){(*XX)-=(*LL)*(*XY); XY++; LL++;}
    (*XX)/=(*LL);
    XX++;
  }
}

// Assembly:
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movq %rdi, %r8
cmpq %rcx, %rax
je 0x43abc
movq (%rsi,%rax,8), %r9
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%r8)
xorl %r10d, %r10d
movsd (%r9,%r10,8), %xmm1
cmpq %r10, %rax
je 0x43aaa
mulsd (%rdi,%r10,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
incq %r10
jmp 0x43a8b
divsd %xmm1, %xmm0
movsd %xmm0, (%r8)
addq $0x8, %r8
incq %rax
jmp 0x43a75
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/choldc.c
// Function: Backward_substitution
void Backward_substitution(double *X, double **L, double *Y, int N)
{
  // Solve the matrix equation L^tX=Y, with L=lower diagonal (only i>=j)
  // X_i =(Y_i - sum_j>i L_ji X_j)/L_ii
  int i, j;
  for(i=N-1; i>=0; i--){
    X[i]=Y[i];
    for(j=i+1; j<N; j++)X[i]-= X[j]*L[j][i];
    X[i]/=L[i][i];
  }
}

// Assembly:
pushq %rbx
movl %ecx, %r9d
leaq (%rsi,%r9,8), %rax
leaq (%rdi,%r9,8), %r8
testl %r9d, %r9d
jle 0x43b25
leaq -0x1(%r9), %r10
movsd (%rdx,%r10,8), %xmm0
movsd %xmm0, (%rdi,%r10,8)
xorl %r11d, %r11d
leal (%r9,%r11), %ebx
cmpl %ecx, %ebx
jge 0x43b08
movsd (%r8,%r11,8), %xmm1
movq (%rax,%r11,8), %rbx
mulsd (%rbx,%r10,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%r10,8)
incq %r11
jmp 0x43ae1
movq (%rsi,%r10,8), %r9
divsd (%r9,%r10,8), %xmm0
movsd %xmm0, (%rdi,%r10,8)
addq $-0x8, %rax
addq $-0x8, %r8
movq %r10, %r9
jmp 0x43ac9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/choldc.c
// Function: Cholevsky_inversion_d2f
float **Cholevsky_inversion_d2f(double **L, int N){
  float **L_inv=Allocate_mat2_f(N, N);
  double X[N];
  int i, j, k;
  for(k=0; k<N; k++){
  // Solve the matrix equation L(i,j)X(j,k)=delta(i,k),
  // with L=lower diagonal (only i>=j)
  // X_jk = (delta_ik - sum_j<i L_ij X_jk)/L_ii
    for(i=0; i<N; i++){
      double *LL=L[i], *XY=X, sum=0; if(i==k)sum=1;
      for(j=0; j<i; j++){sum-=(*LL)*(*XY); XY++; LL++;}
      X[i]=sum/(*LL);
    }
    for(i=0; i<N; i++)L_inv[i][k]=X[i];
  }
  return(L_inv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x4379e
movl %ebx, %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
subq %rsi, %rdx
movq %rdx, %rsp
xorl %esi, %esi
testl %ebx, %ebx
cmovlel %esi, %ebx
movsd 0x74e8(%rip), %xmm0     # 0x4b048
cmpq %rbx, %rsi
je 0x43bd2
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rcx, %rdi
je 0x43bb2
movapd %xmm0, %xmm1
cmpq %rsi, %rdi
je 0x43b7c
xorpd %xmm1, %xmm1
movq (%r14,%rdi,8), %r9
xorl %r10d, %r10d
cmpq %r10, %r8
je 0x43b9e
movsd (%r9,%r10), %xmm2
mulsd (%rdx,%r10), %xmm2
subsd %xmm2, %xmm1
addq $0x8, %r10
jmp 0x43b83
divsd (%r9,%r8), %xmm1
movsd %xmm1, (%rdx,%rdi,8)
incq %rdi
addq $0x8, %r8
jmp 0x43b6a
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x43bcd
cvtsd2ss (%rdx,%rdi,8), %xmm1
movq (%rax,%rdi,8), %r8
movss %xmm1, (%r8,%rsi,4)
incq %rdi
jmp 0x43bb4
incq %rsi
jmp 0x43b60
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/choldc.c
// Function: Cholevsky_inversion
double **Cholevsky_inversion(double **L, int N){
  double **L_inv=Allocate_mat2_d(N, N), X[N];
  int i, j, k;
  for(k=0; k<N; k++){
  // Solve the matrix equation L(i,j)X(j,k)=delta(i,k),
  // with L=lower diagonal (only i>=j)
  // X_jk = (delta_ik - sum_j<i L_ij X_jk)/L_ii
    for(i=0; i<N; i++){
      double *LL=L[i], *XY=X, sum=0; if(i==k)sum=1;
      for(j=0; j<i; j++){sum-=(*LL)*(*XY); XY++; LL++;}
      X[i]=sum/(*LL); L_inv[i][k]=X[i];
    }
  }
  return(L_inv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x43878
movl %ebx, %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
subq %rsi, %rdx
movq %rdx, %rsp
xorl %esi, %esi
testl %ebx, %ebx
cmovlel %esi, %ebx
movsd 0x7434(%rip), %xmm0     # 0x4b048
cmpq %rbx, %rsi
je 0x43c75
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rcx, %rdi
je 0x43c70
movapd %xmm0, %xmm1
cmpq %rsi, %rdi
je 0x43c30
xorpd %xmm1, %xmm1
movq (%r14,%rdi,8), %r9
xorl %r10d, %r10d
cmpq %r10, %r8
je 0x43c52
movsd (%r9,%r10), %xmm2
mulsd (%rdx,%r10), %xmm2
subsd %xmm2, %xmm1
addq $0x8, %r10
jmp 0x43c37
divsd (%r9,%r8), %xmm1
movsd %xmm1, (%rdx,%rdi,8)
movq (%rax,%rdi,8), %r9
movsd %xmm1, (%r9,%rsi,8)
incq %rdi
addq $0x8, %r8
jmp 0x43c1e
incq %rsi
jmp 0x43c14
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/choldc.c
// Function: choldc_f
int choldc_f(float **L, float **a, int N)
{
  int i, j, k, ik, jk;
  double sum, diag[N];
  for(i=0; i<N; i++){
    for(j=i; j<N; j++){
      sum=a[i][j];
      for(k=i-1; k>=0; k--)sum-=L[i][k]*L[j][k];
      if(j==i){
	if(sum<EPS){
	  printf("WARNING, Choldc failed L_ii^2= %.2g i=%d\n", sum, i);
	  if(a==L){
	    // Ugo: Restore lower diagonal 
	    for(ik=0; ik<i; ik++){
	      a[ik][ik]=diag[ik];
	      for(jk=ik+1; jk<N; jk++)a[jk][ik]=a[ik][jk];
	    }
	  }
	  return(-1);
	}
	diag[i]=a[i][i]; L[i][i]=sqrt(sum);
      }else{
	L[j][i]=sum/L[i][i]; // j<=i 
      }
    }
  }
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r8
movl %edx, %r9d
movq %rsp, %rdi
leaq 0xf(,%r9,8), %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
movsd 0x14267(%rip), %xmm2    # 0x57f28
xorpd %xmm3, %xmm3
xorl %r15d, %r15d
movq %rdi, -0x30(%rbp)
movq %r8, -0x48(%rbp)
movq %r9, -0x40(%rbp)
movq %rax, -0x38(%rbp)
cmpq %rax, %r15
je 0x43e09
leaq (%r8,%r15,8), %r12
movq %r15, %r13
cmpq %r9, %r13
je 0x43d8f
movq (%r14,%r15,8), %rcx
cvtss2sd (%rcx,%r13,4), %xmm0
leaq (%r8,%r13,8), %rax
movq %r15, %rdx
testq %rdx, %rdx
jle 0x43d27
movq (%r12), %rsi
movss -0x4(%rsi,%rdx,4), %xmm1
movq (%rax), %rsi
mulss -0x4(%rsi,%rdx,4), %xmm1
decq %rdx
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm0
jmp 0x43d02
cmpq %r15, %r13
jne 0x43d4a
ucomisd %xmm0, %xmm2
ja 0x43d9b
cvtss2sd (%rcx,%r15,4), %xmm1
movsd %xmm1, (%rdi,%r15,8)
ucomisd %xmm3, %xmm0
jb 0x43d5a
sqrtsd %xmm0, %xmm0
jmp 0x43d77
movq (%r12), %rcx
cvtss2sd (%rcx,%r15,4), %xmm1
divsd %xmm1, %xmm0
jmp 0x43d7a
callq 0x2290
xorpd %xmm3, %xmm3
movsd 0x141bd(%rip), %xmm2    # 0x57f28
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %rdi
movq %r12, %rax
cvtsd2ss %xmm0, %xmm0
movq (%rax), %rax
movss %xmm0, (%rax,%r15,4)
incq %r13
jmp 0x43ce8
incq %r15
movq -0x38(%rbp), %rax
jmp 0x43cd8
leaq 0x1418e(%rip), %rdi     # 0x57f30
movl %r15d, %esi
movb $0x1, %al
movq %r8, %r12
callq 0x20f0
pushq $-0x1
popq %rax
cmpq %r12, %r14
je 0x43dc6
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %r10d
pushq $0x1
popq %rcx
xorl %edx, %edx
movq -0x30(%rbp), %r9
cmpq %r10, %rdx
je 0x43db7
cvtsd2ss (%r9,%rdx,8), %xmm0
movq (%r14,%rdx,8), %rsi
movss %xmm0, (%rsi,%rdx,4)
movq %rcx, %rdi
cmpl %ebx, %edi
jge 0x43e01
movss (%rsi,%rdi,4), %xmm0
movq (%r14,%rdi,8), %r8
movss %xmm0, (%r8,%rdx,4)
incq %rdi
jmp 0x43de9
incq %rdx
incq %rcx
jmp 0x43dd2
xorl %eax, %eax
jmp 0x43db7
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/choldc.c
// Function: Forward_substitution_f
void Forward_substitution_f(double *X, float **L, double *Y, int N){
  // Solve the matrix equation LX=Y, with L=lower diagonal (only i>=j)
  // X_i = (Y_i - sum_j<i L_ij X_j)/L_ii
  int i, j; double *XX=X;
  for(i=0; i<N; i++){
    double *XY=X; float *LL=L[i];
    *XX=Y[i]; for(j=0; j<i; j++){(*XX)-=(*LL)*(*XY); XY++; LL++;}
    (*XX)/=(*LL);
    XX++;
  }
}

// Assembly:
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movq %rdi, %r8
cmpq %rcx, %rax
je 0x43e5e
movq (%rsi,%rax,8), %r9
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%r8)
xorl %r10d, %r10d
cvtss2sd (%r9,%r10,4), %xmm1
cmpq %r10, %rax
je 0x43e4c
mulsd (%rdi,%r10,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
incq %r10
jmp 0x43e2d
divsd %xmm1, %xmm0
movsd %xmm0, (%r8)
addq $0x8, %r8
incq %rax
jmp 0x43e17
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/lubksb.c
// Function: lubksb
void lubksb(double **a, int n, int *indx, double *b)
{
  int i,ii=0,ip,j;
  double sum;
  
  for(i=0;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-1;i>=0;i--) {
    sum=b[i];
    for (j=i+1;j<n;j++) sum -= a[i][j]*b[j];
    b[i]=sum/a[i][i];
  }
}

// Assembly:
pushq %rbp
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %r8d
cmovgl %esi, %r8d
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
cmpq %r8, %rax
je 0x44115
movslq (%rdx,%rax,4), %r10
movsd (%rcx,%r10,8), %xmm1
movsd (%rcx,%rax,8), %xmm2
movsd %xmm2, (%rcx,%r10,8)
testl %r9d, %r9d
je 0x440fb
movslq %r9d, %r10
cmpq %rax, %r10
jge 0x4410b
movq (%rdi,%rax,8), %r11
movsd (%r11,%r10,8), %xmm2
mulsd (%rcx,%r10,8), %xmm2
subsd %xmm2, %xmm1
incq %r10
jmp 0x440dd
ucomisd %xmm0, %xmm1
jne 0x44103
jnp 0x44108
movl %eax, %r9d
jmp 0x4410b
xorl %r9d, %r9d
movsd %xmm1, (%rcx,%rax,8)
incq %rax
jmp 0x440bb
movl %esi, %r8d
leaq (,%r8,8), %rax
leaq (%rcx,%r8,8), %rdx
testl %r8d, %r8d
jle 0x44172
leaq -0x1(%r8), %r9
movsd (%rcx,%r9,8), %xmm0
movq (%rdi,%r9,8), %r10
leaq (%r10,%rax), %r11
xorl %ebx, %ebx
leal (%r8,%rbx), %ebp
cmpl %esi, %ebp
jge 0x44159
movsd (%r11,%rbx,8), %xmm1
mulsd (%rdx,%rbx,8), %xmm1
subsd %xmm1, %xmm0
incq %rbx
jmp 0x4413d
divsd (%r10,%r9,8), %xmm0
movsd %xmm0, (%rcx,%r9,8)
addq $-0x8, %rdx
addq $-0x8, %rax
movq %r9, %r8
jmp 0x44124
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/d_diagonalize.c
// Function: eigsrt
void eigsrt(double d[], double **v, int n)
{
  int k,j,i;
  double p;
  
  for (i=1;i<n;i++) {
    p=d[k=i];
    for (j=i+1;j<=n;j++)
      if (d[j] >= p) p=d[k=j];
    if (k != i) {
      d[k]=d[i];
      d[i]=p;
      for (j=1;j<=n;j++) {
	p=v[j][i];
	v[j][i]=v[j][k];
	v[j][k]=p;
      }
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
leal 0x1(%rdx), %eax
movslq %edx, %rcx
movabsq $0x2, %r8
movabsq $0x1, %r9
movq %r9, %r10
cmpq %rcx, %r10
jge 0x44bb4
movsd (%rdi,%r10,8), %xmm0
movq %r8, %rbx
movl %r10d, %r11d
movapd %xmm0, %xmm1
cmpl %edx, %ebx
jg 0x44b6c
movsd (%rdi,%rbx,8), %xmm2
ucomisd %xmm1, %xmm2
cmovael %ebx, %r11d
movapd %xmm1, %xmm3
cmpnlesd %xmm2, %xmm3
movapd %xmm3, %xmm4
andnpd %xmm2, %xmm4
andpd %xmm1, %xmm3
orpd %xmm4, %xmm3
incq %rbx
movapd %xmm3, %xmm1
jmp 0x44b39
movl %r11d, %ebx
cmpq %rbx, %r10
jne 0x44b7c
incq %r10
incq %r8
jmp 0x44b20
movslq %r11d, %r11
movsd %xmm0, (%rdi,%r11,8)
movsd %xmm1, (%rdi,%r10,8)
movq %r9, %rbx
cmpq %rbx, %rax
je 0x44b74
movq (%rsi,%rbx,8), %r14
movsd (%r14,%r10,8), %xmm0
movsd (%r14,%r11,8), %xmm1
movsd %xmm1, (%r14,%r10,8)
movsd %xmm0, (%r14,%r11,8)
incq %rbx
jmp 0x44b8e
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/d_diagonalize.c
// Function: Select_modes
void Select_modes(int *selected, double *eigen_va, float E_MIN, int N)
{
  /* printf("Discarding modes with e_val/<e_val> < %.2g ", E_MIN*0.001);
     printf(" or e_val/<e_val> < %.2g, coll < %.f\n",E_MIN, COLL_THR);
     int n=0; */
  float E_THR=E_MIN; int i;
  double e=0; for(i=1; i<=N; i++)e+=eigen_va[i];
  if(e<0){e=-e;} E_THR*=(e/N);
  for(i=1; i<=N; i++){
    if(eigen_va[i]<E_THR){
      selected[i]=0;
    }else{
      selected[i]=1;
    }
  }
}

// Assembly:
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
je 0x44bd8
addsd 0x8(%rsi,%rcx,8), %xmm1
incq %rcx
jmp 0x44bc8
movapd 0x64e0(%rip), %xmm2     # 0x4b0c0
xorpd %xmm1, %xmm2
cvtsi2sd %edx, %xmm3
maxsd %xmm1, %xmm2
divsd %xmm3, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x44c1b
xorl %edx, %edx
ucomisd 0x8(%rsi,%rcx,8), %xmm0
setbe %dl
movl %edx, 0x4(%rdi,%rcx,4)
incq %rcx
jmp 0x44c02
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/d_diagonalize.c
// Function: Select_modes_coll
void Select_modes_coll(int *selected, double *eigen_va, double **eigen_vt,
		       float E_MIN, float COLL_THR, int N)
{
  /* printf("Discarding modes with e_val/<e_val> < %.2g ", E_MIN*0.001);
     printf(" or e_val/<e_val> < %.2g, coll < %.f\n",E_MIN, COLL_THR);
     int n=0; */
  float E_THR=E_MIN; int i, j;
  double e=0; for(j=1; j<=N; j++)e+=eigen_va[j];
  if(e<0){e=-e;} E_THR*=(e/N);
  float E_THR2=E_THR*0.001;
  for(i=1; i<=N; i++){
    selected[i]=1;
    if(eigen_va[i]<E_THR){
      if(eigen_va[i]<E_THR2){
	selected[i]=0;
      }else{
	double sum=0, Entropy=0;
	for(j=1; j<=N; j++){
	  float v=eigen_vt[j][i];
	  if(v){v*=v; sum+=v; Entropy-=v*log(v);}
	}
	float c=sum*exp(Entropy/sum);
	if(c<COLL_THR){
	  selected[i]=0;
	  //printf("%.1f %f\n", c, eigen_va[i]); n++;
	}
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movss %xmm1, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %ecx
cmovgl %ebx, %ecx
leal 0x1(%rcx), %edx
xorpd %xmm1, %xmm1
cmpq %rax, %rcx
je 0x44c5f
addsd 0x8(%r15,%rax,8), %xmm1
incq %rax
jmp 0x44c4e
movapd 0x6459(%rip), %xmm2     # 0x4b0c0
xorpd %xmm1, %xmm2
cvtsi2sd %ebx, %xmm3
maxsd %xmm1, %xmm2
divsd %xmm3, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xc641(%rip), %xmm0     # 0x512d0
movsd %xmm1, 0x20(%rsp)
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
incl %ebx
pushq $0x1
popq %rbp
movq %rdx, 0x10(%rsp)
cmpq %rdx, %rbp
je 0x44d81
movl $0x1, (%r12,%rbp,4)
movsd (%r15,%rbp,8), %xmm0
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x44d79
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x44d74
xorpd %xmm1, %xmm1
pushq $0x1
popq %r13
xorpd %xmm2, %xmm2
cmpq %r13, %rbx
je 0x44d49
movq (%r14,%r13,8), %rax
cvtsd2ss (%rax,%rbp,8), %xmm0
ucomiss 0x6303(%rip), %xmm0     # 0x4b00c
jne 0x44d0d
jnp 0x44d44
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd %xmm2, 0x30(%rsp)
callq 0x2120
movsd 0x30(%rsp), %xmm2
movsd (%rsp), %xmm1
mulsd 0x28(%rsp), %xmm0
subsd %xmm0, %xmm2
incq %r13
jmp 0x44cf4
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
movsd %xmm1, (%rsp)
callq 0x22a0
mulsd (%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movq 0x10(%rsp), %rdx
jbe 0x44d79
andl $0x0, (%r12,%rbp,4)
incq %rbp
jmp 0x44cb1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nrutil.c
// Function: nrerror
void nrerror(char error_text[])
/* Numerical Recipes standard error handler */
{
  fprintf(stderr,"Numerical Recipes run-time error...\n");
  fprintf(stderr,"%s\n",error_text);
  fprintf(stderr,"...now exiting to system...\n");
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1d259(%rip), %r15     # 0x61ff8
movq (%r15), %rcx
leaq 0x1320f(%rip), %rdi     # 0x57fb8
pushq $0x24
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x2280
movq (%r15), %rdi
leaq 0x12813(%rip), %rsi     # 0x575d5
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2190
movq (%r15), %rcx
leaq 0x13207(%rip), %rdi     # 0x57fdd
pushq $0x1c
popq %rsi
movq %r14, %rdx
callq 0x2280
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nrutil.c
// Function: vector
float *vector(long nl, long nh)
/* allocate a float vector with subscript range v[nl..nh] */
{
  float *v;
  
  v=(float *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(float)));
  if (!v) nrerror("allocation failure in vector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x8(,%rsi,4), %rdi
callq 0x21d0
testq %rax, %rax
je 0x44e0f
shlq $0x2, %rbx
subq %rbx, %rax
addq $0x4, %rax
popq %rbx
retq
leaq 0x131e4(%rip), %rdi     # 0x57ffa
callq 0x44d90
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nrutil.c
// Function: ivector
int *ivector(long nl, long nh)
/* allocate an int vector with subscript range v[nl..nh] */
{
  int *v;

  v=(int *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(int)));
  if (!v) nrerror("allocation failure in ivector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x8(,%rsi,4), %rdi
callq 0x21d0
testq %rax, %rax
je 0x44e41
shlq $0x2, %rbx
subq %rbx, %rax
addq $0x4, %rax
popq %rbx
retq
leaq 0x131d1(%rip), %rdi     # 0x58019
callq 0x44d90
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nrutil.c
// Function: cvector
unsigned char *cvector(long nl, long nh)
     /* allocate an unsigned char vector with subscript range v[nl..nh] */
{
  unsigned char *v;
  
  v=(unsigned char *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(unsigned char)));
  if (!v) nrerror("allocation failure in cvector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x2(%rsi), %rdi
callq 0x21d0
testq %rax, %rax
je 0x44e6a
subq %rbx, %rax
incq %rax
popq %rbx
retq
leaq 0x131c8(%rip), %rdi     # 0x58039
callq 0x44d90
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nrutil.c
// Function: lvector
unsigned long *lvector(long nl, long nh)
     /* allocate an unsigned long vector with subscript range v[nl..nh] */
{
  unsigned long *v;
  
  v=(unsigned long *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(long)));
  if (!v) nrerror("allocation failure in lvector()");
  return v-nl+NR_END;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
subq %rdi, %rsi
leaq 0x10(,%rsi,8), %rdi
callq 0x21d0
testq %rax, %rax
je 0x44e9c
shlq $0x3, %rbx
subq %rbx, %rax
addq $0x8, %rax
popq %rbx
retq
leaq 0x131b6(%rip), %rdi     # 0x58059
callq 0x44d90