LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/optimization.c
// Function: Find_max_quad
float Find_max_quad(float x1, float x2, float x3,
		    float y1, float y2, float y3,
		    float MIN, float MAX)
{

 float yprime_2=((y1-y2)/(x1-x2));
  float yprime_3=((y1-y3)/(x1-x3));
  if(yprime_2 == yprime_3){
    // Singular data, return maximum value
    printf("WARNING in Find_max_quad, equal derivatives\n");
    float xmax=x2, ymax=y2;
    if(y1>ymax){ymax=y1; xmax=x1;}
    if(y3>ymax){xmax=x3;}
    return(xmax);
  }
  float a=(yprime_2-yprime_3)/(x2-x3);
  if(a>0){
    // Second derivative is positive, no maximum!
    //printf("WARNING, second derivative >0\n");
    printf("WARNING in Find_max_quad, second derivative %.2g >0\n", a);
    float xmax=x2, ymax=y2;
    if(y1>ymax){ymax=y1; xmax=x1;}
    if(y3>ymax){xmax=x3;}
    return(xmax);
  }
  float x0=0.5*(x1+x2)-yprime_2/(2*a);
  //printf("a= %.2f x0= %.2f\n", a, x0);
  if(x0<MIN){x0=(x1+MIN)/2;}
  //else if(x0>MAX){x0=(x3+MAX)/2;}
  return(x0);
}

// Assembly:
subq $0x68, %rsp
movaps %xmm0, %xmm8
movaps %xmm3, %xmm0
shufps $0x0, %xmm3, %xmm0      # xmm0 = xmm0[0,0],xmm3[0,0]
movaps %xmm4, %xmm7
unpcklps %xmm5, %xmm7            # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
subps %xmm7, %xmm0
movaps %xmm8, %xmm9
shufps $0x0, %xmm8, %xmm9      # xmm9 = xmm9[0,0],xmm8[0,0]
movaps %xmm1, %xmm7
unpcklps %xmm2, %xmm7            # xmm7 = xmm7[0],xmm2[0],xmm7[1],xmm2[1]
subps %xmm7, %xmm9
divps %xmm9, %xmm0
movaps %xmm0, %xmm7
shufps $0x55, %xmm0, %xmm7     # xmm7 = xmm7[1,1],xmm0[1,1]
ucomiss %xmm7, %xmm0
jne 0x41175
jp 0x41175
leaq 0x1bbb5(%rip), %rdi     # 0x5cd05
movaps %xmm3, 0x50(%rsp)
movaps %xmm8, 0x10(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm5, 0x30(%rsp)
movaps %xmm4, (%rsp)
movaps %xmm1, 0x20(%rsp)
callq 0x2090
jmp 0x411c7
movaps %xmm0, %xmm9
subss %xmm7, %xmm9
movaps %xmm1, %xmm7
subss %xmm2, %xmm7
divss %xmm7, %xmm9
xorps %xmm7, %xmm7
ucomiss %xmm7, %xmm9
jbe 0x41206
xorps %xmm0, %xmm0
cvtss2sd %xmm9, %xmm0
leaq 0x1bb2e(%rip), %rdi     # 0x5ccd0
movb $0x1, %al
movaps %xmm3, 0x50(%rsp)
movaps %xmm8, 0x10(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm5, 0x30(%rsp)
movaps %xmm4, (%rsp)
movaps %xmm1, 0x20(%rsp)
callq 0x20f0
movaps 0x50(%rsp), %xmm0
movaps (%rsp), %xmm1
movaps %xmm1, %xmm2
cmpltss %xmm0, %xmm2
movaps 0x10(%rsp), %xmm3
andps %xmm2, %xmm3
andnps 0x20(%rsp), %xmm2
orps %xmm3, %xmm2
maxss %xmm1, %xmm0
cmpltss 0x30(%rsp), %xmm0
movaps %xmm0, %xmm1
andnps %xmm2, %xmm1
andps 0x40(%rsp), %xmm0
orps %xmm1, %xmm0
addq $0x68, %rsp
retq
addss %xmm8, %xmm1
xorps %xmm2, %xmm2
cvtss2sd %xmm1, %xmm2
addss %xmm9, %xmm9
divss %xmm9, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0xff48(%rip), %xmm2     # 0x51170
subsd %xmm0, %xmm2
cvtsd2ss %xmm2, %xmm2
addss %xmm6, %xmm8
mulss 0x14986(%rip), %xmm8    # 0x55bc4
movaps %xmm2, %xmm0
cmpltss %xmm6, %xmm0
movaps %xmm0, %xmm1
andnps %xmm2, %xmm1
andps %xmm8, %xmm0
jmp 0x411fe
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/optimization.c
// Function: Rearrange_points
void Rearrange_points(float *x1, float *x2, float *x3,
		      float *y1, float *y2, float *y3,
		      float x0, float y0)
{
  if(y0<*y1){
    *x3=*x2; *y3=*y2;
    *x2=*x1; *y2=*y1;
    *x1=x0;  *y1=y0;
  }else if(y0<*y2){
    *x3=*x2; *y3=*y2;
    *x2=x0;  *y2=y0;
  }else if(y0<*y3){
    *x1=*x2; *y1=*y2;
    *x2=x0; *y2=y0;
  }else{
    *x1=*x2; *y1=*y2;
    *x2=*x3; *y2=*y3;
    *x3=x0;  *y3=y0;
  }
}

// Assembly:
movss (%rcx), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x4126f
movss (%rsi), %xmm2
movss %xmm2, (%rdx)
movss (%r8), %xmm2
movss %xmm2, (%r9)
jmp 0x412a8
movss (%r8), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x41287
movq %rsi, %rdi
movq %rdx, %rsi
movq %r8, %rcx
movq %r9, %r8
jmp 0x412a8
movss (%r9), %xmm2
ucomiss %xmm1, %xmm2
movss (%rsi), %xmm2
movss %xmm2, (%rdi)
movss (%r8), %xmm2
movss %xmm2, (%rcx)
movq %rdx, %rdi
movq %r9, %rcx
ja 0x412bf
movss (%rdi), %xmm2
movss %xmm2, (%rsi)
movss (%rcx), %xmm2
movss %xmm2, (%r8)
movq %rdi, %rsi
movq %rcx, %r8
movss %xmm0, (%rsi)
movss %xmm1, (%r8)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/output_tnm.c
// Function: Check_make_dir
int Check_make_dir(char *outdir){
  char name_out[1000]; FILE *file_out;
  if(outdir[0]=='\0')return(0);
  sprintf(name_out, "%s/%s", outdir, "tmp");
  file_out=fopen(name_out, "w");
  if(file_out!=NULL){fclose(file_out); return(1);}
  sprintf(name_out, "mkdir -p %s\n", outdir);
  if(system(name_out)==0)return(1);
  return(0);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x41ef8
pushq %r14
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rdi, %rbx
leaq 0x1b020(%rip), %rsi     # 0x5cede
leaq 0x1b01f(%rip), %rcx     # 0x5cee4
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
leaq 0x15324(%rip), %rsi     # 0x57200
movq %r14, %rdi
callq 0x2220
testq %rax, %rax
je 0x41efb
movq %rax, %rdi
callq 0x20c0
movl $0x1, %eax
jmp 0x41f23
xorl %eax, %eax
retq
leaq 0x1afe6(%rip), %rsi     # 0x5cee8
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
movq %r14, %rdi
callq 0x20e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/output_tnm.c
// Function: Print_cart_fluct
void Print_cart_fluct(int *atom_num, int N_atom, float *fluct,
		      atom *atoms, struct residue *seq,
		      char *name, char *type)
{
  float MAX_B=50.0;
  int i, ia=0, n=1;
  FILE *file_out=fopen(name, "w");
  printf("Writing %s\n", name);
  fprintf(file_out, "REMARK %d B_factor = %s\n",n, type);

  { // Normalize such that max_fluctuation = MAX_B
    float max_f=0, norm;
    for(i=0; i<N_atom; i++)if(fluct[i]>max_f)max_f=fluct[i];
    norm=MAX_B/max_f; for(i=0; i<N_atom; i++)fluct[i]*=norm;
  }
  for(i=0; i<N_atom; i++){
    Print_atom(atoms+atom_num[i], &ia, fluct[i], seq, file_out);
  }
  fprintf(file_out, "TER\n");
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbp
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0x15298(%rip), %rsi     # 0x57200
movq %r9, %rdi
callq 0x2220
movq %rax, %r13
leaq 0xfdd5(%rip), %rdi      # 0x51d4f
movq %rbp, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x1af6a(%rip), %rsi     # 0x5cef5
movq %r13, %rdi
movl $0x1, %edx
movq 0x18(%rsp), %rcx
xorl %eax, %eax
callq 0x21a0
movq %r13, %rcx
testl %ebx, %ebx
jle 0x4204f
movq %rcx, %rsi
movq 0x10(%rsp), %rbp
movl %ebx, %r8d
xorps %xmm0, %xmm0
xorl %eax, %eax
movaps %xmm0, %xmm1
movss (%r15,%rax,4), %xmm0
maxss %xmm1, %xmm0
incq %rax
cmpq %rax, %r8
jne 0x41fba
testl %ebx, %ebx
movq %rsi, %rcx
jle 0x4204f
movss 0x1ad56(%rip), %xmm1    # 0x5cd34
divss %xmm0, %xmm1
xorl %eax, %eax
movss (%r15,%rax,4), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r15,%rax,4)
incq %rax
cmpq %rax, %r8
jne 0x41fe4
testl %ebx, %ebx
movq %rsi, %rcx
jle 0x4204f
movq %r14, %rdx
movq %r12, %r13
xorl %r14d, %r14d
movq %rdx, 0x20(%rsp)
movslq (%r13,%r14,4), %rax
imulq $0x70, %rax, %rdi
addq %rdx, %rdi
movss (%r15,%r14,4), %xmm0
leaq 0xc(%rsp), %rsi
movq %rbp, %rdx
movq %r15, %rbx
movq %rcx, %r15
movq %r8, %r12
callq 0x4207e
movq %r12, %r8
movq %r15, %rcx
movq %rbx, %r15
movq 0x20(%rsp), %rdx
incq %r14
cmpq %r14, %r12
jne 0x42011
leaq 0x1aeb8(%rip), %rdi     # 0x5cf0e
movl $0x4, %esi
movl $0x1, %edx
movq %rcx, %rbx
callq 0x2290
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/output_tnm.c
// Function: Print_atom
void Print_atom(atom *atom, int *num, float B, struct residue *seq,
		FILE *file_out)
{
  struct residue *s=seq+atom->res;
  char aaname3[4]; Name3(aaname3, s->i_aa);
  (*num)++; int jatom=*num; if(jatom>99999)jatom=99999;
  fprintf(file_out,
	  "ATOM  %5d  %4s%3s %c%4d   %8.3f%8.3f%8.3f%6.2f%6.2f\n",
	  jatom, atom->name, aaname3, 'A', atom->res+1,
	  atom->r[0], atom->r[1], atom->r[2], 1.0, B);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movss %xmm0, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movslq 0x64(%rdi), %rax
shlq $0x5, %rax
movswl 0x14(%rdx,%rax), %esi
leaq 0x14(%rsp), %r12
movq %r12, %rdi
callq 0x26d50
movl (%r14), %edx
incl %edx
movl %edx, (%r14)
movl $0x1869f, %eax          # imm = 0x1869F
cmpl %eax, %edx
cmovgel %eax, %edx
leaq 0x18(%r15), %rcx
movl 0x64(%r15), %eax
incl %eax
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
cvtss2sd 0x10(%rsp), %xmm4
movl %eax, (%rsp)
leaq 0x1aec3(%rip), %rsi     # 0x5cfb2
movsd 0xf051(%rip), %xmm3     # 0x51148
movq %rbx, %rdi
movq %r12, %r8
movl $0x41, %r9d
movb $0x5, %al
callq 0x21a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/output_tnm.c
// Function: Print_tors_fluct
void Print_tors_fluct(struct axe *axe, int N_axes, float *fluct,
		      atom *atoms, struct residue *seq,
		      char *name, char *type)
{
  float MAX_B=100.0, f; int i, ia=0, n=1;
  FILE *file_out=fopen(name, "w");
  printf("Writing %s\n", name);
  fprintf(file_out, "MODEL %d  B_factor = %s\n", n, type);

  { // Normalize such that max_fluctuation = MAX_B
    float max_f=0, norm;
    for(i=0; i<N_axes; i++)if(fluct[i]>max_f)max_f=fluct[i];
    norm=MAX_B/max_f;
    for(i=0; i<N_axes; i++)fluct[i]*=norm;
  }

  for(i=0; i<N_axes; i++){
    if(axe[i].type=='f'){
      Print_atom(axe[i].bond->previous->atom, &ia, fluct[i], seq, file_out);
      f=fluct[i]; if(i+1<N_axes)f=0.5*(f+fluct[i+1]);
      Print_atom(axe[i].bond->atom, &ia, f, seq, file_out);
    }else if(axe[i].type=='p'){
      if(ia==0)
	Print_atom(axe[i].bond->previous->atom, &ia, fluct[i], seq, file_out);
      Print_atom(axe[i].bond->atom, &ia, fluct[i], seq, file_out);
    }
  }
  fprintf(file_out, "ENDMDL\n");
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, 0x10(%rsp)
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r12
movq 0x50(%rsp), %rbp
movl $0x0, 0xc(%rsp)
leaq 0x150b8(%rip), %rsi     # 0x57200
movq %r9, %rdi
callq 0x2220
movq %rax, %r15
leaq 0xfbf5(%rip), %rdi      # 0x51d4f
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x1ada8(%rip), %rsi     # 0x5cf13
movq %r15, %rdi
movl $0x1, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x21a0
testl %ebx, %ebx
jle 0x422a7
movl %ebx, %ebp
xorps %xmm0, %xmm0
xorl %eax, %eax
movaps %xmm0, %xmm1
movss (%r14,%rax,4), %xmm0
maxss %xmm1, %xmm0
incq %rax
cmpq %rax, %rbp
jne 0x4218c
testl %ebx, %ebx
jle 0x422a7
movss 0xef6f(%rip), %xmm1     # 0x51120
divss %xmm0, %xmm1
xorl %eax, %eax
movss (%r14,%rax,4), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r14,%rax,4)
incq %rax
cmpq %rax, %rbp
jne 0x421b7
testl %ebx, %ebx
jle 0x422a7
addq $0x8, %r12
movq %rbp, %r13
negq %r13
movl $0x1, %ebx
movzbl -0x8(%r12), %eax
cmpl $0x70, %eax
je 0x42241
cmpl $0x66, %eax
jne 0x4228c
movq (%r12), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movss -0x4(%r14,%rbx,4), %xmm0
leaq 0xc(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rcx
callq 0x4207e
movss -0x4(%r14,%rbx,4), %xmm0
cmpq %rbp, %rbx
jae 0x42238
addss (%r14,%rbx,4), %xmm0
mulss 0x1398c(%rip), %xmm0    # 0x55bc4
movq (%r12), %rax
movq (%rax), %rdi
jmp 0x4227a
cmpl $0x0, 0xc(%rsp)
jne 0x4226c
movq (%r12), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movss -0x4(%r14,%rbx,4), %xmm0
leaq 0xc(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rcx
callq 0x4207e
movq (%r12), %rax
movq (%rax), %rdi
movss -0x4(%r14,%rbx,4), %xmm0
leaq 0xc(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rcx
callq 0x4207e
addq $0x158, %r12            # imm = 0x158
leaq (%rbx,%r13), %rax
incq %rax
incq %rbx
cmpq $0x1, %rax
jne 0x421e6
leaq 0x16fa4(%rip), %rdi     # 0x59252
movl $0x7, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2290
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/output_tnm.c
// Function: Print_structures
void Print_structures(char *pdbout,
		      double *atom_str1, atom *atoms1,
		      struct residue *seq1, char chain1,
		      double *atom_str2, atom *atoms2,
		      struct residue *seq2, char chain2,
		      int *atom_num, int N_ref, int N_cart,
		      float **Cart_mode, float *coeff,
		      int *sort, int N_MODE_PRINT, int N_modes)
{
  double *atom_tmp;
  int imod=0, kmod=0, nmod, i;
  if(N_MODE_PRINT<=0)return;
  if(N_MODE_PRINT < N_modes){nmod = N_MODE_PRINT;}else{nmod= N_modes;}

  // Print reference structure
  //Write_coord(pdbout,atom_str1,atoms1,atom_num,N_ref,seq1,chain1,kmod);
  // kmod++;
  atom_tmp=malloc(N_cart*sizeof(double));
  for(i=0; i<N_cart; i++)atom_tmp[i]=atom_str1[i];

  for(imod=0; imod< nmod; imod++){
    int ik=sort[imod];
    float *mode=Cart_mode[ik];
    /* Update intermediate structure */
    for(i=0;i<N_cart;i++)atom_tmp[i]+=coeff[ik]*mode[i];
    Write_coord(pdbout,atom_tmp,atoms1,atom_num,N_ref,seq1,chain1,kmod);
    kmod++;
  }

  // Print experimental structure 2
  //Write_coord(pdbout,atom_str2,atoms2,atom_num,N_ref,seq2,chain2,-1);
  printf("Writing %s\n", pdbout);
  free(atom_tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x8(%rsp)
movl 0xc8(%rsp), %ebp
testl %ebp, %ebp
jle 0x42445
movq %rsi, 0x10(%rsp)
movl %r8d, (%rsp)
movl 0xd0(%rsp), %ebx
movq 0xc0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0xa8(%rsp), %r14d
movl 0xa0(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %r14d, %r13
leaq (,%r13,8), %rdi
callq 0x21e0
movq %rax, %r12
movl %r14d, %r15d
testl %r13d, %r13d
jle 0x4238e
leaq (,%r15,8), %rdx
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x21b0
testl %ebx, %ebx
jle 0x4241c
cmpl $0x2, %ebp
movl $0x1, %ebx
cmovgel %ebp, %ebx
xorl %ebp, %ebp
movsbl (%rsp), %r13d
testl %r14d, %r14d
jle 0x423ec
movq 0x28(%rsp), %rax
movslq (%rax,%rbp,4), %rcx
movq 0x18(%rsp), %rax
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rdx
movss (%rdx,%rcx,4), %xmm0
xorl %ecx, %ecx
movss (%rax,%rcx,4), %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
addsd (%r12,%rcx,8), %xmm1
movsd %xmm1, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x423cb
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl 0x4(%rsp), %r8d
movq 0x40(%rsp), %r9
pushq %rbp
pushq %r13
callq 0x42454
addq $0x10, %rsp
incq %rbp
cmpq %rbx, %rbp
jne 0x423a8
leaq 0xf92c(%rip), %rdi      # 0x51d4f
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x20f0
movq %r12, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a801(%rip), %rsi     # 0x5cfe7
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rdx
movq %r8, %rcx
xorl %eax, %eax
callq 0x2270
leaq 0x14a00(%rip), %rsi     # 0x57200
movq %r12, %rdi
callq 0x2220
movq %rax, %r15
leaq 0xf53d(%rip), %rdi      # 0x51d4f
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x1a7d2(%rip), %rdi     # 0x5cff5
movl $0x1f, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2290
testl %ebp, %ebp
jle 0x4286b
movl %ebp, %r13d
xorl %ebp, %ebp
leaq 0x1a7d0(%rip), %r12     # 0x5d015
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 0x21a0
incq %rbp
cmpq %rbp, %r13
jne 0x42845
movq %r15, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x44364
leaq 0x4(,%rax,4), %rdx
movq %r14, %rdi
movl $0xff, %esi
callq 0x2110
cmpl $0x0, (%rsp)
jle 0x4442f
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 0x443d6
movslq 0x64(%r15), %rax
shlq $0x5, %rax
movq 0x30(%rsp), %rcx
cmpb $0x47, 0x13(%rcx,%rax)
jne 0x44420
cmpb $0x43, (%r12)
jne 0x44420
cmpb $0x41, 0x19(%r15)
jne 0x44420
movq 0x28(%rsp), %rax
movss (%rax), %xmm0
ucomiss 0xcd32(%rip), %xmm0     # 0x51118
jne 0x443f9
jp 0x443f9
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 0x44386
jmp 0x44431
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_O3/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 0x44571
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 0x21e0
movq %rax, %r12
movq 0x28(%rsp), %rax
movq %r12, (%rax,%rbp,8)
movl 0xc(%rsp), %edi
movl $0x3, %esi
callq 0x4971a
movq %rax, %r13
movq 0x30(%rsp), %rax
movq %r13, (%rax,%rbp,8)
testq %rbp, %rbp
je 0x44563
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 0x444e9
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movss %xmm1, (%r12,%r15,4)
ucomisd 0xcc52(%rip), %xmm0     # 0x51178
jb 0x4452e
sqrtsd %xmm0, %xmm0
jmp 0x44533
callq 0x22a0
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 0x4453a
incq %r15
cmpq %rbp, %r15
jne 0x444d1
incq %rbp
cmpq 0x20(%rsp), %rbp
jne 0x44488
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21e0
movq %rax, %r14
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
testl %ebp, %ebp
jle 0x4460a
leaq (,%rbp,4), %r13
movl %ebp, %ebp
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x21e0
movq %rax, (%r12,%r15,8)
incq %r15
cmpq %r15, %rbp
jne 0x445f6
movl %ebx, %edi
movq (%rsp), %rsi
movq %r14, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x4a559
movss (%r14), %xmm0
movss %xmm0, (%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x49678
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_O3/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 0x18d30(%rip), %rsi     # 0x5d3a4
movq %rsp, %r13
movq %r13, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2270
leaq 0x12b75(%rip), %rsi     # 0x57200
movq %r13, %rdi
callq 0x2220
movq %rax, %r12
leaq 0xd6b2(%rip), %rdi      # 0x51d4f
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
testl %ebp, %ebp
jle 0x446d9
movl %ebp, %r13d
xorl %ebp, %ebp
movsbl (%r14,%rbp), %ecx
movq (%r15,%rbp,8), %r8
movsbl (%rbx,%rbp), %r9d
movq %r12, %rdi
leaq 0x18ce9(%rip), %rsi     # 0x5d3b1
movl %ebp, %edx
xorl %eax, %eax
callq 0x21a0
incq %rbp
cmpq %rbp, %r13
jne 0x446b0
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_O3/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 0x4971a
movq %rax, %r14
testl %ebp, %ebp
jle 0x44df9
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 0x44df1
xorl %r13d, %r13d
movq (%rbx,%r12,8), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r13,4), %xmm0
ucomisd 0xc3c6(%rip), %xmm0     # 0x51178
jb 0x44dba
sqrtsd %xmm0, %xmm0
jmp 0x44dbf
callq 0x22a0
xorpd 0xc2c9(%rip), %xmm0     # 0x51090
divsd (%rsp), %xmm0
callq 0x22b0
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 0x44d9d
incq %r12
cmpq %r15, %r12
jne 0x44d89
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_O3/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 0x45d8c
movq %r8, %r15
movl %ecx, %ebp
movq %rsi, %r14
movl %r9d, (%rsp)
movl %ecx, %edi
movl %ecx, %esi
callq 0x49804
movq %rax, %rbx
movl %ebp, %r12d
movl %ebp, 0xc(%rsp)
testl %ebp, %ebp
jle 0x45c75
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 0x45c5e
movq %r12, 0x10(%rsp)
movl (%rsp), %eax
testl %eax, %eax
jle 0x45d26
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 0x45d19
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 0x45cd0
incq %rdx
cmpq (%rsp), %rdx
jne 0x45c92
cmpl $0x0, 0xc(%rsp)
jle 0x45d8e
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 0x45d76
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 0x45d45
incq %rax
movq %rdx, %rcx
cmpq %r10, %rax
jne 0x45d36
jmp 0x45d8e
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_O3/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, %r15
movl %edx, %ebx
movq %rsp, %r14
leaq 0xf(,%rbx,4), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movl %edx, -0x2c(%rbp)
movslq %edx, %r13
leaq (,%r13,8), %rdi
callq 0x21e0
movq %rax, %r12
testl %r13d, %r13d
jle 0x46b81
movq %r14, -0x40(%rbp)
shlq $0x2, %r13
xorl %r14d, %r14d
movq %r13, %rdi
callq 0x21e0
movq %rax, (%r12,%r14,8)
incq %r14
cmpq %r14, %rbx
jne 0x46b2d
movl -0x2c(%rbp), %r14d
movl %r14d, %edi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %r13
movq %r13, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x4a559
testl %r14d, %r14d
jle 0x46ba1
movq (%r12), %rax
xorl %ecx, %ecx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, (%r15,%rcx,4)
incq %rcx
cmpq %rcx, %rbx
jne 0x46b6c
jmp 0x46ba1
movl -0x2c(%rbp), %ebx
movl %ebx, %edi
movq -0x38(%rbp), %rsi
movq %r14, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x4a559
movq %r14, %r13
movl %ebx, %r14d
movq %r12, %rdi
movl %r14d, %esi
callq 0x49678
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_O3/ugobas[P]tnm/allostery.c
// Function: Singvalue_main
float Singvalue_main(double **A, int Na, int Nb)
{
  int i, j, k, N1, N2;
  if(Na<Nb){N1=Na; N2=Nb;}else{N1=Nb; N2=Na;}
  float *eigenval=malloc(N1*sizeof(float));
  float **eigenvec=Allocate_mat2_f(N1, N1);
  double **Mat=Allocate_mat2_d(N1, N1);
  for(i=0; i<N1; i++){
    for(j=0; j<N1; j++){
      for(k=0; k<N2; k++)Mat[i][j]+=A[i][k]*A[j][k];
    }
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %r15
cmpl %edx, %esi
movl %edx, %ebp
cmovll %esi, %ebp
movslq %ebp, %r14
leaq (,%r14,4), %rdi
callq 0x21e0
movq %rax, 0x10(%rsp)
movl %r14d, %edi
movl %r14d, %esi
callq 0x4971a
movq %rax, 0x8(%rsp)
movl %r14d, %edi
movl %r14d, %esi
callq 0x49804
movq %rax, %r12
testl %r14d, %r14d
jle 0x46c64
cmpl %r13d, %ebx
cmovgl %ebx, %r13d
movl %ebp, %eax
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq (%r12,%rcx,8), %rsi
xorl %edi, %edi
movq (%r15,%rdi,8), %r8
movsd (%rsi,%rdi,8), %xmm0
xorl %r9d, %r9d
movsd (%rdx,%r9,8), %xmm1
mulsd (%r8,%r9,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %r9
cmpq %r9, %r13
jne 0x46c37
incq %rdi
cmpq %rax, %rdi
jne 0x46c2b
incq %rcx
cmpq %rax, %rcx
jne 0x46c21
movl %ebp, %edi
movq %r12, %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdx
movq 0x8(%rsp), %r15
movq %r15, %rcx
movl $0x1, %r8d
callq 0x4a559
movss (%r14), %xmm0
xorpd %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x46c98
sqrtss %xmm0, %xmm0
jmp 0x46c9d
callq 0x21d0
movss %xmm0, 0x4(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x496ae
movq %r15, %rdi
movl %ebx, %esi
callq 0x49678
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_O3/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
testl %esi, %esi
jle 0x46d1a
movq %rdi, %rbx
movl %ebp, %r14d
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x46cea
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x46d39
sqrtsd %xmm0, %xmm0
jmp 0x46d3e
cvtsi2sd %ebp, %xmm1
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jae 0x46d5a
popq %rbx
popq %r14
popq %rbp
jmp 0x22a0
callq 0x22a0
testl %ebp, %ebp
jle 0x46d5a
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x46d44
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46de2
movl %eax, %r10d
xorl %r11d, %r11d
xorl %eax, %eax
movl %eax, %ebx
movl $0x0, %r14d
testl %eax, %eax
jle 0x46d99
movb (%r8,%r11), %bpl
xorl %r14d, %r14d
cmpb %bpl, (%rcx,%r14)
je 0x46d99
incq %r14
cmpq %r14, %rbx
jne 0x46d88
movl %ebx, %r14d
movl %r14d, (%rdi,%r11,4)
testq %r9, %r9
je 0x46da8
movl (%r9,%r11,4), %ebp
jmp 0x46dab
movl %r11d, %ebp
cmpl %eax, %r14d
jne 0x46dc5
movb (%r8,%r11), %r14b
movslq %eax, %r15
movb %r14b, (%rcx,%r15)
movl %ebp, (%rsi,%rbx,4)
movl %ebp, (%rdx,%rbx,4)
incl %eax
jmp 0x46dd8
movl %r14d, %ebx
cmpl (%rsi,%rbx,4), %ebp
jge 0x46dd0
movl %ebp, (%rsi,%rbx,4)
cmpl (%rdx,%rbx,4), %ebp
jle 0x46dd8
movl %ebp, (%rdx,%rbx,4)
incq %r11
cmpq %r10, %r11
jne 0x46d75
jmp 0x46de4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46e27
movl %edx, %eax
movl %r8d, %edx
xorl %r9d, %r9d
movl $0xffffffff, (%rdi,%r9,4) # imm = 0xFFFFFFFF
testl %r8d, %r8d
jle 0x46e28
movb (%rsi,%r9), %r11b
xorl %r10d, %r10d
cmpb (%rcx,%r10), %r11b
je 0x46e1b
incq %r10
cmpq %r10, %rdx
jne 0x46e0b
jmp 0x46e28
movl %r10d, (%rdi,%r9,4)
incq %r9
cmpq %rax, %r9
jne 0x46df7
retq
pushq %rax
movsbl (%rsi,%r9), %esi
leaq 0x16489(%rip), %rdi     # 0x5d2be
movl %r8d, %edx
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/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 0x4793a
pushq %rbx
movq %rsi, %rbx
xorpd %xmm0, %xmm0
cmpl $0x1, %edx
je 0x47935
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 0x47930
sqrtsd %xmm0, %xmm0
jmp 0x47935
callq 0x22a0
movsd %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x47cea
movl 0x70(%rsp), %edi
movq 0x60(%rsp), %r11
movl %ecx, 0x4(%rsp)
movl %ecx, %eax
movq %rax, 0x10(%rsp)
leaq (%rdx,%rax,4), %rax
movq %rax, 0x20(%rsp)
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
xorl %eax, %eax
movq %rdx, %rbx
movslq (%rdx,%r12,4), %r15
movl (%r9,%r15,4), %r13d
testl %r13d, %r13d
setns %cl
cmpl %edi, %r13d
setl %r10b
testb %r10b, %cl
je 0x47c7c
testq %r11, %r11
je 0x47c0b
movl $0x1, (%r11,%r13,4)
movl 0x4(%rsp), %ebp
cmpl %r8d, %ebp
jge 0x47c8d
movq 0x20(%rsp), %r15
movslq (%r15), %r10
movl (%r9,%r10,4), %ecx
testl %ecx, %ecx
setns %r14b
cmpl %edi, %ecx
setl %dl
testb %dl, %r14b
je 0x47c61
cmpl %r13d, %ecx
je 0x47c6f
movq 0x68(%rsp), %rdx
movq (%rdx,%r13,8), %rdx
movss (%rdx,%rcx,4), %xmm1
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtps2pd %xmm2, %xmm1
addpd %xmm1, %xmm0
movq 0x8(%rsp), %rcx
movlpd %xmm0, (%rcx)
incl %eax
jmp 0x47c6f
testq %r11, %r11
je 0x47c6d
negl %r10d
movl %r10d, (%r11,%r13,4)
incl (%rsi)
addq $0x4, %r15
incl %ebp
cmpl %r8d, %ebp
jl 0x47c19
jmp 0x47c8d
testq %r11, %r11
je 0x47c8b
movslq %r13d, %rcx
negl %r15d
movl %r15d, (%r11,%rcx,4)
incl (%rsi)
incq %r12
cmpq 0x10(%rsp), %r12
movq %rbx, %rdx
jne 0x47be1
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
testl %eax, %eax
jle 0x47d0e
xorpd %xmm1, %xmm1
cmpl $0x1, %eax
je 0x47d05
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm2
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 0x47cf0
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0x47d05
xorpd %xmm2, %xmm2
jmp 0x47d0e
movapd %xmm2, 0x10(%rsp)
callq 0x22a0
movapd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
movq 0x8(%rsp), %rax
movsd %xmm1, (%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_O3/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 0x21e0
testl %r12d, %r12d
jle 0x47f9b
movl %ebp, %ecx
xorl %edx, %edx
xorps %xmm0, %xmm0
cvtss2sd (%r15,%rdx,4), %xmm0
movslq (%rbx,%rdx,4), %rsi
testq %rsi, %rsi
jle 0x47f81
movq (%r14,%rdx,8), %rdi
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 0x47f68
incl %esi
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rcx, %rdx
jne 0x47f4f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x21e0
movq %rax, %rbx
testl %r12d, %r12d
jle 0x48058
movl %ebp, %r12d
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
movsd %xmm1, (%rsp)
movq %r15, %rdi
callq 0x21e0
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 0x47ff9
incq %r13
cmpq %r12, %r13
jne 0x47fdd
testl %ebp, %ebp
setle %al
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setbe %cl
orb %al, %cl
jne 0x48058
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 0x4803a
incq %rax
cmpq %r12, %rax
jne 0x48034
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_O3/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, 0x18(%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x30(%rsp), %r13
movq %r9, %rdi
movq %r13, %rsi
callq 0xdca2
leaq 0x1534a(%rip), %rsi     # 0x5d61c
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r13, %rdx
movq %r15, %r13
movq 0x180(%rsp), %rcx
xorl %eax, %eax
callq 0x2270
leaq 0x15331(%rip), %rdi     # 0x5d62a
movq %r14, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0xeef6(%rip), %rsi      # 0x57200
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
testl %ebp, %ebp
jle 0x483f7
movl %ebp, %eax
movq %rax, 0x10(%rsp)
leaq 0x2b(%rsp), %rsi
xorl %r14d, %r14d
movq %r12, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r14,8), %rdx
testq %rdx, %rdx
je 0x4835e
movq %rdi, %rbp
movq %rsi, %r15
leaq 0x152f6(%rip), %rsi     # 0x5d647
xorl %eax, %eax
callq 0x21a0
movq %rbp, %rdi
movq %r15, %rsi
cmpl $0x0, (%r13,%r14,4)
jle 0x483e1
leaq 0x1(%r14), %rax
movq %rax, (%rsp)
xorl %r15d, %r15d
movq %rsi, %r12
movq 0x20(%rsp), %rax
movq (%rax,%r14,8), %rax
movslq (%rax,%r15,4), %rax
shlq $0x5, %rax
movq %r13, %rbp
movq %rbx, %r13
addq %rax, %rbx
addq $0xd, %rbx
movswl 0x7(%rbx), %esi
movq %r12, %rdi
callq 0x26d50
movsbl -0x1(%rbx), %r8d
movq 0x8(%rsp), %rdi
leaq 0x152ad(%rip), %rsi     # 0x5d65c
movq (%rsp), %rdx
movq %r12, %rcx
movq %rbx, %r9
movq %r13, %rbx
movq %rbp, %r13
xorl %eax, %eax
callq 0x21a0
incq %r15
movslq (%rbp,%r14,4), %rax
cmpq %rax, %r15
jl 0x48374
movq (%rsp), %r14
movq 0x8(%rsp), %rdi
movq %r12, %rsi
jmp 0x483e8
incq %r14
movq %r14, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x48336
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_O3/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 0x4952c
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r12
leaq 0xdd8a(%rip), %rsi      # 0x5722c
xorl %ebx, %ebx
movq %rcx, %rdi
xorl %eax, %eax
callq 0x2200
movb 0x4(%r13), %al
movq %r15, 0x8(%rsp)
movb %al, (%r15)
leaq 0x5(%r13), %rdi
leaq 0x13df6(%rip), %rbp     # 0x5d2bb
leaq 0x14(%rsp), %r15
movq %rbp, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2200
movl (%r15), %edx
movq %r12, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2270
movb 0x9(%r13), %al
cmpb $0x20, %al
je 0x49502
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %r12, %rdi
callq 0x2250
movzbl (%r14), %eax
testl %eax, %eax
je 0x49527
cmpl $0x2a, %eax
je 0x4952c
movq 0x8(%rsp), %rcx
movb (%rcx), %cl
incq %r14
cmpb %cl, %al
je 0x4952c
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x49519
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_O3/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 0x49598
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 0x2190
testl %eax, %eax
jne 0x4958c
cmpb %bpl, -0x1(%r13)
je 0x495d6
incq %r14
addq $0x20, %r13
cmpq %r14, %r12
jne 0x49577
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x495d6
movl %eax, %r12d
addq $0xd, %rbx
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2190
testl %eax, %eax
jne 0x495c5
cmpb %bpl, -0x1(%rbx)
je 0x495d3
incq %r13
addq $0x20, %rbx
cmpq %r13, %r12
jne 0x495b0
jmp 0x495d6
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_O3/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 0x495fc
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 0x49623
movl $0x64, %edi
callq 0x21e0
movq %rax, 0x8(%rbx,%r14,8)
xorl %eax, %eax
jmp 0x49639
leaq 0x147b0(%rip), %rdi     # 0x5ddda
movl %r8d, %esi
xorl %eax, %eax
callq 0x20f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq