LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/output_tnm.c
// Function: Print_change
int Print_change(float *Fluct_pred, float *Fluct_obs, int N,
		char *nameout, char *what)
{
  char namefile[200]; FILE *file_out; int i;
  sprintf(namefile, "%s_%s_dev.dat", nameout, what);
  file_out=fopen(namefile, "w");
  printf("Writing %s\n", namefile);

  fprintf(file_out, "# Squared deviation\n# Pred Obs\n");
  for(i=0; i<N; i++)
    fprintf(file_out, "%.4f %.4f\n", Fluct_pred[i], Fluct_obs[i]);
  fclose(file_out);
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1a844(%rip), %rsi     # 0x5d027
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rdx
movq %r8, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x14a43(%rip), %rsi     # 0x57240
movq %r12, %rdi
callq 0x2210
movq %rax, %r15
leaq 0xf4cc(%rip), %rdi      # 0x51cdb
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x1a815(%rip), %rdi     # 0x5d035
movl $0x1f, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2280
testl %ebp, %ebp
jle 0x42868
movl %ebp, %r13d
xorl %ebp, %ebp
leaq 0x1a813(%rip), %r12     # 0x5d055
xorps %xmm0, %xmm0
cvtss2sd (%r14,%rbp,4), %xmm0
xorps %xmm1, %xmm1
cvtss2sd (%rbx,%rbp,4), %xmm1
movq %r15, %rdi
movq %r12, %rsi
movb $0x2, %al
callq 0x2190
incq %rbp
cmpq %rbp, %r13
jne 0x42842
movq %r15, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/allostery.c
// Function: Extract_atoms
int Extract_atoms(int *iref, int *iatom, int *atomres, // Output
		  struct residue *seq, float *mass,
		  atom *atoms, struct Reference Ref, char *ANAME)
{
  /* 
     iref[i]= representative atom (kin) of representative atom i (allostery)
     iatom=   atom number of representative atom i (allostery)
     atomres= representative atom (allostery) of residue
   */
  int ia, Na=0, Nres=atoms[Ref.atom_num[Ref.N_ref-1]].res+1;
  for(ia=0; ia<Nres; ia++)atomres[ia]=-1;
  for(ia=0; ia<Ref.N_ref; ia++){
    atom *atom_i=atoms+Ref.atom_num[ia];
    if((strncmp(atom_i->name, ANAME, 2)==0)||
       ((seq[atom_i->res].amm=='G')&&(strncmp(atom_i->name, "CA", 2)==0))){
      if(*mass==0)*mass=Ref.mass_atom[ia];
      iref[Na]=ia;
      iatom[Na]=Ref.atom_num[ia];
      //ires[Na]=atom_i->res;
      atomres[atom_i->res]=Na; Na++;
    }
  }
  /*for(ia=0; ia<Na; ia++){
    int r=(atoms+Ref.atom_num[iref[ia]])->res;
    printf("%d %c %s %s\n", ia, seq[r].amm, seq[r].pdbres,
    (atoms+Ref.atom_num[iref[ia]])->name);
   }
   exit(8);*/
  return(Na);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x98(%rsp), %r13
movslq 0x70(%rsp), %rax
movq %rax, (%rsp)
movslq -0x4(%r13,%rax,4), %rax
imulq $0x70, %rax, %rax
movl 0x64(%r9,%rax), %eax
testl %eax, %eax
js 0x442c7
leaq 0x4(,%rax,4), %rdx
movq %r14, %rdi
movl $0xff, %esi
callq 0x2110
cmpl $0x0, (%rsp)
jle 0x4439c
movq %r14, 0x10(%rsp)
leaq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
movslq (%r13,%r14,4), %rax
imulq $0x70, %rax, %rax
leaq (%rbx,%rax), %r15
leaq (%rbx,%rax), %r12
addq $0x18, %r12
movl $0x2, %edx
movq %r12, %rdi
movq 0xa0(%rsp), %rsi
callq 0x2070
testl %eax, %eax
je 0x44343
movslq 0x64(%r15), %rax
shlq $0x5, %rax
movq 0x30(%rsp), %rcx
cmpb $0x47, 0x13(%rcx,%rax)
jne 0x4438d
movl $0x2, %edx
movq %r12, %rdi
leaq 0x10e30(%rip), %rsi     # 0x5516a
callq 0x2070
testl %eax, %eax
jne 0x4438d
movq 0x28(%rsp), %rax
movss (%rax), %xmm0
ucomiss 0xccb9(%rip), %xmm0     # 0x5100c
jne 0x44366
jp 0x44366
movq 0x8(%rsp), %rcx
movss (%rcx,%r14,4), %xmm0
movss %xmm0, (%rax)
movslq %ebp, %rbp
movq 0x18(%rsp), %rax
movl %r14d, (%rax,%rbp,4)
movl (%r13,%r14,4), %eax
movq 0x20(%rsp), %rcx
movl %eax, (%rcx,%rbp,4)
movslq 0x64(%r15), %rax
movq 0x10(%rsp), %rcx
movl %ebp, (%rcx,%rax,4)
incl %ebp
incq %r14
cmpq %r14, (%rsp)
jne 0x442e9
jmp 0x4439e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/allostery.c
// Function: Pairwise_distances
void Pairwise_distances(float **d02ij, float ***r0ijk, 
			atom *atoms, int *iatom, int Na)
{
  int ia, ja, k;
  for(ia=0; ia<Na; ia++){
    double *ri=atoms[iatom[ia]].r;
    float *dij=malloc(Na*sizeof(float));
    d02ij[ia]=dij;
    float **rij=Allocate_mat2_f(Na,3);
    r0ijk[ia]=rij;
    for(ja=0; ja<ia; ja++){
      double *rj=atoms[iatom[ja]].r, sum=0;
      float *d=rij[ja];
      for(k=0; k<3; k++){
	*d=ri[k]-(*rj); sum+=(*d)*(*d); d++; rj++;
      }
      dij[ja]=sum;
      sum=sqrt(sum);
      d=rij[ja]; for(k=0; k<3; k++){(*d)/=sum; d++;}
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movl %r8d, 0xc(%rsp)
testl %r8d, %r8d
jle 0x444de
movq %rcx, %r14
movl 0xc(%rsp), %eax
movq %rax, 0x20(%rsp)
leaq (,%rax,4), %rax
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
movslq (%r14,%rbp,4), %rbx
movq 0x18(%rsp), %rdi
callq 0x21d0
movq %rax, %r12
movq 0x28(%rsp), %rax
movq %r12, (%rax,%rbp,8)
movl 0xc(%rsp), %edi
movl $0x3, %esi
callq 0x496ae
movq %rax, %r13
movq 0x30(%rsp), %rax
movq %r13, (%rax,%rbp,8)
testq %rbp, %rbp
je 0x444d0
imulq $0x70, %rbx, %rbx
addq 0x10(%rsp), %rbx
xorl %r15d, %r15d
movslq (%r14,%r15,4), %rax
imulq $0x70, %rax, %rax
addq 0x10(%rsp), %rax
movq (%r13,%r15,8), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rbx,%rdx,8), %xmm1
subsd (%rax,%rdx,8), %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rcx,%rdx,4)
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq $0x3, %rdx
jne 0x44456
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movss %xmm1, (%r12,%r15,4)
ucomisd 0xcbcd(%rip), %xmm0     # 0x51060
jb 0x4449b
sqrtsd %xmm0, %xmm0
jmp 0x444a0
callq 0x2290
movq (%r13,%r15,8), %rax
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtss2sd (%rax,%rcx,4), %xmm1
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rax,%rcx,4)
incq %rcx
cmpl $0x3, %ecx
jne 0x444a7
incq %r15
cmpq %rbp, %r15
jne 0x4443e
incq %rbp
cmpq 0x20(%rsp), %rbp
jne 0x443f5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, (%rsp)
movslq %esi, %rbp
leaq (,%rbp,8), %r12
movq %r12, %rdi
callq 0x21d0
movq %rax, %r14
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
testl %ebp, %ebp
jle 0x44577
leaq (,%rbp,4), %r13
movl %ebp, %ebp
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r12,%r15,8)
incq %r15
cmpq %r15, %rbp
jne 0x44563
movl %ebx, %edi
movq (%rsp), %rsi
movq %r14, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x4a4d2
movss (%r14), %xmm0
movss %xmm0, (%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x4960c
movq %r14, %rdi
callq 0x2050
movss (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
leaq 0x18df3(%rip), %rsi     # 0x5d3d4
movq %rsp, %r13
movq %r13, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x12c48(%rip), %rsi     # 0x57240
movq %r13, %rdi
callq 0x2210
movq %rax, %r12
leaq 0xd6d1(%rip), %rdi      # 0x51cdb
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
testl %ebp, %ebp
jle 0x44646
movl %ebp, %r13d
xorl %ebp, %ebp
movsbl (%r14,%rbp), %ecx
movq (%r15,%rbp,8), %r8
movsbl (%rbx,%rbp), %r9d
movq %r12, %rdi
leaq 0x18dac(%rip), %rsi     # 0x5d3e1
movl %ebp, %edx
xorl %eax, %eax
callq 0x2190
incq %rbp
cmpq %rbp, %r13
jne 0x4461d
movq %r12, %rdi
callq 0x20c0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/allostery.c
// Function: Make_profile
float *Make_profile(float **Mat, int N, char PROF_TYPE, char *what)
{
  printf("Computing profiles of %s type %c\n", what, PROF_TYPE);
  float *prof=malloc(N*sizeof(float)); int i;
  float weight[N], sum_weight=0;
  if(PROF_TYPE=='A'){
    sum_weight=N; for(i=0; i<N; i++)weight[i]=1;
  }else{
    double **Mat2=Get_matrix_positive(Mat, N);
    if(PROF_TYPE=='P'){
      PE_profile(weight, Mat2, N);
    }else if(PROF_TYPE=='C'){
      float *c=EC_profile(NULL, Mat2, N, what);
      for(i=0; i<N; i++)weight[i]=c[i];
      free(c);
    }
    for(i=0; i<N; i++)sum_weight+=weight[i];
    Empty_matrix_d(Mat2, N);
  }
  for(i=0; i<N; i++){
    double sum=0; float *Ca=Mat[i];
    for(int j=0; j<N; j++)if(j!=i)sum+=Ca[j]*weight[j];
    prof[i]=sum/(sum_weight-weight[i]);
  }
  return(prof);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x18ade(%rip), %rdi     # 0x5d54b
movq %rcx, -0x40(%rbp)
movq %rcx, %rsi
xorl %eax, %eax
callq 0x20f0
movl %r14d, -0x2c(%rbp)
movslq %r14d, %r15
leaq (,%r15,4), %rdi
callq 0x21d0
movq %rax, %r14
movl %r15d, %r12d
movq %rsp, %r15
leaq 0xf(,%r12,4), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movl %r13d, -0x38(%rbp)
cmpb $0x41, %r13b
jne 0x44add
movl -0x2c(%rbp), %r13d
cvtsi2ss %r13d, %xmm2
testl %r13d, %r13d
jle 0x44b83
xorl %eax, %eax
movl $0x3f800000, (%r15,%rax,4) # imm = 0x3F800000
incq %rax
cmpq %rax, %r12
jne 0x44ac8
jmp 0x44b83
movq %rbx, %rdi
movl -0x2c(%rbp), %esi
callq 0x47f47
movsbl -0x38(%rbp), %ecx
cmpl $0x43, %ecx
je 0x44b0f
cmpl $0x50, %ecx
movl -0x2c(%rbp), %r13d
jne 0x44b56
movq %r15, %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl %r13d, %edx
callq 0x469e8
jmp 0x44b52
xorl %edi, %edi
movq %rax, -0x38(%rbp)
movq %rax, %rsi
movl -0x2c(%rbp), %r13d
movl %r13d, %edx
movq -0x40(%rbp), %rcx
callq 0x4f608
testl %r13d, %r13d
jle 0x44b46
leaq (,%r12,4), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %rax, %r13
callq 0x21a0
movq %r13, %rax
movq %rax, %rdi
callq 0x2050
movl -0x2c(%rbp), %r13d
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
testl %r13d, %r13d
jle 0x44b6e
xorl %ecx, %ecx
addss (%r15,%rcx,4), %xmm0
incq %rcx
cmpq %rcx, %r12
jne 0x44b60
movss %xmm0, -0x2c(%rbp)
movq %rax, %rdi
movl %r13d, %esi
callq 0x49642
movss -0x2c(%rbp), %xmm2
testl %r13d, %r13d
jle 0x44bd6
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rax
je 0x44bab
movss (%rcx,%rdx,4), %xmm1
mulss (%r15,%rdx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %r12
jne 0x44b93
movaps %xmm2, %xmm1
subss (%r15,%rax,4), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r14,%rax,4)
incq %rax
cmpq %r12, %rax
jne 0x44b8a
movq %r14, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %edi
callq 0x496ae
movq %rax, %r14
testl %ebp, %ebp
jle 0x44c92
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl %ebp, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rax
movl $0x3f800000, (%rax,%r12,4) # imm = 0x3F800000
testq %r12, %r12
je 0x44c8a
xorl %r13d, %r13d
movq (%rbx,%r12,8), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r13,4), %xmm0
ucomisd 0xc415(%rip), %xmm0     # 0x51060
jb 0x44c53
sqrtsd %xmm0, %xmm0
jmp 0x44c58
callq 0x2290
xorpd 0xc430(%rip), %xmm0     # 0x51090
divsd (%rsp), %xmm0
callq 0x22a0
cvtsd2ss %xmm0, %xmm0
movq (%r14,%r12,8), %rax
movss %xmm0, (%rax,%r13,4)
movq (%r14,%r13,8), %rax
movss %xmm0, (%rax,%r12,4)
incq %r13
cmpq %r13, %r12
jne 0x44c36
incq %r12
cmpq %r15, %r12
jne 0x44c22
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
testq %rdi, %rdi
je 0x45c45
movq %r8, %r15
movl %ecx, %ebp
movq %rsi, %r14
movl %r9d, (%rsp)
movl %ecx, %edi
movl %ecx, %esi
callq 0x49798
movq %rax, %rbx
movl %ebp, %r12d
movl %ebp, 0xc(%rsp)
testl %ebp, %ebp
jle 0x45b2e
leaq (,%r12,8), %r13
xorl %ebp, %ebp
movq (%r14,%rbp), %rdi
addq $0x8, %rbp
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2110
cmpq %rbp, %r13
jne 0x45b17
movq %r12, 0x10(%rsp)
movl (%rsp), %eax
testl %eax, %eax
jle 0x45bdf
movb (%r15), %cl
movl %eax, %eax
movq %rax, (%rsp)
xorl %edx, %edx
xorl %esi, %esi
movl %esi, %edi
movl %ecx, %r8d
movb (%r15,%rdx), %cl
xorl %esi, %esi
cmpb %r8b, %cl
setne %sil
addl %edi, %esi
testq %rdx, %rdx
je 0x45bd2
movb (%r15), %r13b
movq 0x20(%rsp), %rax
movq (%rax,%rdx,8), %rdi
movq 0x18(%rsp), %rax
movq (%rax,%rdx,8), %r8
movl %esi, %r10d
movq (%rbx,%r10,8), %r9
movq (%r14,%r10,8), %r10
xorl %r11d, %r11d
xorl %ebp, %ebp
movb (%r15,%r11), %r12b
xorl %eax, %eax
cmpb %r13b, %r12b
setne %al
addl %eax, %ebp
movss (%rdi,%r11,4), %xmm0
movss (%r8,%r11,4), %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
addsd (%r9,%rbp,8), %xmm1
movsd %xmm1, (%r9,%rbp,8)
cvtss2sd %xmm0, %xmm0
addsd (%r10,%rbp,8), %xmm0
movsd %xmm0, (%r10,%rbp,8)
incq %r11
movl %r12d, %r13d
cmpq %r11, %rdx
jne 0x45b89
incq %rdx
cmpq (%rsp), %rdx
jne 0x45b4b
cmpl $0x0, 0xc(%rsp)
jle 0x45c47
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x10(%rsp), %r10
movq (%r14,%rax,8), %rsi
movq (%rbx,%rax,8), %rdi
leaq 0x8(%rcx), %rdx
xorl %r8d, %r8d
movsd (%rdi,%r8), %xmm0
divsd (%rsi,%r8), %xmm0
movsd %xmm0, (%rdi,%r8)
cmpq %r8, %rcx
je 0x45c2f
movq (%rbx,%r8), %r9
movsd %xmm0, (%r9,%rax,8)
movsd (%rsi,%r8), %xmm0
movq (%r14,%r8), %r9
movsd %xmm0, (%r9,%rax,8)
addq $0x8, %r8
cmpq %r8, %rdx
jne 0x45bfe
incq %rax
movq %rdx, %rcx
cmpq %r10, %rax
jne 0x45bef
jmp 0x45c47
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebx
movq %rsp, %rcx
leaq 0xf(,%rbx,4), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movl %edx, -0x2c(%rbp)
movslq %edx, %r13
leaq (,%r13,8), %rdi
callq 0x21d0
movq %rax, %r12
testl %r13d, %r13d
jle 0x46a51
shlq $0x2, %r13
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r12,%r15,8)
incq %r15
cmpq %r15, %rbx
jne 0x46a3d
movl -0x2c(%rbp), %r15d
movl %r15d, %edi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %r13
movq %r13, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x4a4d2
testl %r15d, %r15d
jle 0x46a8f
movq (%r12), %rax
xorl %ecx, %ecx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rbx
jne 0x46a7c
movq %r12, %rdi
movl %r15d, %esi
callq 0x4960c
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_O1/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, %ebp
movl %esi, %ebx
movq %rdi, %r13
cmpl %edx, %esi
movl %edx, %r14d
cmovgl %esi, %r14d
cmovll %esi, %ebp
movslq %ebp, %r15
leaq (,%r15,4), %rdi
callq 0x21d0
movq %rax, 0x10(%rsp)
movl %r15d, %edi
movl %r15d, %esi
callq 0x496ae
movq %rax, 0x8(%rsp)
movl %r15d, %edi
movl %r15d, %esi
callq 0x49798
movq %rax, %r12
testl %r15d, %r15d
jle 0x46b57
movl %ebp, %eax
movl %r14d, %ecx
xorl %edx, %edx
movq (%r13,%rdx,8), %rsi
movq (%r12,%rdx,8), %rdi
xorl %r8d, %r8d
movq (%r13,%r8,8), %r9
movsd (%rdi,%r8,8), %xmm0
xorl %r10d, %r10d
movsd (%rsi,%r10,8), %xmm1
mulsd (%r9,%r10,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r10
cmpq %r10, %rcx
jne 0x46b29
incq %r8
cmpq %rax, %r8
jne 0x46b1b
incq %rdx
cmpq %rax, %rdx
jne 0x46b0f
movl %ebp, %edi
movq %r12, %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdx
movq 0x8(%rsp), %r15
movq %r15, %rcx
movl $0x1, %r8d
callq 0x4a4d2
movss (%r14), %xmm0
xorpd %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x46b8b
sqrtss %xmm0, %xmm0
jmp 0x46b90
callq 0x21c0
movss %xmm0, 0x4(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x49642
movq %r15, %rdi
movl %ebx, %esi
callq 0x4960c
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_O1/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
movl %esi, %r14d
xorpd %xmm0, %xmm0
testl %esi, %esi
jle 0x46bf6
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x46be1
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x46c0d
sqrtsd %xmm0, %xmm0
jmp 0x46c12
callq 0x2290
testl %ebp, %ebp
jle 0x46c2e
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x46c18
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl 0x28(%rsp), %eax
testl %eax, %eax
jle 0x46cba
movl %eax, %r10d
xorl %r11d, %r11d
xorl %eax, %eax
movl $0x0, %ebx
testl %eax, %eax
jle 0x46c6c
movl %eax, %r14d
movb (%r8,%r11), %bpl
xorl %ebx, %ebx
cmpb %bpl, (%rcx,%rbx)
je 0x46c6c
incq %rbx
cmpq %rbx, %r14
jne 0x46c5b
movl %r14d, %ebx
movl %ebx, (%rdi,%r11,4)
testq %r9, %r9
je 0x46c7b
movl (%r9,%r11,4), %ebp
jmp 0x46c7e
movl %r11d, %ebp
movl %ebx, %r14d
cmpl %eax, %ebx
jne 0x46c9c
movb (%r8,%r11), %bl
movslq %eax, %r15
movb %bl, (%rcx,%r15)
movl %ebp, (%rsi,%r14,4)
movl %ebp, (%rdx,%r14,4)
incl %eax
jmp 0x46cb0
cmpl (%rsi,%r14,4), %ebp
jge 0x46ca6
movl %ebp, (%rsi,%r14,4)
cmpl (%rdx,%r14,4), %ebp
jle 0x46cb0
movl %ebp, (%rdx,%r14,4)
incq %r11
cmpq %r10, %r11
jne 0x46c49
jmp 0x46cbc
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edx, %edx
jle 0x46d06
movl %edx, %eax
movl %r8d, %edx
xorl %r9d, %r9d
movl $0xffffffff, (%rdi,%r9,4) # imm = 0xFFFFFFFF
testl %r8d, %r8d
jle 0x46cf7
movb (%rsi,%r9), %r11b
xorl %r10d, %r10d
cmpb (%rcx,%r10), %r11b
je 0x46cf3
incq %r10
cmpq %r10, %rdx
jne 0x46ce3
jmp 0x46cf7
movl %r10d, (%rdi,%r9,4)
cmpl $0x0, (%rdi,%r9,4)
js 0x46d07
incq %r9
cmpq %rax, %r9
jne 0x46ccf
retq
pushq %rax
movsbl (%rsi,%r9), %esi
leaq 0x165da(%rip), %rdi     # 0x5d2ee
movl %r8d, %edx
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O1/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 0x478b4
pushq %rbx
movq %rsi, %rbx
xorpd %xmm0, %xmm0
cmpl $0x1, %edx
je 0x478af
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
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x478aa
sqrtsd %xmm0, %xmm0
jmp 0x478af
callq 0x2290
movsd %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rdi)
movl $0x0, (%rsi)
testl %ecx, %ecx
jle 0x47c28
movl 0x70(%rsp), %edi
movq 0x60(%rsp), %r11
movl %ecx, 0x14(%rsp)
movl %ecx, %eax
movq %rax, 0x20(%rsp)
leaq (%rdx,%rax,4), %rax
movq %rax, 0x18(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
xorl %eax, %eax
movq %rdx, (%rsp)
movslq (%rdx,%r12,4), %rcx
movl (%r9,%rcx,4), %ebp
movslq %ebp, %r13
testl %r13d, %r13d
setns %r10b
cmpl %edi, %r13d
setl %r14b
testb %r14b, %r10b
je 0x47c07
testq %r11, %r11
je 0x47b8f
movl $0x1, (%r11,%rbp,4)
movl 0x14(%rsp), %ecx
cmpl %r8d, %ecx
jge 0x47c14
movq 0x18(%rsp), %r15
movslq (%r15), %r10
movl (%r9,%r10,4), %r14d
testl %r14d, %r14d
setns %dl
cmpl %edi, %r14d
setl %bl
testb %bl, %dl
je 0x47bec
cmpl %ebp, %r14d
je 0x47bfa
movq 0x68(%rsp), %rdx
movq (%rdx,%r13,8), %rdx
movss (%rdx,%r14,4), %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
addsd %xmm1, %xmm2
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x8(%rsp), %rdx
addsd (%rdx), %xmm0
movsd %xmm0, (%rdx)
incl %eax
jmp 0x47bfa
testq %r11, %r11
je 0x47bf8
negl %r10d
movl %r10d, (%r11,%rbp,4)
incl (%rsi)
addq $0x4, %r15
incl %ecx
cmpl %r8d, %ecx
jl 0x47b9d
jmp 0x47c14
testq %r11, %r11
je 0x47c12
negl %ecx
movl %ecx, (%r11,%r13,4)
incl (%rsi)
incq %r12
cmpq 0x20(%rsp), %r12
movq (%rsp), %rdx
jne 0x47b60
jmp 0x47c2e
xorl %eax, %eax
xorpd %xmm2, %xmm2
testl %eax, %eax
jle 0x47c90
xorpd %xmm0, %xmm0
cmpl $0x1, %eax
je 0x47c87
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm2
movq 0x8(%rsp), %rcx
movsd (%rcx), %xmm0
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
decl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x47c78
sqrtsd %xmm0, %xmm0
jmp 0x47c87
movsd %xmm2, (%rsp)
callq 0x2290
movsd (%rsp), %xmm2
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movslq %esi, %r12
leaq (,%r12,8), %rdi
callq 0x21d0
testl %r12d, %r12d
jle 0x47f3e
movl %ebp, %ecx
xorl %edx, %edx
xorps %xmm0, %xmm0
cvtss2sd (%r15,%rdx,4), %xmm0
movsd %xmm0, (%rax,%rdx,8)
movslq (%rbx,%rdx,4), %rsi
testq %rsi, %rsi
jle 0x47f1f
movq (%r14,%rdx,8), %rdi
movsd (%rax,%rdx,8), %xmm0
xorl %r8d, %r8d
movslq (%rdi,%r8,4), %r9
xorps %xmm1, %xmm1
cvtss2sd (%r15,%r9,4), %xmm1
addsd %xmm1, %xmm0
incq %r8
cmpq %r8, %rsi
jne 0x47f01
movsd %xmm0, (%rax,%rdx,8)
incl %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd (%rax,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq %rcx, %rdx
jne 0x47ede
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r13
leaq (,%r13,8), %r15
movq %r15, %rdi
callq 0x21d0
movq %rax, %rbx
movl %ebp, %r12d
xorpd %xmm1, %xmm1
testl %r13d, %r13d
jle 0x47fbd
xorl %r13d, %r13d
movsd %xmm1, (%rsp)
movq %r15, %rdi
callq 0x21d0
movsd (%rsp), %xmm1
movq %rax, (%rbx,%r13,8)
movq (%r14,%r13,8), %rcx
xorl %edx, %edx
movapd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%rdx,4), %xmm1
movsd %xmm1, (%rax,%rdx,8)
minsd %xmm0, %xmm1
incq %rdx
cmpq %rdx, %r12
jne 0x47f98
incq %r13
cmpq %r12, %r13
jne 0x47f7c
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setbe %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0x47ff7
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x47fd9
incq %rax
cmpq %r12, %rax
jne 0x47fd3
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_O1/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, %rbx
movl %ecx, %ebp
movq %rdx, 0x28(%rsp)
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
movq 0x180(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %r9, %rdi
movq %r13, %rsi
callq 0xdc8a
leaq 0x153d1(%rip), %rsi     # 0x5d64c
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x153c0(%rip), %rdi     # 0x5d65a
movq %r14, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0xef95(%rip), %rsi      # 0x57240
movq %r14, %rdi
callq 0x2210
movq %rax, %r14
testl %ebp, %ebp
jle 0x48385
movl %ebp, %eax
movq %rax, 0x18(%rsp)
leaq 0x7(%rsp), %rdi
xorl %r12d, %r12d
movq %r14, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax,%r12,8), %rdx
testq %rdx, %rdx
je 0x482f6
movq %r14, %rdi
leaq 0x1538d(%rip), %rsi     # 0x5d677
xorl %eax, %eax
callq 0x2190
leaq 0x7(%rsp), %rdi
cmpl $0x0, (%r15,%r12,4)
movq %r15, %rbp
movq 0x20(%rsp), %rdx
jle 0x4836f
leal 0x1(%r12), %eax
movl %eax, 0xc(%rsp)
xorl %r15d, %r15d
movq (%rdx,%r12,8), %rax
movslq (%rax,%r15,4), %rax
shlq $0x5, %rax
movq %rbx, %r13
addq %rax, %rbx
addq $0xd, %rbx
movswl 0x7(%rbx), %esi
movq %rdx, %r14
callq 0x271f8
movsbl -0x1(%rbx), %r8d
movq 0x10(%rsp), %rdi
leaq 0x15348(%rip), %rsi     # 0x5d68c
movl 0xc(%rsp), %edx
leaq 0x7(%rsp), %rcx
movq %rbx, %r9
movq %r13, %rbx
xorl %eax, %eax
callq 0x2190
movq %r14, %rdx
leaq 0x7(%rsp), %rdi
incq %r15
movslq (%rbp,%r12,4), %rax
cmpq %rax, %r15
jl 0x48311
incq %r12
cmpq 0x18(%rsp), %r12
movq %rbp, %r15
movq 0x10(%rsp), %r14
jne 0x482d2
movq %r14, %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_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
cmpb $0x20, (%rcx)
je 0x494bd
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r12
leaq 0xde39(%rip), %rsi      # 0x5726c
xorl %ebx, %ebx
movq %rcx, %rdi
xorl %eax, %eax
callq 0x21f0
movb 0x4(%r13), %al
movq %r15, 0x8(%rsp)
movb %al, (%r15)
leaq 0x5(%r13), %rdi
leaq 0x13e95(%rip), %rbp     # 0x5d2eb
leaq 0x14(%rsp), %r15
movq %rbp, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x21f0
movl (%r15), %edx
movq %r12, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2260
movb 0x9(%r13), %al
cmpb $0x20, %al
je 0x49493
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %r12, %rdi
callq 0x2240
cmpb $0x2a, (%r14)
je 0x494bd
movb (%r14), %al
testb %al, %al
je 0x494b8
movq 0x8(%rsp), %rcx
movb (%rcx), %cl
incq %r14
cmpb %cl, %al
je 0x494bd
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x494aa
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebp
movq %rdi, %r15
xorl %eax, %eax
testl %r8d, %r8d
movl %r8d, 0x4(%rsp)
cmovgl %r8d, %eax
cmpl %ecx, %eax
jge 0x49529
movl %eax, %r14d
movl %ecx, %r12d
movq %r14, %rax
shlq $0x5, %rax
leaq (%rax,%rbx), %r13
addq $0xd, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2180
testl %eax, %eax
jne 0x4951d
cmpb %bpl, -0x1(%r13)
je 0x49567
incq %r14
addq $0x20, %r13
cmpq %r14, %r12
jne 0x49508
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x49567
movl %eax, %r12d
addq $0xd, %rbx
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
testl %eax, %eax
jne 0x49556
cmpb %bpl, -0x1(%rbx)
je 0x49564
incq %r13
addq $0x20, %rbx
cmpq %r13, %r12
jne 0x49541
jmp 0x49567
movl %r13d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4958d
movl (%rsi), %ecx
movl %ecx, (%rdx,%rax,4)
movl $0x0, (%rsi)
movslq (%rdi), %r14
leal 0x1(%r14), %eax
movl %eax, (%rdi)
cmpl %r8d, %r14d
jge 0x495b4
movl $0x64, %edi
callq 0x21d0
movq %rax, 0x8(%rbx,%r14,8)
xorl %eax, %eax
jmp 0x495ca
leaq 0x1484f(%rip), %rdi     # 0x5de0a
movl %r8d, %esi
xorl %eax, %eax
callq 0x20f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x49606
movl %esi, %esi
movl %ecx, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
testl %ecx, %ecx
jle 0x495fd
movl (%rdi,%r9,4), %r10d
xorl %r11d, %r11d
cmpl (%rdx,%r11,4), %r10d
je 0x495fb
incq %r11
cmpq %r11, %r8
jne 0x495eb
jmp 0x495fd
incl %eax
incq %r9
cmpq %rsi, %r9
jne 0x495e0
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x49641
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x49634
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x49623
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x49677
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x4966a
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x49659
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x496ad
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x496a0
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x4968f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movq %rax, %r14
testl %r15d, %r15d
jle 0x49711
movslq %ebx, %rax
leaq (,%rax,4), %r15
movl %eax, %r12d
shlq $0x2, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x21d0
movq %rax, (%r14,%rbp,8)
testl %ebx, %ebx
jle 0x49709
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2110
incq %rbp
cmpq %rbp, %r13
jne 0x496ec
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movq %rax, %r14
testl %r15d, %r15d
jle 0x49786
movslq %ebx, %rax
leaq (,%rax,4), %r15
movl %eax, %r12d
shlq $0x2, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x21d0
movq %rax, (%r14,%rbp,8)
testl %ebx, %ebx
jle 0x4977e
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2110
incq %rbp
cmpq %rbp, %r13
jne 0x49761
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movq %rax, %r14
testl %r15d, %r15d
jle 0x497fb
movslq %ebx, %rax
leaq (,%rax,8), %r15
movl %eax, %r12d
shlq $0x3, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x21d0
movq %rax, (%r14,%rbp,8)
testl %ebx, %ebx
jle 0x497f3
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2110
incq %rbp
cmpq %rbp, %r13
jne 0x497d6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movl %edx, %r12d
movq %rsp, %rcx
leaq 0xf(,%r12,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
testl %edx, %edx
jle 0x49907
movq %rdi, %r14
movl $0x1, %r13d
xorl %ebx, %ebx
movsd 0x14790(%rip), %xmm2    # 0x5dfe8
xorpd %xmm3, %xmm3
movq %rsi, -0x30(%rbp)
movq %rbx, %r15
movq (%rsi,%rbx,8), %rax
movsd (%rax,%r15,8), %xmm0
testq %rbx, %rbx
je 0x49898
movq (%r14,%rbx,8), %rcx
movq (%r14,%r15,8), %rdx
movq %r13, %r8
leal -0x2(%r8), %edi
movsd (%rcx,%rdi,8), %xmm1
mulsd (%rdx,%rdi,8), %xmm1
subsd %xmm1, %xmm0
decq %r8
cmpq $0x1, %r8
jg 0x4987d
cmpq %rbx, %r15
jne 0x498bd
ucomisd %xmm0, %xmm2
ja 0x4990e
movsd (%rax,%rbx,8), %xmm1
movq -0x38(%rbp), %rax
movsd %xmm1, (%rax,%rbx,8)
ucomisd %xmm3, %xmm0
jb 0x498cb
sqrtsd %xmm0, %xmm0
jmp 0x498e0
movq (%r14,%rbx,8), %rax
divsd (%rax,%rbx,8), %xmm0
movq %r15, %rax
jmp 0x498e3
callq 0x2290
xorpd %xmm3, %xmm3
movsd 0x1470c(%rip), %xmm2    # 0x5dfe8
movq -0x30(%rbp), %rsi
movq %rbx, %rax
movq (%r14,%rax,8), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %r15
cmpq %r12, %r15
jne 0x49863
incq %rbx
incq %r13
cmpq %r12, %rbx
jne 0x49860
xorl %eax, %eax
jmp 0x49999
leaq 0x146db(%rip), %rdi     # 0x5dff0
movl %ebx, %esi
movb $0x1, %al
callq 0x20f0
movq -0x30(%rbp), %r10
cmpq %r10, %r14
setne %cl
testq %rbx, %rbx
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x49999
movl %ebx, %ecx
xorl %edx, %edx
movq %r12, %rsi
movq %r10, %rdi
xorl %r8d, %r8d
movq %r8, %r9
movq -0x38(%rbp), %r8
movsd (%r8,%r9,8), %xmm0
movq (%r10,%r9,8), %r10
movsd %xmm0, (%r10,%r9,8)
leaq 0x1(%r9), %r8
cmpq %r12, %r8
jae 0x49985
addq %rdx, %r10
movl $0x1, %r11d
movsd (%r10,%r11,8), %xmm0
movq (%rdi,%r11,8), %rbx
movsd %xmm0, (%rbx,%r9,8)
incq %r11
cmpq %r11, %rsi
jne 0x4996d
addq $0x8, %rdi
addq $0x8, %rdx
decq %rsi
cmpq %rcx, %r8
movq -0x30(%rbp), %r10
jne 0x49944
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %ecx, %ecx
jle 0x49a09
movl %ecx, %eax
xorl %ecx, %ecx
movq %rdi, %r8
movq (%rsi,%rcx,8), %r9
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%r8)
testq %rcx, %rcx
je 0x499ee
movsd (%r8), %xmm0
xorl %r10d, %r10d
movsd (%r9), %xmm1
mulsd (%rdi,%r10,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r8)
addq $0x8, %r9
incq %r10
cmpq %r10, %rcx
jne 0x499ce
movsd (%r8), %xmm0
divsd (%r9), %xmm0
movsd %xmm0, (%r8)
addq $0x8, %r8
incq %rcx
cmpq %rax, %rcx
jne 0x499b3
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %ecx, %ecx
jle 0x49a92
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %eax
leaq (%rsi,%rax,8), %r8
leaq (%rdi,%rax,8), %r9
movq %rax, %r10
leaq -0x1(%r10), %r11
movsd -0x8(%rdx,%r10,8), %xmm0
movsd %xmm0, -0x8(%rdi,%r10,8)
cmpq %rax, %r10
jge 0x49a67
movsd (%rdi,%r11,8), %xmm0
xorl %ebx, %ebx
movsd (%r9,%rbx,8), %xmm1
movq (%r8,%rbx,8), %r14
mulsd (%r14,%r11,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%r11,8)
incq %rbx
leal (%r10,%rbx), %ebp
cmpl %ecx, %ebp
jl 0x49a42
movq (%rsi,%r11,8), %rbx
movsd (%rdi,%r11,8), %xmm0
divsd (%rbx,%r11,8), %xmm0
movsd %xmm0, (%rdi,%r11,8)
addq $-0x8, %r8
addq $-0x8, %r9
cmpq $0x1, %r10
movq %r11, %r10
jg 0x49a23
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14d
movq %rdi, %rbx
movl %esi, %edi
callq 0x496ae
movl %r14d, %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
subq %rsi, %rdx
movq %rdx, %rsp
testl %r14d, %r14d
jle 0x49b43
xorl %esi, %esi
movsd 0x7572(%rip), %xmm0     # 0x51040
xorl %edi, %edi
xorl %r8d, %r8d
movapd %xmm0, %xmm1
cmpq %rsi, %r8
je 0x49ae0
xorpd %xmm1, %xmm1
movq (%rbx,%r8,8), %r9
testq %r8, %r8
je 0x49b08
xorl %r10d, %r10d
movsd (%r9,%r10), %xmm2
mulsd (%rdx,%r10), %xmm2
subsd %xmm2, %xmm1
addq $0x8, %r10
cmpq %r10, %rdi
jne 0x49aec
addq %r10, %r9
divsd (%r9), %xmm1
movsd %xmm1, (%rdx,%r8,8)
incq %r8
addq $0x8, %rdi
cmpq %rcx, %r8
jne 0x49ad3
xorl %edi, %edi
xorps %xmm1, %xmm1
cvtsd2ss (%rdx,%rdi,8), %xmm1
movq (%rax,%rdi,8), %r8
movss %xmm1, (%r8,%rsi,4)
incq %rdi
cmpq %rdi, %rcx
jne 0x49b21
incq %rsi
cmpq %rcx, %rsi
jne 0x49ace
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq