LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/seqres.c
// Function: Align_seqres
void Align_seqres(int *ali_seqres, char *seqres, int N_seqres,
		  char *seq, int nres)
{
  // ali_seqres[iseqres]=resstruct
  int IDMIN=7;
  int i=0, k=0; char *s1=seqres, *s2=seq;
  for(i=0; i<N_seqres; i++){
    if((*s1==*s2)&&(k<nres)){
      int ali=1;
      if((i==0)||(ali_seqres[i-1]<0)){
	// gap, look forward
	for(int i1=i; i1<N_seqres; i1++){
	  char *t1=seqres+i1, *t2=s2; int id=0;
	  while(*t2==*t1){
	    id++; if(id==IDMIN)break; t1++; t2++;
	  }
	  if(id==IDMIN){if(i1!=i)ali=0; break;}
	}
      }
      if(ali){ali_seqres[i]=k; k++; s2++;} // Align here
      else{ali_seqres[i]=-1;} // Align forward, not here
    }else{
      ali_seqres[i]=-1;
    }
    s1++;
  }
  if(0){
    printf("%d aligned residues over %d disordered: %d\n",
	   k, N_seqres, N_seqres-k);
    printf("SEQRES:  ");
    for(i=0; i<N_seqres; i++)printf("%c", seqres[i]);
    printf("\n");
    printf("ATOMRES: ");
    for(i=0; i<N_seqres; i++){
      if(ali_seqres[i]<0){printf("-");}
      else{printf("%c", seq[ali_seqres[i]]);}
    }
    printf("\n");
    exit(8);
  }
}

// Assembly:
testl %edx, %edx
jle 0x10814
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %eax
xorl %edx, %edx
xorl %r9d, %r9d
movq %rsi, %r10
xorl %r11d, %r11d
movb (%r10), %bl
cmpb (%rcx), %bl
sete %bl
cmpl %r8d, %r11d
setl %bpl
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x107f3
testq %r9, %r9
je 0x10798
cmpl $0x0, -0x4(%rdi,%r9,4)
jns 0x107e7
movb (%rcx), %bpl
movl $0x1, %ebx
movq %r10, %r14
movq %r9, %r15
cmpb (%rsi,%r15), %bpl
sete %r12b
jne 0x107d3
movl $0x1, %r13d
movb (%rcx,%r13), %r12b
cmpb (%r14,%r13), %r12b
sete %r12b
jne 0x107d3
incq %r13
cmpl $0x7, %r13d
jne 0x107b6
cmpq %r9, %r15
cmovnel %edx, %ebx
testb %r12b, %r12b
jne 0x107e3
incq %r15
incq %r14
cmpq %rax, %r15
jb 0x107a6
testl %ebx, %ebx
je 0x107f3
movl %r11d, (%rdi,%r9,4)
incl %r11d
incq %rcx
jmp 0x107fb
movl $0xffffffff, (%rdi,%r9,4) # imm = 0xFFFFFFFF
incq %r10
incq %r9
cmpq %rax, %r9
jne 0x10773
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/vector.c
// Function: Rotate
void Rotate(float *r, float **rot){
  float tmp[3];
  tmp[0]=rot[0][0]*r[0]+rot[0][1]*r[1]+rot[0][2]*r[2];
  tmp[1]=rot[1][0]*r[0]+rot[1][1]*r[1]+rot[1][2]*r[2];
  tmp[2]=rot[2][0]*r[0]+rot[2][1]*r[1]+rot[2][2]*r[2];
  r[0]=tmp[0]; r[1]=tmp[1]; r[2]=tmp[2]; 
}

// Assembly:
movss (%rdi), %xmm0
movss 0x4(%rdi), %xmm1
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movss 0x4(%rax), %xmm2
mulss %xmm1, %xmm2
movss (%rax), %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movss 0x8(%rdi), %xmm2
movss 0x8(%rax), %xmm4
mulss %xmm2, %xmm4
addss %xmm3, %xmm4
movss 0x4(%rcx), %xmm3
mulss %xmm1, %xmm3
movss (%rcx), %xmm5
mulss %xmm0, %xmm5
addss %xmm3, %xmm5
movss 0x8(%rcx), %xmm3
mulss %xmm2, %xmm3
movq 0x10(%rsi), %rax
mulss 0x4(%rax), %xmm1
mulss (%rax), %xmm0
addss %xmm5, %xmm3
addss %xmm1, %xmm0
mulss 0x8(%rax), %xmm2
addss %xmm0, %xmm2
movss %xmm4, (%rdi)
movss %xmm3, 0x4(%rdi)
movss %xmm2, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Rotate_d
void Rotate_d(double *r, double **rot){
  double tmp[3];
  tmp[0]=rot[0][0]*r[0]+rot[0][1]*r[1]+rot[0][2]*r[2];
  tmp[1]=rot[1][0]*r[0]+rot[1][1]*r[1]+rot[1][2]*r[2];
  tmp[2]=rot[2][0]*r[0]+rot[2][1]*r[1]+rot[2][2]*r[2];
  r[0]=tmp[0]; r[1]=tmp[1]; r[2]=tmp[2]; 
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movsd 0x8(%rax), %xmm2
mulsd %xmm1, %xmm2
movsd (%rax), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd 0x10(%rdi), %xmm2
movsd 0x10(%rax), %xmm4
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
movsd 0x8(%rcx), %xmm3
mulsd %xmm1, %xmm3
movsd (%rcx), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm3, %xmm5
movsd 0x10(%rcx), %xmm3
mulsd %xmm2, %xmm3
movq 0x10(%rsi), %rax
mulsd 0x8(%rax), %xmm1
mulsd (%rax), %xmm0
addsd %xmm5, %xmm3
addsd %xmm1, %xmm0
mulsd 0x10(%rax), %xmm2
addsd %xmm0, %xmm2
movsd %xmm4, (%rdi)
movsd %xmm3, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Matrix_multiplication
void Matrix_multiplication(double *w, double **M, double *v, int n)
{
  int i, j;
  for(i=0; i<n; i++){
    double sum=0, *mi=M[i], *v0=v;
    for(j=0; j<n; j++){sum+=(*mi)*(*v0); mi++; v0++;}
    w[i]=sum;
  }
}

// Assembly:
testl %ecx, %ecx
jle 0x10af0
movl %ecx, %eax
xorl %ecx, %ecx
movq (%rsi,%rcx,8), %r8
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm1
mulsd (%rdx,%r9,8), %xmm1
addsd %xmm1, %xmm0
incq %r9
cmpl %r9d, %eax
jne 0x10acb
movsd %xmm0, (%rdi,%rcx,8)
incq %rcx
cmpq %rax, %rcx
jne 0x10ac0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Transform_matrix
void Transform_matrix(float A[3][3], float **R){
  // Similarity transformation A'=RAR^T
  float tmp[3][3]; int i, j, k;
  for(i=0; i<3; i++){
    float *Ai=A[i];
    for(j=0; j<3; j++){
      float t=0, *Rj=R[j];
      for(k=0; k<3; k++)t+=Ai[k]*Rj[k];
      tmp[i][j]=t; 
    }
  }
  for(i=0; i<3; i++){
    float *Ri=R[i];
    for(j=0; j<3; j++){
      float t=0;
      for(k=0; k<3; k++)t+=Ri[k]*tmp[k][j];
      A[i][j]=t; 
    }
  }
}

// Assembly:
pushq %rbx
xorl %eax, %eax
movq %rdi, %rcx
leaq (%rax,%rax,2), %rdx
leaq (%rsp,%rdx,4), %rdx
addq $-0x30, %rdx
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rcx,%r10,4), %xmm1
mulss (%r9,%r10,4), %xmm1
addss %xmm1, %xmm0
incq %r10
cmpq $0x3, %r10
jne 0x10b10
movss %xmm0, (%rdx,%r8,4)
incq %r8
cmpq $0x3, %r8
jne 0x10b06
incq %rax
addq $0xc, %rcx
cmpq $0x3, %rax
jne 0x10af7
xorl %eax, %eax
leaq -0x30(%rsp), %rcx
movq (%rsi,%rax,8), %rdx
leaq (%rax,%rax,2), %r8
leaq (%rdi,%r8,4), %r8
movq %rcx, %r9
xorl %r10d, %r10d
xorps %xmm0, %xmm0
movq %r9, %r11
xorl %ebx, %ebx
movss (%rdx,%rbx,4), %xmm1
mulss (%r11), %xmm1
addss %xmm1, %xmm0
incq %rbx
addq $0xc, %r11
cmpq $0x3, %rbx
jne 0x10b66
movss %xmm0, (%r8,%r10,4)
incq %r10
addq $0x4, %r9
cmpq $0x3, %r10
jne 0x10b5e
incq %rax
cmpq $0x3, %rax
jne 0x10b4c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Transform_matrix_d
void Transform_matrix_d(double **A, double **R){
  // Similarity transformation A'=RAR^T
  double tmp[3][3]; int i, j, k;
  for(i=0; i<3; i++){
    double *Ai=A[i];
    for(j=0; j<3; j++){
      double t=0, *Rj=R[j];
      for(k=0; k<3; k++)t+=Ai[k]*Rj[k];
      tmp[i][j]=t; 
    }
  }
  for(i=0; i<3; i++){
    double *Ri=R[i];
    for(j=0; j<3; j++){
      double t=0;
      for(k=0; k<3; k++)t+=Ri[k]*tmp[k][j];
      A[i][j]=t; 
    }
  }
}

// Assembly:
pushq %rbx
xorl %eax, %eax
movq (%rdi,%rax,8), %rcx
leaq (%rax,%rax,2), %rdx
leaq (%rsp,%rdx,8), %rdx
addq $-0x50, %rdx
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
movsd (%rcx,%r10,8), %xmm1
mulsd (%r9,%r10,8), %xmm1
addsd %xmm1, %xmm0
incq %r10
cmpq $0x3, %r10
jne 0x10bc0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x10bb5
incq %rax
cmpq $0x3, %rax
jne 0x10ba2
xorl %eax, %eax
leaq -0x50(%rsp), %rcx
movq (%rsi,%rax,8), %rdx
movq (%rdi,%rax,8), %r8
movq %rcx, %r9
xorl %r10d, %r10d
xorpd %xmm0, %xmm0
movq %r9, %r11
xorl %ebx, %ebx
movsd (%rdx,%rbx,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
incq %rbx
addq $0x18, %r11
cmpq $0x3, %rbx
jne 0x10c0f
movsd %xmm0, (%r8,%r10,8)
incq %r10
addq $0x8, %r9
cmpq $0x3, %r10
jne 0x10c06
incq %rax
cmpq $0x3, %rax
jne 0x10bf8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Corr_coeff
float Corr_coeff(float *xx, float *yy, int N,
		 float *slope, float *offset)
{
  double xy=0, x1=0, y1=0, x2=0, y2=0;
  float *x=xx, *y=yy; int i;

  for(i=0; i<N; i++){
    xy += (*x)*(*y);
    x1+=(*x); x2+= (*x)*(*x);
    y1+=(*y); y2+= (*y)*(*y);
    x++; y++;
  }
  x2=N*x2-x1*x1; y2=N*y2-y1*y1; xy=N*xy-x1*y1;
  if((x2==0.0)||(y2==0.0))return(0.0);
  if(slope)*slope=xy/x2;
  if(offset)*offset=(y1-(*slope)*x1)/N;
  //printf("N= %d xy=%.2g x2=%.2g y2=%.2g\n", N, xy, x2, y2);
  return(xy/sqrt(x2*y2));
}

// Assembly:
xorpd %xmm1, %xmm1
xorpd %xmm8, %xmm8
xorpd %xmm4, %xmm4
xorpd %xmm3, %xmm3
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
testl %edx, %edx
jle 0x10e08
movl %edx, %eax
xorl %r9d, %r9d
movss (%rdi,%r9,4), %xmm5
movss (%rsi,%r9,4), %xmm6
movaps %xmm5, %xmm7
mulss %xmm6, %xmm7
cvtss2sd %xmm7, %xmm7
addsd %xmm7, %xmm8
xorps %xmm7, %xmm7
cvtss2sd %xmm5, %xmm7
addsd %xmm7, %xmm4
mulss %xmm5, %xmm5
cvtss2sd %xmm5, %xmm5
addsd %xmm5, %xmm0
xorps %xmm5, %xmm5
cvtss2sd %xmm6, %xmm5
addsd %xmm5, %xmm3
mulss %xmm6, %xmm6
xorps %xmm5, %xmm5
cvtss2sd %xmm6, %xmm5
addsd %xmm5, %xmm2
incq %r9
cmpl %r9d, %eax
jne 0x10db3
xorps %xmm5, %xmm5
cvtsi2sd %edx, %xmm5
movapd %xmm4, %xmm6
mulsd %xmm4, %xmm6
mulsd %xmm5, %xmm0
subsd %xmm6, %xmm0
ucomisd %xmm1, %xmm0
xorpd %xmm1, %xmm1
jne 0x10e2f
jnp 0x10ed2
movapd %xmm3, %xmm6
mulsd %xmm3, %xmm6
mulsd %xmm5, %xmm2
subsd %xmm6, %xmm2
xorpd %xmm6, %xmm6
ucomisd %xmm6, %xmm2
jne 0x10e4f
jnp 0x10ed2
movapd %xmm3, %xmm1
mulsd %xmm4, %xmm1
mulsd %xmm5, %xmm8
subsd %xmm1, %xmm8
testq %rcx, %rcx
je 0x10e77
movapd %xmm8, %xmm1
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rcx)
testq %r8, %r8
je 0x10e9b
xorps %xmm1, %xmm1
cvtss2sd (%rcx), %xmm1
mulsd %xmm4, %xmm1
subsd %xmm1, %xmm3
divsd %xmm5, %xmm3
xorps %xmm1, %xmm1
cvtsd2ss %xmm3, %xmm1
movss %xmm1, (%r8)
mulsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x10eaf
sqrtsd %xmm0, %xmm0
jmp 0x10ec5
pushq %rax
movsd %xmm8, (%rsp)
callq 0x2290
movsd (%rsp), %xmm8
addq $0x8, %rsp
divsd %xmm0, %xmm8
xorps %xmm1, %xmm1
cvtsd2ss %xmm8, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Corr_coeff_w
float Corr_coeff_w(float *xx, float *yy, int *w, int N,
		   float *slope, float *offset, int *norm)
{
  double xy=0, x1=0, y1=0, x2=0, y2=0;
  float *x=xx, *y=yy; int i;

  (*norm)=0;
  for(i=0; i<N; i++){
    if(w[i]){
      xy += (*x)*(*y); (*norm)++;
      x1+=(*x); x2+= (*x)*(*x);
      y1+=(*y); y2+= (*y)*(*y);
    }
    x++; y++;
  }
  x2=(*norm)*x2-x1*x1; y2=(*norm)*y2-y1*y1; xy=(*norm)*xy-x1*y1;
  *slope=xy/x2; *offset=(y1-(*slope)*x1)/(*norm);
  //printf("N= %d xy=%.2g x2=%.2g y2=%.2g\n", N, xy, x2, y2);
  return(xy/sqrt(x2*y2));
}

// Assembly:
pushq %rax
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
xorpd %xmm1, %xmm1
xorpd %xmm8, %xmm8
xorpd %xmm4, %xmm4
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
testl %ecx, %ecx
jle 0x10f63
movl %ecx, %ecx
xorl %r10d, %r10d
cmpl $0x0, (%rdx,%r10,4)
je 0x10f5b
movss (%rdi,%r10,4), %xmm5
movss (%rsi,%r10,4), %xmm6
movaps %xmm5, %xmm7
mulss %xmm6, %xmm7
incl (%rax)
cvtss2sd %xmm7, %xmm7
addsd %xmm7, %xmm8
xorps %xmm7, %xmm7
cvtss2sd %xmm5, %xmm7
addsd %xmm7, %xmm4
mulss %xmm5, %xmm5
cvtss2sd %xmm5, %xmm5
addsd %xmm5, %xmm2
xorps %xmm5, %xmm5
cvtss2sd %xmm6, %xmm5
addsd %xmm5, %xmm3
mulss %xmm6, %xmm6
xorps %xmm5, %xmm5
cvtss2sd %xmm6, %xmm5
addsd %xmm5, %xmm0
incq %r10
cmpq %r10, %rcx
jne 0x10f05
xorps %xmm5, %xmm5
cvtsi2sdl (%rax), %xmm5
movapd %xmm4, %xmm6
mulsd %xmm4, %xmm6
mulsd %xmm5, %xmm2
subsd %xmm6, %xmm2
movapd %xmm3, %xmm6
mulsd %xmm3, %xmm6
mulsd %xmm5, %xmm0
movapd %xmm3, %xmm7
mulsd %xmm4, %xmm7
mulsd %xmm5, %xmm8
subsd %xmm7, %xmm8
movapd %xmm8, %xmm7
divsd %xmm2, %xmm7
cvtsd2ss %xmm7, %xmm7
subsd %xmm6, %xmm0
movss %xmm7, (%r8)
xorps %xmm6, %xmm6
cvtss2sd %xmm7, %xmm6
mulsd %xmm4, %xmm6
subsd %xmm6, %xmm3
divsd %xmm5, %xmm3
cvtsd2ss %xmm3, %xmm3
movss %xmm3, (%r9)
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x10fda
sqrtsd %xmm0, %xmm0
jmp 0x10feb
movsd %xmm8, (%rsp)
callq 0x2290
movsd (%rsp), %xmm8
divsd %xmm0, %xmm8
xorps %xmm0, %xmm0
cvtsd2ss %xmm8, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Collectivity_norm1
float Collectivity_norm1(float *v, int N){
  double sum=0, Entropy=0;
  for(int i=0; i<N; i++){
    float w=v[i]; if(w<=0)continue; sum+=w; Entropy-=w*log(w);
  }
  if(sum==0){
    printf("ERROR in collectivity_norm1, sum= %.2g\n", sum);
    return(0);
  }
  Entropy=Entropy/sum+log(sum);
  float kappa=exp(Entropy);
  return(kappa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x11066
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
xorps %xmm3, %xmm3
movss (%rbx,%r15,4), %xmm0
ucomiss %xmm0, %xmm3
jae 0x1105e
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x2120
xorps %xmm3, %xmm3
movsd 0x8(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
subsd %xmm0, %xmm2
incq %r15
cmpq %r15, %r14
jne 0x1101b
ucomisd 0x3fff2(%rip), %xmm1    # 0x51060
jne 0x1108a
jp 0x1108a
leaq 0x4507f(%rip), %rdi     # 0x560f8
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0x20f0
xorpd %xmm0, %xmm0
jmp 0x110ac
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x2120
addsd 0x8(%rsp), %xmm0
callq 0x22a0
cvtsd2ss %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Collectivity_norm2
float Collectivity_norm2(float *v, int N){
  float kappa, w; double sum=0, Entropy=0; int i;
  for(i=0; i<N; i++){
    w=v[i]*v[i]; if(w>0){sum+=w; Entropy-=w*log(w);}
  }
  if(sum>0){
    Entropy=Entropy/sum;
    Entropy+=log(sum);
  }
  kappa=exp(Entropy);
  if(isnan(kappa)){
    printf("Warning in Collectivity_norm2 ");
    printf("Entropy: %.2g sum: %.2g kappa: %.2g\n", Entropy, sum, kappa);
    printf("v: ");
    for(i=0; i<30; i++)printf(" %.2g", v[i]);
    printf(" ...\n");
    //exit(8);
  }
  return(kappa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x11126
movl %esi, %r14d
xorl %r15d, %r15d
xorps %xmm3, %xmm3
movss (%rbx,%r15,4), %xmm0
mulss %xmm0, %xmm0
ucomiss %xmm3, %xmm0
jbe 0x1111e
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
addsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x2120
xorps %xmm3, %xmm3
movsd 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
subsd %xmm0, %xmm1
incq %r15
cmpq %r15, %r14
jne 0x110d7
ucomisd 0x3ff32(%rip), %xmm2    # 0x51060
movsd %xmm2, 0x18(%rsp)
jbe 0x11153
divsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd %xmm2, %xmm0
callq 0x2120
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x22a0
cvtsd2ss %xmm0, %xmm0
ucomiss %xmm0, %xmm0
jp 0x11175
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x44fa4(%rip), %rdi     # 0x56120
xorl %r15d, %r15d
xorl %eax, %eax
movss %xmm0, 0x10(%rsp)
callq 0x20f0
xorps %xmm2, %xmm2
cvtss2sd 0x10(%rsp), %xmm2
leaq 0x44fa3(%rip), %rdi     # 0x5613f
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movb $0x3, %al
callq 0x20f0
leaq 0x44fae(%rip), %rdi     # 0x56164
xorl %eax, %eax
callq 0x20f0
leaq 0x44fa4(%rip), %r14     # 0x56168
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r15,4), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x20f0
incq %r15
cmpq $0x1e, %r15
jne 0x111c4
leaq 0x44f87(%rip), %rdi     # 0x5616e
callq 0x2090
movss 0x10(%rsp), %xmm0
jmp 0x1116b
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Collectivity_norm2_outlier
float Collectivity_norm2_outlier(float *v, int N, int *outlier){
  float kappa, w; double sum=0, Entropy=0; int i;
  for(i=0; i<N; i++){
    if(outlier && (outlier[i]))continue;
    w=v[i]*v[i]; if(w>0){sum+=w; Entropy-=w*log(w);}
  }
  Entropy=Entropy/sum+log(sum);
  kappa=exp(Entropy);
  return(kappa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x11278
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r15d
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
xorps %xmm3, %xmm3
xorpd %xmm2, %xmm2
testq %rbx, %rbx
je 0x11229
cmpl $0x0, (%rbx,%r12,4)
jne 0x1126e
movss (%r14,%r12,4), %xmm0
mulss %xmm0, %xmm0
ucomiss %xmm3, %xmm0
jbe 0x1126e
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
addsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, (%rsp)
callq 0x2120
xorps %xmm3, %xmm3
movsd 0x10(%rsp), %xmm2
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
subsd %xmm0, %xmm1
incq %r12
cmpq %r12, %r15
jne 0x1121d
jmp 0x11280
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
movapd %xmm2, %xmm0
callq 0x2120
addsd (%rsp), %xmm0
callq 0x22a0
cvtsd2ss %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Collectivity_Renyi_norm1
float Collectivity_Renyi_norm1(float *v, int N){
  double sum=0, sum2=0, SR; int i; float w;
  for(i=0; i<N; i++){
    w=v[i]; if(w<=0)continue; sum+=w; sum2+=w*w;
  }
  SR=(sum*sum)/sum2;
  return(SR);
}

// Assembly:
testl %esi, %esi
jle 0x112ea
movl %esi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorps %xmm2, %xmm2
xorpd %xmm1, %xmm1
movss (%rdi,%rcx,4), %xmm3
ucomiss %xmm3, %xmm2
jae 0x112e0
xorps %xmm4, %xmm4
cvtss2sd %xmm3, %xmm4
addsd %xmm4, %xmm0
mulss %xmm3, %xmm3
cvtss2sd %xmm3, %xmm3
addsd %xmm3, %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x112bf
jmp 0x112f2
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm0, %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Area_norm1
float Area_norm1(float *v, int N){
  double sum=0, sum2=0, imean; int i; float w;
  for(i=0; i<N; i++){
    w=v[i]; if(w<=0)continue; sum+=w; sum2+=i*w;
  }
  imean=sum2/sum;
  return((N-imean-1)/(N-1));
}

// Assembly:
testl %esi, %esi
jle 0x113a2
movl %esi, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
xorps %xmm2, %xmm2
xorpd %xmm0, %xmm0
movss (%rdi,%rcx,4), %xmm3
ucomiss %xmm3, %xmm2
jae 0x11394
xorps %xmm4, %xmm4
cvtss2sd %xmm3, %xmm4
xorps %xmm5, %xmm5
cvtsi2ss %ecx, %xmm5
addsd %xmm4, %xmm1
mulss %xmm3, %xmm5
xorps %xmm3, %xmm3
cvtss2sd %xmm5, %xmm3
addsd %xmm3, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x11369
divsd %xmm1, %xmm0
jmp 0x113aa
movsd 0x44d3e(%rip), %xmm0    # 0x560e8
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
subsd %xmm0, %xmm1
addsd 0x44d33(%rip), %xmm1    # 0x560f0
decl %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/vector.c
// Function: Area_norm2
float Area_norm2(float *v, int N){
  double sum=0, sum2=0, imean; int i; float w;
  for(i=0; i<N; i++){
    w=v[i]*v[i]; if(w<=0)continue; sum+=w; sum2+=i*w;
  }
  imean=sum2/sum;
  return((N-imean-1)/(N-1));
}

// Assembly:
testl %esi, %esi
jle 0x11422
movl %esi, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
xorps %xmm2, %xmm2
xorpd %xmm0, %xmm0
movss (%rdi,%rcx,4), %xmm3
mulss %xmm3, %xmm3
ucomiss %xmm3, %xmm2
jae 0x11414
xorps %xmm4, %xmm4
cvtss2sd %xmm3, %xmm4
xorps %xmm5, %xmm5
cvtsi2ss %ecx, %xmm5
addsd %xmm4, %xmm1
mulss %xmm3, %xmm5
xorps %xmm3, %xmm3
cvtss2sd %xmm5, %xmm3
addsd %xmm3, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x113e5
divsd %xmm1, %xmm0
jmp 0x1142a
movsd 0x44cbe(%rip), %xmm0    # 0x560e8
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
subsd %xmm0, %xmm1
addsd 0x44cb3(%rip), %xmm1    # 0x560f0
decl %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/allocate_tnm.c
// Function: Allocate_tors
void Allocate_tors(struct Tors *X, int N_axes, int N_Cart, int N_modes)
{
  X->N_axes=N_axes;
  X->N_Cart=N_Cart;
  X->Cart=malloc(N_Cart*sizeof(float));
  X->Tors=malloc(N_axes*sizeof(float));
  X->MW_Tors=malloc(N_axes*sizeof(float));
  X->coeff=malloc(N_modes*sizeof(float));
  X->RMSD=0; X->M=0; 
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movslq %edx, %rdi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, 0x8(%rbx)
movslq %r14d, %r14
shlq $0x2, %r14
movq %r14, %rdi
callq 0x21d0
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x21d0
movq %rax, 0x10(%rbx)
movslq %ebp, %rdi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, 0x20(%rbx)
xorl %eax, %eax
movl %eax, 0x30(%rbx)
movl %eax, 0x3c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/allocate_tnm.c
// Function: Empty_tors
void Empty_tors(struct Tors X){
  free(X.Tors);
  free(X.MW_Tors);
  free(X.Cart);
  free(X.coeff);
}

// Assembly:
pushq %rax
movq 0x28(%rsp), %rdi
callq 0x2050
movq 0x20(%rsp), %rdi
callq 0x2050
movq 0x18(%rsp), %rdi
callq 0x2050
movq 0x30(%rsp), %rdi
popq %rax
jmp 0x2050
nop
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/align_tnm.c
// Function: Match_chains_by_length
void Match_chains_by_length(int *match1,
			    struct chain *chains1, int Nchain1,
			    struct chain *chains2, int Nchain2)
{
  int match2[Nchain2], free1[Nchain1], free2[Nchain2], i, j;
  for(i=0; i<Nchain1; i++){match1[i]=-1; free1[i]=1;}
  for(i=0; i<Nchain2; i++){match2[i]=-1; free2[i]=1;}
  Best_match(match1, free1, chains1, Nchain1, chains2, Nchain2);
  Best_match(match2, free2, chains2, Nchain2, chains1, Nchain1);
  for(i=0; i<Nchain1; i++){
    j=match1[i];
    if(match2[j]==i){free2[j]=0;} // Freeze reciprocal best matches
    else{match1[i]=-1;}
  }
  Best_match(match1, free1, chains1, Nchain1, chains2, Nchain2);  

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, %r13
movl %r8d, -0x2c(%rbp)
movl %r8d, %r14d
movq %rsp, %rcx
leaq 0xf(,%r14,4), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movl %edx, %r15d
movq %rsp, %r12
leaq 0xf(,%r15,4), %rcx
andq $-0x10, %rcx
subq %rcx, %r12
movq %r12, %rsp
movq %rsp, %rbx
subq %rax, %rbx
movq %rbx, %rsp
movl %edx, -0x30(%rbp)
testl %edx, %edx
jle 0x1228a
leaq (,%r15,4), %rdx
movq %r13, %rdi
movl $0xff, %esi
callq 0x2110
xorl %eax, %eax
movl $0x1, (%r12,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0x1227a
cmpl $0x0, -0x2c(%rbp)
jle 0x122b7
leaq (,%r14,4), %rdx
movq -0x38(%rbp), %rdi
movl $0xff, %esi
callq 0x2110
xorl %eax, %eax
movl $0x1, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r14
jne 0x122a8
movq %r13, %rdi
movq %r12, %rsi
movq -0x40(%rbp), %rdx
movl -0x30(%rbp), %r14d
movl %r14d, %ecx
movq -0x48(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x1234a
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq -0x48(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %r8
movl %r14d, %r9d
callq 0x1234a
movq -0x38(%rbp), %rsi
testl %r14d, %r14d
jle 0x12321
xorl %eax, %eax
movslq (%r13,%rax,4), %rcx
movl (%rsi,%rcx,4), %edx
cmpq %rdx, %rax
jne 0x12310
movl $0x0, (%rbx,%rcx,4)
jmp 0x12319
movl $0xffffffff, (%r13,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq %rax, %r15
jne 0x122fa
movq %r13, %rdi
movq %r12, %rsi
movq -0x40(%rbp), %rdx
movl -0x30(%rbp), %ecx
movq -0x48(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x1234a
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/align_tnm.c
// Function: Best_match
void Best_match(int *match1, int *free2,
		struct chain *chains1, int Nchain1,
		struct chain *chains2, int Nchain2)
{
  for(int i=0; i<Nchain1; i++){
    if(match1[i]>=0)continue;
    int imin=-1, d_min=100000, n1=chains1[i].nres;
    if((i<Nchain2)&&(free2[i])){
      d_min=abs(n1-chains2[i].nres); imin=i;
    }
    for(int j=0; j<Nchain2; j++){
      if((j==i)||(free2[j]==0))continue;
      int d=abs(n1-chains2[j].nres);
      if(d<d_min){d_min=d; imin=j;}
    }
    match1[i]=imin;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, -0x10(%rsp)
testl %ecx, %ecx
jle 0x12409
movslq %r9d, %rax
movl %ecx, %ecx
movl %eax, %r10d
movq -0x10(%rsp), %r8
addq $0x1c, %r8
movq %r8, -0x8(%rsp)
xorl %ebx, %ebx
cmpl $0x0, (%rdi,%rbx,4)
jns 0x123fd
imulq $0x70, %rbx, %r12
movl 0x1c(%rdx,%r12), %r8d
movl $0x186a0, %r14d         # imm = 0x186A0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpq %rax, %rbx
jge 0x123b9
cmpl $0x0, (%rsi,%rbx,4)
je 0x123b9
movl %r8d, %r15d
movq -0x10(%rsp), %r11
subl 0x1c(%r11,%r12), %r15d
movl %r15d, %r14d
negl %r14d
cmovsl %r15d, %r14d
movl %ebx, %r15d
testl %r9d, %r9d
jle 0x123f9
movq -0x8(%rsp), %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x123ed
cmpl $0x0, (%rsi,%r13,4)
je 0x123ed
movl %r8d, %r11d
subl (%r12), %r11d
movl %r11d, %ebp
negl %ebp
cmovsl %r11d, %ebp
cmpl %r14d, %ebp
cmovll %r13d, %r15d
cmovll %ebp, %r14d
incq %r13
addq $0x70, %r12
cmpq %r13, %r10
jne 0x123c6
movl %r15d, (%rdi,%rbx,4)
incq %rbx
cmpq %rcx, %rbx
jne 0x12379
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/align_tnm.c
// Function: Test_chains
void Test_chains(int *icl, int ncl,struct chain *chains, int Nchain, int n)
{
  int i, j;
  for(j=0; j<ncl; j++){
    i=icl[j];
    if(i<0 || i>=Nchain){
      printf("ERROR, wrong index of chain in PDB%d: %d not in [0,%d]\n",
	     n, i, Nchain); exit(8);
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x129f9
movl %edx, %eax
movl %esi, %esi
xorl %r8d, %r8d
movl (%rdi,%r8,4), %edx
testl %edx, %edx
js 0x129fa
cmpl %eax, %edx
jge 0x129fa
incq %r8
cmpq %r8, %rsi
jne 0x129e5
retq
pushq %rax
leaq 0x43a55(%rip), %rdi     # 0x56457
movl %ecx, %esi
movl %eax, %ecx
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2270
nop
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/dof_tnm.c
// Function: Count_gaps
int Count_gaps(struct bond *bonds, int natoms){
  int Ngap=0, ichain=-1, ires=-1;
  for(int i=0; i<natoms; i++){
    struct bond *bond=bonds+i;
    if(bond->atom->chain!=ichain){
      ichain=bond->atom->chain; ires=bond->atom->res;
      continue;
    }
    if(bond->atom->res!=ires){
      if((ires>=0)&&(bond->previous!=NULL)){
	if(Distance_square(bond->r, bond->previous->r) > D2_GAP)Ngap++;
      }
      ires=bond->atom->res;
    }
  }
  printf("%d gaps found in protein\n", Ngap);
  return(Ngap);
}

// Assembly:
pushq %rbx
testl %esi, %esi
jle 0x13d06
movss 0x54bc1(%rip), %xmm0    # 0x68828
movl %esi, %eax
shlq $0x6, %rax
leaq (%rax,%rax,2), %rax
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %ebx, %ebx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq (%rdi,%rcx), %r9
movl 0x64(%r9), %esi
movl 0x6c(%r9), %r9d
cmpl %edx, %r9d
jne 0x13c9b
cmpl %r8d, %esi
jne 0x13caf
movl %r8d, %esi
jmp 0x13c9e
movl %r9d, %edx
addq $0xc0, %rcx
movl %esi, %r8d
cmpq %rcx, %rax
jne 0x13c80
jmp 0x13d08
testl %r8d, %r8d
js 0x13c9e
movq 0x28(%rdi,%rcx), %r8
testq %r8, %r8
je 0x13c9e
movsd 0x8(%rdi,%rcx), %xmm1
movsd 0x10(%rdi,%rcx), %xmm2
subsd 0x8(%r8), %xmm1
subsd 0x10(%r8), %xmm2
movsd 0x18(%rdi,%rcx), %xmm3
subsd 0x18(%r8), %xmm3
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
xorps %xmm1, %xmm1
cvtsd2ss %xmm3, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x13c9e
incl %ebx
jmp 0x13c9e
xorl %ebx, %ebx
leaq 0x42b51(%rip), %rdi     # 0x56860
movl %ebx, %esi
xorl %eax, %eax
callq 0x20f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/dof_tnm.c
// Function: Set_rigid
void Set_rigid(struct rigid *rigid_tmp, int *nrigid,
	       struct bond *bond, int prev_chain, int N_axes)
{
  rigid_tmp[*nrigid].chain1=prev_chain;
  rigid_tmp[*nrigid].chain2=bond->atom->chain;
  rigid_tmp[*nrigid].iaxe=N_axes;
  (*nrigid)++;
}

// Assembly:
movslq (%rsi), %rax
leaq (%rax,%rax,2), %rax
movl %ecx, (%rdi,%rax,4)
movq (%rdx), %rax
movl 0x6c(%rax), %eax
movslq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
movl %eax, 0x4(%rdi,%rcx,4)
movslq (%rsi), %rax
leaq (%rax,%rax,2), %rax
movl %r8d, 0x8(%rdi,%rax,4)
incl (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/dof_tnm.c
// Function: Axe_prot_main
char Axe_prot_main(struct bond *bond, int r_last)
{
  char *name=bond->atom->name, *previous_name=bond->previous->atom->name;
  if(strncmp(name,"N ", 2)==0){
    if((strncmp(previous_name,"C ", 2)==0)&&
       (bond->atom->res==(bond->previous->atom->res+1))){
      return('o'); // omega 
    }else{return('q');}         // Pseudo-axe after disordered loop
  }else if(strncmp(name,"CA", 2)==0){
    if((strncmp(previous_name,"N ", 2)==0)&&
       (bond->atom->res==bond->previous->atom->res)){
      return('f'); // phi
    }else{return('q');}
  }else if(strncmp(name,"C ", 2)==0){
    if((strncmp(previous_name,"CA", 2)==0)&&
       (bond->atom->res==bond->previous->atom->res)){
      if(bond->atom->res==r_last)return(NONE);
      return('p'); // psi
    }else{return('q');}
  }else{
    return('s');
  }
  return(NONE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq (%rdi), %r12
movq 0x28(%rdi), %rax
leaq 0x18(%r12), %r15
movq (%rax), %r13
leaq 0x18(%r13), %r14
leaq 0x42018(%rip), %rsi     # 0x55f23
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
je 0x13f92
leaq 0x41247(%rip), %rsi     # 0x5516a
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
je 0x13fbb
leaq 0x41fe7(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
movl %eax, %ecx
movb $0x73, %al
testl %ecx, %ecx
jne 0x13fe2
leaq 0x4120b(%rip), %rsi     # 0x5516a
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
movl %eax, %ecx
movb $0x71, %al
testl %ecx, %ecx
jne 0x13fe2
movl 0x64(%r12), %ecx
cmpl 0x64(%r13), %ecx
jne 0x13fe2
cmpl %ebx, %ecx
movzbl 0x5489c(%rip), %ecx     # 0x68824
movl $0x70, %eax
cmovel %ecx, %eax
jmp 0x13fe2
leaq 0x41f8d(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
jne 0x13fe0
movl 0x64(%r13), %ecx
incl %ecx
movb $0x6f, %al
cmpl %ecx, 0x64(%r12)
jne 0x13fe0
jmp 0x13fe2
leaq 0x41f61(%rip), %rsi     # 0x55f23
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
jne 0x13fe0
movl 0x64(%r12), %ecx
movb $0x66, %al
cmpl 0x64(%r13), %ecx
je 0x13fe2
movb $0x71, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/dof_tnm.c
// Function: Axe_nuc_main
char Axe_nuc_main(struct bond *bond, int r_last)
{
  char *name=bond->atom->name, *previous_name=bond->previous->atom->name;
  if(strncmp(name,"O5'", 3)==0){
    if(strncmp(previous_name,"P ", 3)==0)return('1');
  }else if(strncmp(name,"C5'", 3)==0){
    if(strncmp(previous_name,"O5'", 3)==0)return('2');
  }else if(strncmp(name,"C4'", 3)==0){
    if(strncmp(previous_name,"C5'", 3)==0)return('3');
  }else if(strncmp(name,"C3'", 3)==0){
    if(strncmp(previous_name,"C4'", 3)==0)return('4');
  }else if(strncmp(name,"O3'", 3)==0){
    if(strncmp(previous_name,"C3'", 3)==0)return('5');
  }else if(strncmp(name,"P  ", 3)==0){
    if(strncmp(previous_name,"O3'", 3)==0)return('6');
    /*}else if(strncmp(name,"C1'", 3)==0){
      if(strncmp(previous_name,"N", 1)==0)return('s');*/ // side chain!
  }else{
    return(NONE);
  }
  return(NONE);
  //return('q'); // Disordered main axis
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x28(%rdi), %rax
addq $0x18, %r14
movq (%rax), %rbx
addq $0x18, %rbx
leaq 0x4287c(%rip), %rsi     # 0x56885
movl $0x3, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x140cd
leaq 0x42867(%rip), %rsi     # 0x5688c
movl $0x3, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x140e9
leaq 0x4284f(%rip), %rsi     # 0x56890
movl $0x3, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x14105
leaq 0x42837(%rip), %rsi     # 0x56894
movl $0x3, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x14121
leaq 0x4281f(%rip), %rsi     # 0x56898
movl $0x3, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x1413d
leaq 0x42807(%rip), %rsi     # 0x5689c
movl $0x3, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
jne 0x14155
leaq 0x427e7(%rip), %rsi     # 0x56898
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x14155
movb $0x36, %al
jmp 0x1415b
leaq 0x427b5(%rip), %rsi     # 0x56889
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x14155
movb $0x31, %al
jmp 0x1415b
leaq 0x42795(%rip), %rsi     # 0x56885
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x14155
movb $0x32, %al
jmp 0x1415b
leaq 0x42780(%rip), %rsi     # 0x5688c
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x14155
movb $0x33, %al
jmp 0x1415b
leaq 0x42768(%rip), %rsi     # 0x56890
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x14155
movb $0x34, %al
jmp 0x1415b
leaq 0x42750(%rip), %rsi     # 0x56894
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x14163
movb 0x546c9(%rip), %al      # 0x68824
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x35, %al
jmp 0x1415b
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/dof_tnm.c
// Function: Count_interactions
int Count_interactions(atom *atoms, int natoms,
		       struct interaction *Int_list, int N_int)
{
  int i;
  for(i=0; i<natoms; i++)atoms[i].N_int=0;
  for(i=0; i<N_int; i++){
    atoms[Int_list[i].i1].N_int++;
    atoms[Int_list[i].i2].N_int++;
  }
  return i;
}

// Assembly:
testl %esi, %esi
jle 0x14584
movl %esi, %eax
imulq $0x70, %rax, %rax
xorl %esi, %esi
movl $0x0, 0x60(%rdi,%rsi)
addq $0x70, %rsi
cmpq %rsi, %rax
jne 0x14573
testl %ecx, %ecx
jle 0x145b7
movl %ecx, %ecx
addq $0x4, %rdx
xorl %eax, %eax
movslq -0x4(%rdx), %rsi
imulq $0x70, %rsi, %rsi
incl 0x60(%rdi,%rsi)
movslq (%rdx), %rsi
imulq $0x70, %rsi, %rsi
incl 0x60(%rdi,%rsi)
incq %rax
addq $0xc8, %rdx
cmpq %rax, %rcx
jne 0x14590
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/dof_tnm.c
// Function: Select_axes_int
int Select_axes_int(int *skipped, struct axe *axes, int *N_axes, int start,
		    atom *atoms, int natoms, int MIN_INT)
{
  int n_skipped=0;
  int n=start, last=*N_axes-1, last_a, a, i;
  for(a=start; a<*N_axes; a++){
    struct axe *axe=axes+a;
    if(a<last){
      struct axe *next=axe+1;
      if(((next->type=='l')||(axe->type=='l')||(axe->type=='a'))&&
	 ((a+1)<last)){
	next++;
      }
      last_a=next->first_atom;
    }else{
      last_a=natoms;
    }
    int num_int=0;
    for(i=axe->first_atom; i< last_a; i++)num_int+=atoms[i].N_int;
    if((num_int >= MIN_INT)||(axe->rigid)){ //
      if(a!=n)axes[n]=*axe;
      n++;
    }else{
      printf("%c%d ", axe->type, a);
      skipped[n_skipped]=a;
      n_skipped++;
    }
  }
  *N_axes=n;
  return(n_skipped);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, 0x10(%rsp)
movslq (%rdx), %rcx
xorl %r13d, %r13d
cmpl %ebx, %ecx
jle 0x146cf
movq %rsi, %r12
leal -0x1(%rcx), %eax
movslq %ebx, %r15
movslq %eax, %rbp
addq $-0x2, %rcx
movq %rcx, 0x18(%rsp)
addq $0x60, %r8
movq %r8, 0x20(%rsp)
xorl %r13d, %r13d
imulq $0x158, %r15, %rsi      # imm = 0x158
addq %r12, %rsi
movl 0xc(%rsp), %ecx
cmpq %rbp, %r15
jge 0x14649
leaq 0x158(%rsi), %rax
cmpb $0x6c, 0x158(%rsi)
je 0x14636
movzbl (%rsi), %ecx
cmpl $0x6c, %ecx
je 0x14636
cmpl $0x61, %ecx
jne 0x14646
leaq 0x2b0(%rsi), %rcx
cmpq 0x18(%rsp), %r15
cmovlq %rcx, %rax
movl 0x10(%rax), %ecx
movslq 0x10(%rsi), %rdi
xorl %eax, %eax
cmpl %ecx, %edi
jge 0x1466f
movslq %ecx, %rcx
imulq $0x70, %rdi, %rdx
addq 0x20(%rsp), %rdx
subq %rdi, %rcx
xorl %eax, %eax
addl (%rdx), %eax
addq $0x70, %rdx
decq %rcx
jne 0x14664
cmpl 0x60(%rsp), %eax
jge 0x1467b
cmpl $0x0, 0x4(%rsi)
je 0x146aa
cmpl %r15d, %ebx
je 0x14697
movslq %ebx, %rax
imulq $0x158, %rax, %rdi      # imm = 0x158
addq %r12, %rdi
movl $0x158, %edx            # imm = 0x158
callq 0x21a0
incl %ebx
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x14606
jmp 0x146cf
movsbl (%rsi), %esi
leaq 0x421ec(%rip), %rdi     # 0x568a0
movl %r15d, %edx
xorl %eax, %eax
callq 0x20f0
movslq %r13d, %r13
movq 0x10(%rsp), %rax
movl %r15d, (%rax,%r13,4)
incl %r13d
jmp 0x14699
movl %ebx, (%r14)
movl %r13d, %eax
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/dof_tnm.c
// Function: Last_axe
int Last_axe(int *aa, struct axe *axes, int ini, int n, int iatom)
{
  int a=*aa; struct axe *axe=axes+(*aa);
  while(a<n){
    if(axe->first_atom>iatom)break;
    a++; axe++;
  }
  if(a==0)return(-1);
  if(a==n){a--; axe--;}
  if(axe->first_atom>iatom && (axe-1)->first_atom<=iatom){a--; axe--;}
  if(a<ini){*aa=a;}else{*aa=ini;}
  if((axe->first_atom<=iatom))return(a); //&&(axe->last_atom>=i)
  printf("WARNING, last_axe<0: atom %d axe %d n= %d first %d last %d\n",
	 iatom, a, n, axe->first_atom, axe->last_atom); //exit(8);
  return(-1);
}

// Assembly:
pushq %rbx
movl %edx, %eax
movslq (%rdi), %rdx
imulq $0x158, %rdx, %r9       # imm = 0x158
addq %rsi, %r9
cmpl %ecx, %edx
jge 0x1470d
cmpl %r8d, 0x10(%r9)
jg 0x1470d
incl %edx
addq $0x158, %r9             # imm = 0x158
cmpl %edx, %ecx
jne 0x146f8
movl %ecx, %edx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edx, %edx
je 0x14770
leaq -0x158(%r9), %rsi
xorl %r10d, %r10d
cmpl %ecx, %edx
cmovneq %r9, %rsi
sete %r10b
subl %r10d, %edx
cmpl %r8d, 0x10(%rsi)
jle 0x14745
cmpl %r8d, -0x148(%rsi)
jg 0x14745
addq $-0x158, %rsi           # imm = 0xFEA8
decl %edx
cmpl %eax, %edx
cmovll %edx, %eax
movl %eax, (%rdi)
movl 0x10(%rsi), %eax
cmpl %r8d, %eax
jle 0x1476e
movl 0x14(%rsi), %r9d
leaq 0x42147(%rip), %rdi     # 0x568a6
movl %r8d, %esi
movl %eax, %r8d
xorl %eax, %eax
callq 0x20f0
jmp 0x14770
movl %edx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/buildup.c
// Function: Trajectory
void Trajectory(atom *atoms, int natoms, struct axe *axes, int naxe,
		float **Tors_mode, int imode, float fact, int nmove,
		struct bond *bonds)
{
  int iter, i, iatom, j;

  Set_bonds_measure(bonds, natoms, atoms);
  double d_phi[naxe];
  for(i=0; i<naxe; i++)d_phi[i]=Tors_mode[imode][i]*fact;

  atom *atommove=malloc(natoms*sizeof(atom));
  for(iter=0; iter<nmove; iter++){
    Build_up(bonds, natoms, d_phi, naxe);
    double r2=0; float x;
    for(i=0; i<natoms; i++){
      struct bond *bond=bonds+i;
      if(bond->i_atom<0)break;
      iatom=bond->i_atom;
      for(j=0; j<3; j++){
	atommove[i].r[j]=bonds[i].r[j];
	x=atommove[i].r[j]-atoms[iatom].r[j];
	r2+=x*x;
      }
      // printf("%3d %s %.4f\n", i, bond->name, x);
    }
    printf("mode %2d step %3d d2=%.4f\n", imode, iter, r2);
  }
  free(atommove);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm0, -0x38(%rbp)
movl %r9d, -0x30(%rbp)
movq %r8, %r14
movl %ecx, %ebx
movq %rdi, %r15
movq 0x18(%rbp), %r12
movq %r12, %rdi
movl %esi, -0x2c(%rbp)
movq %r15, %rdx
callq 0x1512b
movss -0x38(%rbp), %xmm1
movl %ebx, %eax
movq %rsp, %rdx
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
subq %rcx, %rdx
movq %rdx, %rsp
testl %ebx, %ebx
jle 0x15070
movslq -0x30(%rbp), %rcx
movq (%r14,%rcx,8), %rcx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x15056
cmpl $0x0, 0x10(%rbp)
jle 0x1511c
movslq -0x2c(%rbp), %r14
leaq 0x8(%r12), %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
movq %rdx, -0x40(%rbp)
movl -0x2c(%rbp), %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x154bb
xorps %xmm0, %xmm0
testl %r13d, %r13d
jle 0x150fa
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x6, %rdx
movslq 0x20(%r12,%rdx), %rdx
testq %rdx, %rdx
js 0x150e8
imulq $0x70, %rdx, %rsi
addq %r15, %rsi
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
cvtsd2ss %xmm1, %xmm1
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq $0x3, %rdi
jne 0x150c5
testl %edx, %edx
js 0x150fa
incq %rcx
addq $0xc0, %rax
cmpq %r14, %rcx
jl 0x150aa
leaq 0x41887(%rip), %rdi     # 0x56988
movl -0x30(%rbp), %esi
movl %ebx, %edx
movb $0x1, %al
callq 0x20f0
incl %ebx
cmpl 0x10(%rbp), %ebx
movq -0x40(%rbp), %rdx
jne 0x15091
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/buildup.c
// Function: Is_atom_main
int Is_atom_main(char *name, int seq_type){
  if((seq_type==1)||(seq_type==-1)){ // Amino-acid
    if((strncmp(name, "N ", 2)==0)||
       (strncmp(name, "CA", 2)==0)||
       (strncmp(name, "C ", 2)==0)){return(1);}
    else{return(0);}
  }else if((seq_type== 2)||(seq_type== 3)||
	   (seq_type==-2)||(seq_type==-3)){ // Nucleic acid
    if((strncmp(name,"P ", 3)==0)||
       (strncmp(name,"O5'", 3)==0)||
       (strncmp(name,"C5'", 3)==0)||
       (strncmp(name,"C4'", 3)==0)||
       (strncmp(name,"C3'", 3)==0)||
       (strncmp(name,"O3'", 3)==0)){return(1);}
    else{return(0);}
  }else{
    return(1);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
addl $0x3, %esi
cmpl $0x6, %esi
ja 0x15ce7
movq %rdi, %rbx
movl $0x63, %eax
btl %esi, %eax
jae 0x15c93
leaq 0x40c81(%rip), %rsi     # 0x56889
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x15ce7
leaq 0x40c61(%rip), %rsi     # 0x56885
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x15ce7
leaq 0x40c4c(%rip), %rsi     # 0x5688c
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x15ce7
leaq 0x40c34(%rip), %rsi     # 0x56890
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x15ce7
leaq 0x40c20(%rip), %rsi     # 0x56894
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x15ce7
leaq 0x40c0c(%rip), %rsi     # 0x56898
movl $0x3, %edx
jmp 0x15cd9
movl $0x14, %eax
btl %esi, %eax
jae 0x15ce7
leaq 0x4027f(%rip), %rsi     # 0x55f23
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x15ce7
leaq 0x3f4ae(%rip), %rsi     # 0x5516a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x15ce7
leaq 0x40252(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
sete %bpl
movzbl %bpl, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/interactions_tnm.c
// Function: Purge_interactions_res_pair
void Purge_interactions_res_pair(int *N_int, struct interaction *Int_list,
				 int nres)
{
  // Maximum one interaction per residue pair
  int Nnew=0, res1, res2, k; 
  struct interaction *res12;
  struct interaction *ptr, *ini=Int_list, *end=Int_list+*N_int;
  struct interaction *tmp=malloc(*N_int*sizeof(struct interaction));

  for(res1=0; res1<nres; res1++){
    for(res2=res1+1; res2<nres; res2++){
      // Find strongest res1-res2 contact
      // Find the next value of res2
      int res2min=nres; res12=NULL;
      for(ptr=ini; ptr<end; ptr++){
	if(ptr->res1 > res1)break;
	if(ptr->res1 == res1){
	  if(ptr->res2 == res2){
	    if((res12==NULL)||(ptr->sec_der>res12->sec_der)||
	       ((ptr->sec_der==res12->sec_der)&&(ptr->r0 < res12->r0))){
	      res12=ptr;
	    }
	  }else if((ptr->res2 < res2min)&&(ptr->res2 > res2)){
	    res2min=ptr->res2;
	  }
	}
      } // End pair

      if(res12){tmp[Nnew]=*res12; Nnew++;} // store

      // Prepare next value
      if(res2min==nres){ini=ptr; break;} // end res2
      else{res2=res2min-1;}

    } // end res2
  } // end res1

  for(k=0; k<Nnew; k++)Int_list[k]=tmp[k];
  *N_int=Nnew;
  free(tmp);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
movslq (%rdi), %rax
imulq $0xc8, %rax, %r12
movq %r12, %rdi
callq 0x21d0
movq %rax, %r8
testl %ebp, %ebp
movq %rax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
jle 0x189d9
movl %ebp, %edi
addq %r13, %r12
xorl %edx, %edx
xorl %eax, %eax
movl %ebp, 0x4(%rsp)
movl %eax, %ebx
leal 0x1(%rbx), %r14d
movl %r14d, (%rsp)
cmpl %edi, %r14d
jge 0x189cc
cmpq %r12, %r13
jae 0x18981
movl %edi, %ebp
movq %r13, %r15
xorl %esi, %esi
cmpl %ebx, 0x8(%r15)
jg 0x18988
jne 0x18973
movl 0xc(%r15), %eax
cmpl %r14d, %eax
jne 0x18966
testq %rsi, %rsi
je 0x18961
movsd 0x28(%r15), %xmm0
ucomisd 0x28(%rsi), %xmm0
ja 0x18961
jne 0x18973
jp 0x18973
movsd 0x20(%rsi), %xmm0
ucomisd 0x20(%r15), %xmm0
jbe 0x18973
movq %r15, %rsi
jmp 0x18973
cmpl %ebp, %eax
movl %ebp, %ecx
cmovll %eax, %ecx
cmpl %r14d, %eax
cmovgl %ecx, %ebp
addq $0xc8, %r15
cmpq %r12, %r15
jb 0x1892d
jmp 0x18988
xorl %esi, %esi
movq %r13, %r15
movl %edi, %ebp
testq %rsi, %rsi
je 0x189b9
movslq %edx, %rdx
movq %rdx, 0x20(%rsp)
imulq $0xc8, %rdx, %rdi
addq %r8, %rdi
movl $0xc8, %edx
callq 0x21a0
movl 0x4(%rsp), %edi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %r8
incl %edx
incl %r14d
cmpl %edi, %ebp
cmovnel %ebp, %r14d
cmoveq %r15, %r13
jne 0x18918
movl (%rsp), %eax
cmpl %edi, %eax
jne 0x1890e
jmp 0x189db
xorl %edx, %edx
testl %edx, %edx
jle 0x18a00
movl %edx, %eax
movq %rdx, %rbx
imulq $0xc8, %rax, %rdx
movq 0x10(%rsp), %rdi
movq %r8, %rsi
callq 0x21a0
movq %rbx, %rdx
movq 0x8(%rsp), %r8
movq 0x18(%rsp), %rax
movl %edx, (%rax)
movq %r8, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/interactions_tnm.c
// Function: Find_atom
int Find_atom(atom *atoms, int *i1, int res, int N_atoms, char *atom_type){
  int i; atom *atom;

  atom=atoms+*i1;
  for(i=*i1; i<N_atoms; i++){
    if(atom->res > res)break;
    if(atom->res < res)goto next1;
    if(strncmp(atom->name, atom_type, 2)==0){*i1=i; return(0);}
  next1: atom++;
  }
  // Not found? Look for CA atom
  atom=atoms+*i1;
  for(i=*i1; i<N_atoms; i++){
    if(atom->res > res)break;
    if(atom->res < res)goto next2;
    if(strncmp(atom->name, "CA", 2)==0){*i1=i; return(0);}
  next2: atom++;
  }
  return(-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl (%rsi), %r12d
movslq %r12d, %rax
movq %rax, (%rsp)
cmpl %ecx, %eax
jge 0x18e0a
movq %r8, %r15
imulq $0x70, (%rsp), %rax
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx), %rbx
addq $0x64, %rbx
movl %r12d, %r13d
cmpl %r14d, (%rbx)
jg 0x18e0a
jl 0x18dfe
leaq -0x4c(%rbx), %rdi
movl $0x2, %edx
movq %r15, %rsi
callq 0x2070
testl %eax, %eax
je 0x18e5c
incl %r13d
addq $0x70, %rbx
cmpl %r13d, %ebp
jne 0x18de2
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl %ebp, %r12d
jge 0x18e67
imulq $0x70, (%rsp), %rax
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx), %r13
addq $0x64, %r13
leaq 0x3c33c(%rip), %rbx     # 0x5516a
cmpl %r14d, (%r13)
jg 0x18e67
jl 0x18e4b
leaq -0x4c(%r13), %rdi
movl $0x2, %edx
movq %rbx, %rsi
callq 0x2070
testl %eax, %eax
je 0x18e59
incl %r12d
addq $0x70, %r13
cmpl %r12d, %ebp
jne 0x18e2e
jmp 0x18e67
movl %r12d, %r13d
movq 0x10(%rsp), %rax
movl %r13d, (%rax)
xorl %r15d, %r15d
movl %r15d, %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/interactions_tnm.c
// Function: Covalent
int Covalent(int res1, int res2, atom *atom1, atom *atom2){
  if(res2!=(res1+1))return(0);
  if((strncmp(atom2->name, "N ", 2)==0)&&
       ((strncmp(atom1->name, "O ", 2)==0)
	||(strncmp(atom1->name, "CA", 2)==0)
	||(strncmp(atom1->name, "C ", 2)==0)
	))return(1);
  if((strncmp(atom2->name, "CA", 2)==0)&&
     (strncmp(atom1->name, "C ", 2)==0)
     //||(strncmp(atom1->name, "O ", 2)==0)
     )return(1);
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
incl %edi
xorl %ebp, %ebp
cmpl %esi, %edi
jne 0x18ee0
movq %rcx, %r14
movq %rdx, %rbx
addq $0x18, %r14
leaq 0x3d08a(%rip), %rsi     # 0x55f23
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x18eed
leaq 0x3c2b9(%rip), %rsi     # 0x5516a
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
jne 0x18ede
addq $0x18, %rbx
leaq 0x3d059(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x18f44
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rbx), %r15
leaq 0x3d031(%rip), %rsi     # 0x55f29
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
movl $0x1, %ebp
testl %eax, %eax
je 0x18ee0
leaq 0x3c255(%rip), %rsi     # 0x5516a
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
je 0x18ee0
leaq 0x3cff9(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x18eaa
jmp 0x18ee0
movl $0x1, %ebp
jmp 0x18ee0