LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/allostery.c
// Function: Eigenvalue_main
float Eigenvalue_main(double **Corr, int Na)
{
  int i;
  float *eigenval=malloc(Na*sizeof(double));
  float **eigenvec=malloc(Na*sizeof(float *));
  for(i=0; i<Na; i++)eigenvec[i]=malloc(Na*sizeof(float));
  d_Diagonalize(Na, Corr, eigenval, eigenvec, 1);
  float Ev=eigenval[0];
  Empty_matrix_f(eigenvec, Na); free(eigenval);
  return(Ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x62207
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x621d8
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %r8d
callq 0x6ac30
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x69240
movq -0x18(%rbp), %rdi
callq 0x1040
movss -0x24(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/allostery.c
// Function: Print_names
void Print_names(int N, char **pdbres, char *amm, char *chain,
		 char *nameout1)
{
  int i;  char nameout[200];
  sprintf(nameout, "%s.names.dat", nameout1);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  for(i=0; i<N; i++){
    fprintf(file_out, "%d %c_%s_%c\n", i, amm[i], pdbres[i], chain[i]);
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x100(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x20517(%rip), %rsi     # 0x82797
movb $0x0, %al
callq 0x1200
leaq -0x100(%rbp), %rdi
leaq 0x1a0dd(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0x108(%rbp)
leaq -0x100(%rbp), %rsi
leaq 0x1523f(%rip), %rdi     # 0x774ee
movb $0x0, %al
callq 0x10d0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6230d
movq -0x108(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rsi
movq (%rax,%rsi,8), %r8
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rsi
movsbl (%rax,%rsi), %r9d
leaq 0x204a9(%rip), %rsi     # 0x827a4
movb $0x0, %al
callq 0x1150
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x622bd
movq -0x108(%rbp), %rdi
callq 0x10a0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/allostery.c
// Function: Negexp_distance
float **Negexp_distance(float **d02ij, int Na, float D)
{
  float **eij=Allocate_mat2_f(Na, Na);
  for(int i=0; i<Na; i++){
    eij[i][i]=1;
    for(int j=0; j<i; j++){
      eij[i][j]=exp(-sqrt(d02ij[i][j])/D);
      eij[j][i]=eij[i][j];
    }
  }
  return(eij);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x69360
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x62cbe
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movss 0x13492(%rip), %xmm0    # 0x76090
movss %xmm0, (%rax,%rcx,4)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x62cae
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1220
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movss -0x10(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x1230
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x62c0a
jmp 0x62cb0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x62bda
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x659b1
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x65982
movq -0x50(%rbp), %rdx
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl $0x1, %r8d
callq 0x6ac30
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x65a0a
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x659dd
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x69240
movq -0x50(%rbp), %rax
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x65a58
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x65a64
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movslq -0x20(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x69360
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x694a0
movq %rax, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x65b38
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x65b28
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x65b1b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x40(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65abc
jmp 0x65b1d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x65aad
jmp 0x65b2a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x65a9a
movl -0x20(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %r8d
callq 0x6ac30
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1220
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x692a0
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x69240
movq -0x30(%rbp), %rdi
callq 0x1040
movss -0x44(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x65bfd
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65bbe
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x1220
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x65c4a
movsd -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65c1c
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x65d81
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x65cc3
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x40(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x65cb6
jmp 0x65cc3
jmp 0x65cb8
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x65c90
movl -0x38(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cmpq $0x0, -0x30(%rbp)
je 0x65ce8
movq -0x30(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
jmp 0x65cee
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x65d33
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x65d71
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x65d51
movl -0x3c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x65d6f
movl -0x3c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x65d71
jmp 0x65d73
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x65c7d
movl -0x34(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x65e5a
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x65e15
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x65e08
movl -0x2c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x65e15
jmp 0x65e0a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x65dd4
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x65e4a
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
movl -0x24(%rbp), %edx
leaq 0x1c878(%rip), %rdi     # 0x826b1
movb $0x0, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
jmp 0x65e4c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x65db2
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x6691e
jmp 0x669ad
cmpl $0x1, -0x14(%rbp)
jne 0x66931
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x669ad
cvtsi2sdl -0x14(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd (%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movl -0x14(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x1220
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x67134
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x670fe
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x30(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x670b0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6707f
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6722b
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6721b
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6720e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x67210
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6719e
jmp 0x6721d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6716f
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x67290
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6728e
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x67281
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6724b
jmp 0x67283
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6723c
jmp 0x67290
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x11000
leaq -0x150(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movq 0x10(%rbp), %rcx
leaq 0x1b446(%rip), %rsi     # 0x82a0f
movb $0x0, %al
callq 0x1200
leaq -0x150(%rbp), %rsi
leaq 0x1b43f(%rip), %rdi     # 0x82a1d
movb $0x0, %al
callq 0x10d0
leaq -0x150(%rbp), %rdi
leaq 0x14d7f(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0x168(%rbp)
movl $0x0, -0x15c(%rbp)
movl -0x15c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6771b
movq -0x18(%rbp), %rax
movslq -0x15c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6764e
movq -0x168(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x15c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1b3f3(%rip), %rsi     # 0x82a3a
movb $0x0, %al
callq 0x1150
movl $0x0, -0x160(%rbp)
movl -0x160(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x15c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x67705
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x15c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x160(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x170(%rbp)
leaq -0x155(%rbp), %rdi
movq -0x170(%rbp), %rax
movswl 0x14(%rax), %esi
callq 0x37330
movq -0x168(%rbp), %rdi
movl -0x15c(%rbp), %edx
addl $0x1, %edx
leaq -0x155(%rbp), %rcx
movq -0x170(%rbp), %rax
movsbl 0xc(%rax), %r8d
movq -0x170(%rbp), %r9
addq $0xd, %r9
leaq 0x1b365(%rip), %rsi     # 0x82a4f
movb $0x0, %al
callq 0x1150
movl -0x160(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x160(%rbp)
jmp 0x67658
jmp 0x67707
movl -0x15c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x15c(%rbp)
jmp 0x67609
movq -0x168(%rbp), %rdi
callq 0x10a0
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x68f24
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x69005
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x13463(%rip), %rsi     # 0x7c39e
movb $0x0, %al
callq 0x11a0
movq -0x28(%rbp), %rax
movb 0x4(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rdi
addq $0x5, %rdi
leaq 0x19750(%rip), %rsi     # 0x826ae
leaq -0x3c(%rbp), %rdx
movb $0x0, %al
callq 0x11a0
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %edx
leaq 0x19737(%rip), %rsi     # 0x826ae
movb $0x0, %al
callq 0x1200
movq -0x28(%rbp), %rax
movsbl 0x9(%rax), %eax
cmpl $0x20, %eax
je 0x68fb2
leaq -0x3e(%rbp), %rdi
movq -0x28(%rbp), %rax
movsbl 0x9(%rax), %edx
leaq 0x19c98(%rip), %rsi     # 0x82c36
movb $0x0, %al
callq 0x1200
movq -0x10(%rbp), %rdi
leaq -0x3e(%rbp), %rsi
callq 0x11e0
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x68fc7
movl $0x0, -0x4(%rbp)
jmp 0x69005
jmp 0x68fc9
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x68ffe
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x68ff0
movl $0x0, -0x4(%rbp)
jmp 0x69005
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x68fc9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x69042
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x69049
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x690a8
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
addq $0xd, %rdi
movq -0x10(%rbp), %rsi
callq 0x1140
cmpl $0x0, %eax
jne 0x6909b
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl 0xc(%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6909b
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6910f
jmp 0x6909d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6904f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x69108
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
addq $0xd, %rdi
movq -0x10(%rbp), %rsi
callq 0x1140
cmpl $0x0, %eax
jne 0x690fb
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl 0xc(%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x690fb
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6910f
jmp 0x690fd
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x690af
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x69159
movq -0x18(%rbp), %rax
movl (%rax), %edx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x2c(%rbp), %eax
jle 0x69193
movl -0x2c(%rbp), %esi
leaq 0x1a053(%rip), %rdi     # 0x831d6
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x691b6
movl $0x64, %edi
callq 0x1180
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6923a
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6922d
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x69220
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6922d
jmp 0x69222
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x691fd
jmp 0x6922f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x691e0
movl -0x20(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/allocate.c
// Function: Empty_matrix_f
void Empty_matrix_f(float **matrix, int N){
  int i;
  if(matrix==NULL)return;
  for(i=0; i<N; i++)free(matrix[i]);
  free(matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x69258
jmp 0x6928c
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x69283
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6925f
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/allocate.c
// Function: Empty_matrix_d
void Empty_matrix_d(double **matrix, int N){
  int i;
  if(matrix==NULL)return;
  for(i=0; i<N; i++)free(matrix[i]);
  free(matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x692b8
jmp 0x692ec
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x692e3
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x692bf
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/allocate.c
// Function: Empty_matrix_i
void Empty_matrix_i(int **matrix, int N){
  int i;
  if(matrix==NULL)return;
  for(i=0; i<N; i++)free(matrix[i]);
  free(matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x69318
jmp 0x6934c
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x69343
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6931f
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x693e9
movslq -0x8(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x693dc
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x693b1
jmp 0x693de
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x69386
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x69488
movslq -0x8(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x6947b
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x69451
jmp 0x6947d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x69426
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x69529
movslq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x6951c
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x694f1
jmp 0x6951e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x694c6
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x698ba
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x69888
movq -0x40(%rbp), %rax
movsd (%rax), %xmm0
movq -0x38(%rbp), %rax
movsd (%rax), %xmm2
movq -0x30(%rbp), %rax
movsd (%rax), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x69822
movq -0x40(%rbp), %rax
movsd (%rax), %xmm1
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x697e2
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x699a8
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6996f
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x69909
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x698dc
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
movl %esi, %edi
callq 0x69360
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x69b32
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x69ae2
movq -0x58(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x69a4f
movsd 0xc5fe(%rip), %xmm0     # 0x76048
movsd %xmm0, -0x50(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x69aba
movq -0x40(%rbp), %rax
movsd (%rax), %xmm0
movq -0x48(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x50(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x69a56
movq -0x58(%rbp), %rax
movsd -0x50(%rbp), %xmm0
movq -0x40(%rbp), %rcx
divsd (%rcx), %xmm0
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x69a0e
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x69b22
movq -0x58(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x69ae9
jmp 0x69b24
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x699fb
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
movl %esi, %edi
callq 0x694a0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x69cb0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x69ca0
movq -0x58(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x69bef
movsd 0xc45e(%rip), %xmm0     # 0x76048
movsd %xmm0, -0x50(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x69c5a
movq -0x40(%rbp), %rax
movsd (%rax), %xmm0
movq -0x48(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x50(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x69bf6
movq -0x58(%rbp), %rax
movsd -0x50(%rbp), %xmm0
movq -0x40(%rbp), %rcx
divsd (%rcx), %xmm0
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x69bae
jmp 0x69ca2
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x69b9b
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6a042
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6a00c
movq -0x40(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x38(%rbp), %rax
movsd (%rax), %xmm2
movq -0x30(%rbp), %rax
movsd (%rax), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x69fa2
movq -0x40(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x69f62
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop