LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Get_tors
int Get_tors(struct axe *axe, int naxe, int res, int a_ini){
  for(int a=a_ini; a<naxe; a++){
    if((axe[a].bond)->atom->res == res){
      return(a);
    }else if((axe[a].bond)->atom->res > res){
      return(-1);
    }
  }
  return(-1);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, %ecx
jge 0x29816
movslq %ecx, %r8
movslq %esi, %rsi
imulq $0x158, %r8, %r9        # imm = 0x158
addq %r9, %rdi
addq $0x8, %rdi
incq %r8
movq (%rdi), %r9
movq (%r9), %r9
movl 0x64(%r9), %r9d
cmpl %edx, %r9d
je 0x29817
jg 0x29816
incl %ecx
addq $0x158, %rdi            # imm = 0x158
leaq 0x1(%r8), %r9
cmpq %rsi, %r8
movq %r9, %r8
jl 0x297f0
retq
movl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/Fit_B_factors.c
// Function: Compute_correlation
float Compute_correlation(float **Cart_mode, float *sigma2,
			  int N_modes, int i1, int i2)
{
  int ia, k1=3*i1, k2=3*i2;
  double corr=0;
  for(ia=0; ia< N_modes; ia++){
    if(sigma2[ia]==0)continue;
    float *x1=Cart_mode[ia]+k1;
    float *x2=Cart_mode[ia]+k2;
    double xx=x1[0]*x2[0]+x1[1]*x2[1]+x1[2]*x2[2];
    corr += xx*sigma2[ia];
  }
  return(corr);
}

// Assembly:
testl %edx, %edx
jle 0x2a305
leal (%r8,%r8,2), %r8d
leal (%rcx,%rcx,2), %eax
cltq
movslq %r8d, %rcx
movl %edx, %edx
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
xorps %xmm1, %xmm1
movss (%rsi,%r8,4), %xmm2
ucomiss %xmm1, %xmm2
jne 0x2a2b4
jnp 0x2a2f8
movq (%rdi,%r8,8), %r9
movss 0x4(%r9,%rax,4), %xmm3
mulss 0x4(%r9,%rcx,4), %xmm3
movss (%r9,%rax,4), %xmm4
mulss (%r9,%rcx,4), %xmm4
addss %xmm3, %xmm4
movss 0x8(%r9,%rax,4), %xmm3
mulss 0x8(%r9,%rcx,4), %xmm3
addss %xmm4, %xmm3
cvtss2sd %xmm3, %xmm3
cvtss2sd %xmm2, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm0
incq %r8
cmpq %r8, %rdx
jne 0x2a2a7
cvtsd2ss %xmm0, %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/Fit_B_factors.c
// Function: Print_data
void Print_data(float **X, float *Y, int N, int Npar, char *name){
  char nameout[100];
  sprintf(nameout, "%s_Bfact_data_fits.dat", name);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  int a,i;
  /*float *norm=malloc(Npar*sizeof(float)); 
  for(a=0; a<Npar; a++){
    double sum=0;
    for(i=0; i<N; i++)sum+=X[i][a]*X[i][a];
    norm[a]=sqrt(sum/N);
    }*/
  fprintf(file_out, "#Y ENM const x y z xx xy xz yy yz zz\n");
  for(i=0; i<N; i++){
    fprintf(file_out, "%.3f\t",Y[i]);
    for(a=0; a<Npar; a++)fprintf(file_out, "%.3f\t",X[i][a]);
    fprintf(file_out, "\n");
  }
  fclose(file_out);
  //free(norm);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
leaq 0x2f21c(%rip), %rsi     # 0x598f8
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2270
leaq 0x2cb0b(%rip), %rsi     # 0x57200
movq %r13, %rdi
callq 0x2220
movq %rax, %r12
leaq 0x27648(%rip), %rdi     # 0x51d4f
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x2f1f7(%rip), %rdi     # 0x5990f
movl $0x25, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x2290
testl %ebp, %ebp
jle 0x2a79e
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %r14d
xorl %ebx, %ebx
leaq 0x2f1f2(%rip), %r13     # 0x59935
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbx,4), %xmm0
movq %r12, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x21a0
cmpl $0x0, 0xc(%rsp)
jle 0x2a787
xorl %ebp, %ebp
movq (%r15,%rbx,8), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbp,4), %xmm0
movq %r12, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x21a0
incq %rbp
cmpq %rbp, %r14
jne 0x2a766
movl $0xa, %edi
movq %r12, %rsi
callq 0x2140
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x2a743
movq %r12, %rdi
callq 0x20c0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/Fit_B_factors.c
// Function: Find_outliers_mean
int Find_outliers_mean(int *outlier, float *y, int N, float sig){
  double y1=0; int i;
  for(i=0; i<N; i++)y1+=y[i];
  float max=sig*y1/N; int n=0;
  for(i=0; i<N; i++){
    if(outlier[i])continue;
    if(y[i]>max){outlier[i]=1; n++;}
  }
  return(n);
}

// Assembly:
testl %edx, %edx
jle 0x2a81c
movl %edx, %ecx
xorpd %xmm1, %xmm1
xorl %eax, %eax
xorps %xmm2, %xmm2
cvtss2sd (%rsi,%rax,4), %xmm2
addsd %xmm2, %xmm1
incq %rax
cmpq %rax, %rcx
jne 0x2a7c4
testl %edx, %edx
jle 0x2a81c
cvtss2sd %xmm0, %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x0, (%rdi,%rdx,4)
jne 0x2a813
movss (%rsi,%rdx,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2a813
movl $0x1, (%rdi,%rdx,4)
incl %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x2a7fa
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/Fit_B_factors.c
// Function: Find_outliers_Z
int Find_outliers_Z(int *outlier, float *y, int N, float sig){
  double y1=0, y2=0; float *yy=y; int i;
  for(i=0; i<N; i++){
    y1+=*yy; y2+=(*yy)*(*yy); yy++;
  }
  y1/=N; y2=y2-N*y1*y1; if(N>1)y2=sqrt(y2/(N-1));
  float max=y1+sig*y2, min=y1-sig*y2; int n=0;
  for(i=0; i<N; i++){
    if(outlier[i])continue;
    if((y[i]>max)||(y[i]<min)){outlier[i]=1; n++;}
  }
  return(n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, %xmm3
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x2a862
xorl %eax, %eax
movss (%rbx,%rax,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
incq %rax
cmpl %eax, %r12d
jne 0x2a844
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
cmpl $0x2, %r15d
jl 0x2a8c4
leal -0x1(%r15), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2a8a7
sqrtsd %xmm0, %xmm0
jmp 0x2a8c4
movss %xmm3, 0xc(%rsp)
movapd %xmm2, 0x10(%rsp)
callq 0x22a0
movapd 0x10(%rsp), %xmm2
movss 0xc(%rsp), %xmm3
testl %r15d, %r15d
jle 0x2a919
xorps %xmm1, %xmm1
cvtss2sd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
subsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
xorl %ecx, %ecx
xorl %eax, %eax
cmpl $0x0, (%r14,%rcx,4)
jne 0x2a90f
movss (%rbx,%rcx,4), %xmm2
ucomiss %xmm0, %xmm2
ja 0x2a905
ucomiss %xmm2, %xmm1
jbe 0x2a90f
movl $0x1, (%r14,%rcx,4)
incl %eax
incq %rcx
cmpq %rcx, %r12
jne 0x2a8ef
jmp 0x2a91b
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/Fit_B_factors.c
// Function: Fit_no_outliers
float Fit_no_outliers(int *outlier, float *XX, float *YY, int N,
		      float *slope, float *offset)
{
  int k=0; float X[N], Y[N];
  for(int i=0; i<N; i++){
    if(outlier[i])continue;
    X[k]=XX[i]; Y[k]=YY[i]; k++;
  }
  float r=Corr_coeff(X, Y, k, slope, offset);
  return(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsp, %rax
leaq 0xf(,%rbx,4), %r10
andq $-0x10, %r10
subq %r10, %rax
movq %rax, %rsp
movq %rsp, %r11
subq %r10, %r11
movq %r11, %rsp
testl %ecx, %ecx
jle 0x2a982
xorl %ecx, %ecx
xorl %r10d, %r10d
cmpl $0x0, (%rdi,%rcx,4)
jne 0x2a978
movss (%rsi,%rcx,4), %xmm0
movslq %r10d, %r10
movss %xmm0, (%rax,%r10,4)
movss (%rdx,%rcx,4), %xmm0
movss %xmm0, (%r11,%r10,4)
incl %r10d
incq %rcx
cmpq %rcx, %rbx
jne 0x2a956
jmp 0x2a985
xorl %r10d, %r10d
movq %rax, %rdi
movq %r11, %rsi
movl %r10d, %edx
movq %r8, %rcx
movq %r9, %r8
callq 0x108db
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/confchange.c
// Function: Select_cc2
int Select_cc2(float *dx2, int nres1, float *Dcart, atom *atoms1,
	       struct Reference Ref, char *name)
{
  int n=0, i, j;
  for(i=0; i<Ref.N_ref; i++){
    if(strncmp(atoms1[Ref.atom_num[i]].name, name, 2)!=0)continue;
    float *Dc=Dcart+3*i; double d2=0;
    for(j=0; j<3; j++){d2+=(*Dc)*(*Dc); Dc++;}
    dx2[n]=d2; n++;
    if(n > nres1){
      printf("ERROR in Select_cc2, too many %s atoms > %d residues\n",
	     name, nres1); return(0);
    }
  }
  if(n!=nres1){
    printf("WARNING in Select_cc2, %d %s atoms but %d residues\n",
	   n, name, nres1);
  }
  return(n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, 0x10(%rsp)
movslq 0x50(%rsp), %r13
testq %r13, %r13
jle 0x2d62c
movq %rcx, %r15
movq %rdx, %r12
leaq 0x50(%rsp), %rax
movq 0x28(%rax), %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
movslq (%rbx,%r14,4), %rax
imulq $0x70, %rax, %rax
leaq (%r15,%rax), %rdi
addq $0x18, %rdi
movl $0x2, %edx
movq 0x8(%rsp), %rsi
callq 0x2070
testl %eax, %eax
jne 0x2d61e
xorpd %xmm0, %xmm0
xorl %eax, %eax
movss (%r12,%rax,4), %xmm1
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpl $0x3, %eax
jne 0x2d5eb
cvtsd2ss %xmm0, %xmm0
movslq %ebp, %rax
movq 0x10(%rsp), %rcx
movss %xmm0, (%rcx,%rax,4)
cmpl 0x4(%rsp), %ebp
jge 0x2d651
incl %ebp
incq %r14
addq $0xc, %r12
cmpq %r13, %r14
jne 0x2d5c2
jmp 0x2d62e
xorl %ebp, %ebp
movl 0x4(%rsp), %ecx
cmpl %ecx, %ebp
jne 0x2d63a
movl %ecx, %ebp
jmp 0x2d66a
leaq 0x2d3a1(%rip), %rdi     # 0x5a9e2
movl %ebp, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x20f0
jmp 0x2d66a
leaq 0x2d354(%rip), %rdi     # 0x5a9ac
xorl %ebp, %ebp
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x20f0
movl %ebp, %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/confchange.c
// Function: RMSD_CA
float RMSD_CA(float *coord_1, float *coord_2, struct Reference Ref,
	      atom *atoms, int nres, struct ali_atoms ali_atoms)
{
  int n3=3*nres; float coord_CA1[n3], coord_CA2[n3], mass[nres];
  int k=0, n=0;
  for(int i=0; i<ali_atoms.N_ref; i++){
    if(strncmp(atoms[Ref.atom_num[i]].name, "CA", 2))continue;
    int ii=3*i; mass[n]=ali_atoms.mass[i]; n++;
    if(n>nres){printf("ERROR, too many CA atoms\n"); exit(8);}
    for(int j=0; j<3; j++){
      coord_CA1[k]=coord_1[ii]; 
      coord_CA2[k]=coord_2[ii];
      ii++; k++;
    }
  }
  float rmsd=rmsd_mclachlan_f(coord_CA1, coord_CA2, mass, n);
  return(rmsd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
leal (%rcx,%rcx,2), %eax
leaq 0xf(,%rax,4), %r9
andq $-0x10, %r9
movq %rsp, %rax
subq %r9, %rax
movq %rax, %rsp
movq %rsp, %r8
subq %r9, %r8
movq %r8, %rsp
movq %rcx, %rsi
movl %ecx, %r10d
movq %rsp, %rcx
leaq 0xf(,%r10,4), %r10
andq $-0x10, %r10
subq %r10, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movslq 0x58(%rbp), %r10
testq %r10, %r10
jle 0x2eba5
leaq 0x40(%rbp), %rbx
leaq 0x10(%rbp), %r11
movq 0x28(%r11), %r11
movq 0x10(%rbx), %rbx
shlq $0x2, %r10
leaq (%r10,%r10,2), %r14
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %r10d, %r10d
movslq (%r11), %r12
imulq $0x70, %r12, %r12
cmpb $0x43, 0x18(%rdx,%r12)
jne 0x2eb8e
addq %rdx, %r12
addq $0x18, %r12
cmpb $0x41, 0x1(%r12)
jne 0x2eb8e
movss (%rbx), %xmm0
movslq %r10d, %r12
movq -0x30(%rbp), %rcx
movss %xmm0, (%rcx,%r12,4)
cmpl %esi, %r12d
jge 0x2ebcd
movq %r15, %r12
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %r12
movq -0x38(%rbp), %rcx
leaq (%rcx,%r12), %r9
addq %rdi, %r12
incl %r10d
movslq %r13d, %r13
movl 0x8(%r12), %ecx
movl %ecx, 0x8(%rax,%r13,4)
movq (%r12), %rcx
movq %rcx, (%rax,%r13,4)
movl 0x8(%r9), %ecx
movl %ecx, 0x8(%r8,%r13,4)
movq (%r9), %rcx
movq %rcx, (%r8,%r13,4)
addl $0x3, %r13d
addq $0xc, %r15
addq $0x4, %rbx
addq $0x4, %r11
cmpq %r15, %r14
jne 0x2eb0f
jmp 0x2eba8
xorl %r10d, %r10d
movq %rax, %rdi
movq %r8, %rsi
movq -0x30(%rbp), %rdx
movl %r10d, %ecx
callq 0x4dfa0
cvtsd2ss %xmm0, %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c153(%rip), %rdi     # 0x5ad27
callq 0x2090
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/confchange.c
// Function: Periodic_angles
int Periodic_angles(double *dphi, struct axe *axe, int n)
{
  float pi=acos(-1), twopi=2*pi; int m=0;
  for(int i=0; i<n; i++){
    if(axe[i].type=='l')continue;
    if((dphi[i]<=pi)&&(dphi[i]>=-pi))continue;
    while(dphi[i]>pi)dphi[i]-=twopi;
    while(dphi[i]<-pi)dphi[i]+=twopi;
    m++;
  }
  printf("%d angles > pi=%.5f changed\n", m, pi);
  return(m);
}

// Assembly:
pushq %rbx
testl %edx, %edx
jle 0x2ee69
movl %edx, %eax
xorl %ecx, %ecx
movapd 0x284ff(%rip), %xmm0    # 0x572f0
movsd 0x2ae87(%rip), %xmm1    # 0x59c80
movsd 0x2ae87(%rip), %xmm2    # 0x59c88
movsd 0x2ae87(%rip), %xmm3    # 0x59c90
movsd 0x2ae87(%rip), %xmm4    # 0x59c98
xorl %ebx, %ebx
imulq $0x158, %rcx, %rdx      # imm = 0x158
cmpb $0x6c, (%rsi,%rdx)
je 0x2ee5f
movsd (%rdi,%rcx,8), %xmm5
movapd %xmm5, %xmm6
andpd %xmm0, %xmm6
ucomisd %xmm6, %xmm1
jae 0x2ee5f
ucomisd %xmm1, %xmm5
jbe 0x2ee48
addsd %xmm2, %xmm5
ucomisd %xmm1, %xmm5
ja 0x2ee39
movsd %xmm5, (%rdi,%rcx,8)
ucomisd %xmm5, %xmm3
jbe 0x2ee5d
addsd %xmm4, %xmm5
ucomisd %xmm5, %xmm3
ja 0x2ee4e
movsd %xmm5, (%rdi,%rcx,8)
incl %ebx
incq %rcx
cmpq %rax, %rcx
jne 0x2ee13
jmp 0x2ee6b
xorl %ebx, %ebx
leaq 0x2bba4(%rip), %rdi     # 0x5aa16
movsd 0x2ae06(%rip), %xmm0    # 0x59c80
movl %ebx, %esi
movb $0x1, %al
callq 0x20f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/confchange.c
// Function: RMS
float RMS(float *v, int n, int *outlier){
  double RMS=0; int m=n;
  for(int i=0; i<n; i++){
    if(outlier && (outlier[i])){m--; continue;}
    RMS+=v[i]*v[i];
  }
  RMS=sqrt(RMS/m);
  return(RMS);
}

// Assembly:
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x2eec1
movl %esi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x2eea6
cmpl $0x0, (%rdx,%rcx,4)
je 0x2eea6
decl %esi
jmp 0x2eeb7
movss (%rdi,%rcx,4), %xmm2
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x2ee97
jmp 0x2eec5
xorpd %xmm0, %xmm0
xorps %xmm2, %xmm2
cvtsi2sd %esi, %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x2eedc
sqrtsd %xmm0, %xmm0
jmp 0x2eee6
pushq %rax
callq 0x22a0
addq $0x8, %rsp
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/confchange.c
// Function: RMSD_confchange
float RMSD_confchange(float cc, float *mode, double *d_phi,
		      float *coord_all, float *coord_new,
		      double *d_phi_opt, int naxes, struct bond *bonds,
		      atom *atoms, int natoms, struct Reference Ref,
		      float *coord_2)
{
  // angular distance
  for(int i=0; i<naxes; i++)d_phi[i]=d_phi_opt[i]+cc*mode[i];
  Set_bonds_measure(bonds, natoms, atoms);
  Build_up(bonds, natoms, d_phi, naxes);
  Put_coord(coord_all, bonds, natoms);
  Write_ref_coord(coord_new, Ref.N_ref, coord_all, Ref.atom_num);
  float rmsd2=rmsd_mclachlan_f(coord_2, coord_new, Ref.mass_atom, Ref.N_ref);
  return(rmsd2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movl 0x50(%rsp), %r12d
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %r14
testl %r9d, %r9d
jle 0x30b8d
movl %ebp, %eax
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
addsd (%r8,%rcx,8), %xmm1
movsd %xmm1, (%r13,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x30b6b
movq %r14, %rdi
movl %r12d, %esi
callq 0x14cf3
movq %r14, %rdi
movl %r12d, %esi
movq %r13, %rdx
movl %ebp, %ecx
callq 0x15083
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x326eb
leaq 0x58(%rsp), %r14
movl (%r14), %ebp
movq 0x28(%r14), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x32d7a
movq 0x10(%r14), %rdx
movq 0x88(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x4dfa0
cvtsd2ss %xmm0, %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/simulation.c
// Function: Set_masses
void Set_masses(float *mass, atom *atoms, int natoms){
  int n=0, i;
  for(i=0; i<natoms; i++){
    //ALIGN
    if(atoms[i].ali==0)continue;
    mass[n] = Mass(atoms+i); n++;
  }
}

// Assembly:
testl %edx, %edx
jle 0x326ea
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
xorl %r12d, %r12d
cmpl $0x0, 0x54(%rbx)
je 0x326d6
movq %rbx, %rdi
callq 0x25a4d
movslq %r12d, %r12
movss %xmm0, (%r14,%r12,4)
incl %r12d
addq $0x70, %rbx
decq %r15
jne 0x326bc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Put_coord
int Put_coord(float *coord_all, struct bond *bonds, int natoms)
{
  float *coord=coord_all; int i;
  for(i=0; i<natoms; i++){
    if(bonds[i].i_atom<0)break;
    for(int j=0; j<3; j++){*coord=bonds[i].r[j]; coord++;}
  }
  return(i);
}

// Assembly:
testl %edx, %edx
jle 0x32738
movl %edx, %eax
movl %edx, %ecx
leaq 0x8(%rsi), %r8
xorl %edx, %edx
leaq (%rdx,%rdx,2), %r9
shlq $0x6, %r9
cmpl $0x0, 0x20(%rsi,%r9)
js 0x3273b
xorl %r9d, %r9d
xorps %xmm0, %xmm0
cvtsd2ss (%r8,%r9,2), %xmm0
movss %xmm0, (%rdi,%r9)
addq $0x4, %r9
cmpq $0xc, %r9
jne 0x3270c
incq %rdx
addq $0xc0, %r8
addq %r9, %rdi
cmpq %rcx, %rdx
jne 0x326f9
retq
xorl %eax, %eax
retq
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Energy_clashes
float Energy_clashes(float *r, int N){
  float dthr=1.2, dthr2=dthr*dthr;
  float dthr_large=7*dthr, dthr2_large=dthr_large*dthr_large;
  int large_skip=10, r_skip=3*large_skip;
  double E_sum=0;
  int i, j, k;
  float *ri=r;
  for(i=0; i<N; i++){
    float *rj=r;
    for(j=0; j<i-3; j++){
      float dd=0, d;
      for(k=0; k<3; k++){
	d=ri[k]-rj[k];
	if(fabs(d)> dthr_large){
	  j+=large_skip; rj+=r_skip; goto next_j;
	}
	if(fabs(d)> dthr)goto next_j;
	dd += d*d;
	if(dd > dthr2_large){
	  j+=large_skip; rj+=r_skip; goto next_j;
	}
	if(dd > dthr2)goto next_j;
      }
      if(dd==0){
	printf("ERROR, zero distance for atoms %d and %d\n", i, j);
	exit(8);
      }else{
	E_sum+=1./(dd*dd*dd);
      }
    next_j: rj+=3;
    }
    ri+=3;
  }
  return(E_sum/N);
}

// Assembly:
pushq %rax
testl %esi, %esi
jle 0x32830
xorl %eax, %eax
xorpd %xmm0, %xmm0
movaps 0x24b8c(%rip), %xmm1    # 0x572e0
movss 0x28614(%rip), %xmm2    # 0x5ad70
movss 0x28610(%rip), %xmm3    # 0x5ad74
movss 0x2860c(%rip), %xmm4    # 0x5ad78
movss 0x28608(%rip), %xmm5    # 0x5ad7c
xorps %xmm6, %xmm6
movsd 0x1e9c9(%rip), %xmm7    # 0x51148
movq %rdi, %rcx
cmpl $0x4, %eax
jb 0x32820
leal -0x3(%rax), %r8d
xorl %edx, %edx
movq %rdi, %r9
xorps %xmm8, %xmm8
xorl %r10d, %r10d
movss (%rcx,%r10,4), %xmm9
subss (%r9,%r10,4), %xmm9
movaps %xmm9, %xmm10
andps %xmm1, %xmm10
ucomiss %xmm2, %xmm10
ja 0x3280a
ucomiss %xmm3, %xmm10
ja 0x32811
mulss %xmm9, %xmm9
addss %xmm9, %xmm8
ucomiss %xmm4, %xmm8
ja 0x3280a
ucomiss %xmm5, %xmm8
ja 0x32811
incq %r10
cmpq $0x3, %r10
jne 0x3279b
ucomiss %xmm6, %xmm8
jne 0x327e2
jnp 0x32845
movaps %xmm8, %xmm9
mulss %xmm8, %xmm9
mulss %xmm8, %xmm9
xorps %xmm8, %xmm8
cvtss2sd %xmm9, %xmm8
movapd %xmm7, %xmm9
divsd %xmm8, %xmm9
addsd %xmm9, %xmm0
jmp 0x32811
addl $0xa, %edx
addq $0x78, %r9
addq $0xc, %r9
incl %edx
cmpl %r8d, %edx
jl 0x32794
addq $0xc, %rcx
incl %eax
cmpl %esi, %eax
jne 0x32782
jmp 0x32834
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rax
retq
leaq 0x2869e(%rip), %rdi     # 0x5aeea
movl %eax, %esi
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Print_PDB
void Print_PDB(FILE *file_out, atom *atoms, int natoms, float *atom_str3,
	       struct residue *seq, int k, float rmsd)
{
  int i, ij=0, j=0; atom *atom1=atoms;
  char aaname3[10]; for(i=0; i<4; i++)aaname3[i]='\0';
  if(k>=0)fprintf(file_out, "MODEL %d RMSD from PDB= %.3f\n", k, rmsd);
  for(i=0; i<natoms; i++){
    //ALIGN
    if(atom1->ali<0){atom1++; continue;}
    int res=atom1->res; Name3(aaname3,seq[res].i_aa);
    if(j < 99999)j++;
    fprintf(file_out,
	    "ATOM  %5d  %3s %3s %c%4s    %8.3f%8.3f%8.3f%6.2f%6.2f\n",
	    j,atom1->name,aaname3,seq[res].chain, seq[res].pdbres,
	    atom_str3[ij],atom_str3[ij+1],atom_str3[ij+2],1.0,
	    atom1->B_factor);
    ij+=3;
    atom1++;
  }
  fprintf(file_out, "ENDMDL\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movl $0x0, 0xc(%rsp)
testl %r9d, %r9d
js 0x328a4
cvtss2sd %xmm0, %xmm0
leaq 0x285e6(%rip), %rsi     # 0x5ae7d
movq %r15, %rdi
movl %r9d, %edx
movb $0x1, %al
callq 0x21a0
testl %ebp, %ebp
jle 0x3295e
addq $0x64, %r12
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpl $0x0, -0x10(%r12)
js 0x32952
movslq (%r12), %rax
shlq $0x5, %rax
movq 0x20(%rsp), %rcx
leaq (%rcx,%rax), %r14
addq $0xd, %r14
movswl 0x7(%r14), %esi
leaq 0xc(%rsp), %rdi
callq 0x26d50
xorl %eax, %eax
cmpl $0x1869f, %r13d         # imm = 0x1869F
setl %al
addl %eax, %r13d
leaq -0x4c(%r12), %rcx
movsbl -0x1(%r14), %r9d
movslq %ebx, %rbx
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbx,4), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rax,%rbx,4), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rax,%rbx,4), %xmm2
xorps %xmm4, %xmm4
cvtss2sd -0x48(%r12), %xmm4
movq %r14, (%rsp)
movq %r15, %rdi
leaq 0x28563(%rip), %rsi     # 0x5ae9b
movl %r13d, %edx
leaq 0xc(%rsp), %r8
movsd 0x1e800(%rip), %xmm3    # 0x51148
movb $0x5, %al
callq 0x21a0
addl $0x3, %ebx
addq $0x70, %r12
decl %ebp
jne 0x328b5
leaq 0x268ed(%rip), %rdi     # 0x59252
movl $0x7, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x2290
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/simulation.c
// Function: Metropolis
int Metropolis(float Ene_tmp, float Ene, float T)
{
  // Initialize random numbers
  if(INIRAN==0){
     INIRAN=1;
     unsigned long iran=randomgenerator();
     InitRandom( (RANDOMTYPE)iran);
     //RANFACTOR=pow(12.0,1/3.0);
  }
  if(Ene_tmp < Ene)return(1);
  float fact=exp((Ene-Ene_tmp)/T);
  //float ran=RandomFloating()*RANFACTOR;
  //if(ran < fact)return(1);
  if(RandomFloating() < fact)return(1);
  return(0);
}

// Assembly:
subq $0x18, %rsp
cmpl $0x0, 0x46b6f(%rip)     # 0x79500
jne 0x329ce
movl $0x1, 0x46b63(%rip)     # 0x79500
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x14(%rsp)
movss %xmm0, 0x10(%rsp)
callq 0x32a14
movq %rax, %rdi
callq 0x503ac
movss 0x10(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movl $0x1, %eax
ucomiss %xmm0, %xmm1
ja 0x32a0f
subss %xmm0, %xmm1
divss %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x22b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %eax, %eax
callq 0x504e7
xorps %xmm1, %xmm1
cvtss2sd 0xc(%rsp), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: randomgenerator
unsigned long randomgenerator(void){

     unsigned long tm;
     time_t seconds;

     time(&seconds);
     srand((unsigned)(seconds % 65536));
     do   /* waiting time equal 1 second */
       tm= clock();
     while (tm/CLOCKS_PER_SEC < (unsigned)(1));
     return((unsigned long) (rand()));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rdi
leal 0xffff(%rdi), %eax
testq %rdi, %rdi
cmovnsl %edi, %eax
andl $0xffff0000, %eax       # imm = 0xFFFF0000
subl %eax, %edi
callq 0x2160
callq 0x20b0
cmpq $0xf4240, %rax          # imm = 0xF4240
jb 0x32a41
callq 0x22c0
cltq
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Extract_dphi
void Extract_dphi(double *d_phi, float **Tors_mode, float *sigma,
		  int N_modes, int N_axes, float factor, long *idum)
{
  float gasdev(long *idum);
  int i, k; float z, coeff;

  for(i=0; i<N_axes; i++)d_phi[i]=0;
  for(k=0; k<N_modes; k++){
    z=gasdev(idum);
    coeff = z*sigma[k];
    double *phi=d_phi; float *mode=Tors_mode[k];
    for(i=0; i<N_axes; i++){*phi += coeff*(*mode); phi++; mode++;}
  }
  for(i=0; i<N_axes; i++)d_phi[i]*=factor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movss %xmm0, 0x4(%rsp)
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movl %r8d, %r13d
testl %r8d, %r8d
jle 0x32a9f
leaq (,%r13,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2110
testl %r15d, %r15d
jle 0x32af3
movl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x5014c
testl %ebp, %ebp
jle 0x32aeb
movq 0x10(%rsp), %rax
mulss (%rax,%r12,4), %xmm0
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movss (%rax,%rcx,4), %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
addsd (%rbx,%rcx,8), %xmm1
movsd %xmm1, (%rbx,%rcx,8)
incq %rcx
cmpl %ecx, %r13d
jne 0x32acc
incq %r12
cmpq %r15, %r12
jne 0x32aaa
testl %ebp, %ebp
jle 0x32b18
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x32b02
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/simulation.c
// Function: Extract_dx
void Extract_dx(float *dx, float **Cart_mode, float *sigma,
		int N_modes, int N_Cart, float factor, long *idum)
{
  float gasdev(long *idum);
  int i, k; float z, coeff;

  for(i=0; i<N_Cart; i++)dx[i]=0;
  for(k=0; k<N_modes; k++){
    z=gasdev(idum);
    coeff = z*sigma[k];
    float *x=dx, *mode=Cart_mode[k];
    for(i=0; i<N_Cart; i++){*x += coeff*(*mode); x++; mode++;}
  }
  for(i=0; i<N_Cart; i++)dx[i]*=factor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movss %xmm0, 0x4(%rsp)
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movl %r8d, %r13d
testl %r8d, %r8d
jle 0x32b6b
leaq (,%r13,4), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2110
testl %r15d, %r15d
jle 0x32bbb
movl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x5014c
testl %ebp, %ebp
jle 0x32bb3
movq 0x10(%rsp), %rax
mulss (%rax,%r12,4), %xmm0
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movss (%rax,%rcx,4), %xmm1
mulss %xmm0, %xmm1
addss (%rbx,%rcx,4), %xmm1
movss %xmm1, (%rbx,%rcx,4)
incq %rcx
cmpl %ecx, %r13d
jne 0x32b98
incq %r12
cmpq %r15, %r12
jne 0x32b76
testl %ebp, %ebp
movss 0x4(%rsp), %xmm1
jle 0x32bdd
xorl %eax, %eax
movss (%rbx,%rax,4), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r13
jne 0x32bc7
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/simulation.c
// Function: Print_seqres
void Print_seqres(FILE *file_out, struct chain *chains, int Nchain)
{
  char aaname3[8]; for(int i=0; i<8; i++)aaname3[i]='\0';
  int line=1;
  for(int i=0; i<Nchain; i++){
    struct chain *ch=chains+i;
    int lines=ch->N_seqres/13+1, k=0;
    for(int l=0; l<lines; l++){
      fprintf(file_out, "SEQRES %3d %c %4d ",
	      line, ch->label, ch->N_seqres);
      for(int j=0; j<13; j++){
	if(k<ch->N_seqres){
	  Name3(aaname3, Code_AA(ch->seqres[k]));
	  fprintf(file_out, " %3s", aaname3);
	}else{
	  fprintf(file_out, "    ");
	}
	k++;
      }
      fprintf(file_out, "\n"); line++;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq $0x0, 0x30(%rsp)
testl %edx, %edx
jle 0x32d30
movq %rdi, %r14
movl %edx, %ecx
movl $0x1, %edx
leaq 0x30(%rsp), %r13
leaq 0x2674b(%rip), %rbx     # 0x5936c
xorl %edi, %edi
movq %rsi, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
imulq $0x70, %rdi, %r12
movl 0x60(%rsi,%r12), %eax
cmpl $-0xc, %eax
jl 0x32d24
movq %rdi, 0x20(%rsp)
addq %rsi, %r12
cltq
imulq $0x4ec4ec4f, %rax, %rax # imm = 0x4EC4EC4F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rax
addl %ecx, %eax
addl %edx, %eax
incl %eax
movl %eax, 0x8(%rsp)
xorl %ebp, %ebp
movsbl 0x34(%r12), %ecx
movl 0x60(%r12), %r8d
movq %r14, %rdi
leaq 0x28256(%rip), %rsi     # 0x5aed2
movq %rdx, 0x28(%rsp)
xorl %eax, %eax
callq 0x21a0
movslq %ebp, %r15
leal 0xd(%r15), %eax
movl %eax, 0xc(%rsp)
movl $0xd, %ebp
movslq 0x60(%r12), %rax
cmpq %rax, %r15
jge 0x32cd1
movq 0x58(%r12), %rax
movsbl (%rax,%r15), %edi
callq 0x1f488
movq %r13, %rdi
movl %eax, %esi
callq 0x26d50
movq %r14, %rdi
leaq 0x28220(%rip), %rsi     # 0x5aee5
movq %r13, %rdx
xorl %eax, %eax
callq 0x21a0
jmp 0x32ce6
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2290
incq %r15
decl %ebp
jne 0x32c98
movl $0xa, %edi
movq %r14, %rsi
callq 0x2140
movq 0x28(%rsp), %rdx
incl %edx
cmpl 0x8(%rsp), %edx
movl 0xc(%rsp), %ebp
jne 0x32c67
movl 0x8(%rsp), %eax
movl %eax, %edx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdi
incq %rdi
cmpq %rcx, %rdi
jne 0x32c2d
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/simulation.c
// Function: Write_ref_coord_atom
void Write_ref_coord_atom(float *coord_ref, int N_ref, atom *atoms,
                          int *atom_num)
{
  float *coord=coord_ref;
  for(int i=0;i<N_ref;i++){
    double *r=atoms[atom_num[i]].r;
    for(int j=0; j<3; j++){*coord=*r; coord++; r++;}
  }
}

// Assembly:
testl %esi, %esi
jle 0x32d79
movl %esi, %eax
xorl %esi, %esi
movslq (%rcx,%rsi,4), %r8
imulq $0x70, %r8, %r9
addq %rdx, %r9
xorl %r8d, %r8d
xorps %xmm0, %xmm0
cvtsd2ss (%r9,%r8,2), %xmm0
movss %xmm0, (%rdi,%r8)
addq $0x4, %r8
cmpl $0xc, %r8d
jne 0x32d55
incq %rsi
addq %r8, %rdi
cmpq %rax, %rsi
jne 0x32d47
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Write_ref_coord
void Write_ref_coord(float *coord_ref, int N_ref, float *coord_all,
		     int *atom_num)
{
  float *coord=coord_ref;
  for(int i=0;i<N_ref;i++){
    float *r=coord_all+3*atom_num[i];
    for(int j=0; j<3; j++){*coord=*r; coord++; r++;}
  }
}

// Assembly:
testl %esi, %esi
jle 0x32db5
movl %esi, %eax
xorl %esi, %esi
movl (%rcx,%rsi,4), %r8d
leal (%r8,%r8,2), %r8d
movslq %r8d, %r8
leaq (%rdx,%r8,4), %r9
xorl %r8d, %r8d
movss (%r9,%r8), %xmm0
movss %xmm0, (%rdi,%r8)
addq $0x4, %r8
cmpl $0xc, %r8d
jne 0x32d94
incq %rsi
addq %r8, %rdi
cmpq %rax, %rsi
jne 0x32d82
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Put_atoms
int Put_atoms(atom *atoms, float *coords, int natoms){
  atom *atom=atoms; float *coord=coords;
  for(int i=0; i<natoms; i++){
    for(int j=0; j<3; j++){atom->r[j]=*coord; coord++;}
    atom++;
  }
  return(0);
}

// Assembly:
testl %edx, %edx
jle 0x32de2
xorl %eax, %eax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtss2sd (%rsi,%rcx), %xmm0
movsd %xmm0, (%rdi,%rcx,2)
addq $0x4, %rcx
cmpq $0xc, %rcx
jne 0x32dbe
addq $0x70, %rdi
incl %eax
addq %rcx, %rsi
cmpl %edx, %eax
jne 0x32dbc
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Copy_bonds
void Copy_bonds(struct bond *bonds1, struct bond *bonds, int natoms)
{
  struct bond *bond1=bonds1, *bond=bonds;
  bond1->previous=NULL;
  for(int i=0; i<natoms; i++){
    *bond1=*bond;
    //if(bond->i_atom<0)break;
    if(i){
      bond1->previous=bonds1+(int)(bond->previous-bonds);
    }
    bond++; bond1++;
  }
}

// Assembly:
movq $0x0, 0x28(%rdi)
testl %edx, %edx
jle 0x3383a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
leaq (%r14,%r12), %rsi
leaq (%r15,%r12), %rdi
movl $0xc0, %edx
callq 0x21b0
testl %ebp, %ebp
je 0x33825
movq 0x28(%r14,%r12), %rax
subq %r14, %rax
shrq $0x6, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
leaq (%rax,%rax,2), %rax
shlq $0x6, %rax
addq %r15, %rax
movq %rax, 0x28(%r15,%r12)
incl %ebp
addq $0xc0, %r12
cmpl %ebp, %ebx
jne 0x337eb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: Copy_atoms_bonds
void Copy_atoms_bonds(atom *atoms, struct bond *bonds, int natoms){
  atom *atom=atoms; struct bond *bond=bonds;
  for(int i=0; i<natoms; i++){
    double *r1=atom->r, *r2=bond->r;
    for(int j=0; j<3; j++){*r1=*r2; r1++; r2++;}
    atom++; bond++;
  }
}

// Assembly:
testl %edx, %edx
jle 0x36927
xorl %eax, %eax
movl $0x1, %ecx
movsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rdi,%rcx,8)
incq %rcx
cmpl $0x4, %ecx
jne 0x36903
addq $0x70, %rdi
addq $0xc0, %rsi
incl %eax
cmpl %edx, %eax
jne 0x368fe
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/simulation.c
// Function: RMSD_LIN
float RMSD_LIN(float *RMSD_target, float *RMSD_full,
	       struct Jacobian *J, float *Delta_phi,
	       struct Reference Ref,
	       float *coord_ref_1, float *coord_ref_2,
	       float *coord_full)
{
  // Compute new conformation
  int N_Cart=3*Ref.N_ref;
  float RMSD=0, coord_lin[N_Cart];
  for(int i=0; i<N_Cart; i++){
    double X=coord_ref_1[i];
    for(int a=0; a<J->N_axes; a++)
      X+=J->Jacobian_ar[a][i]*Delta_phi[a];
    coord_lin[i]=X;
  }
  if(coord_ref_2){
    *RMSD_target=
      rmsd_mclachlan_f(coord_ref_2, coord_lin, Ref.mass_atom, Ref.N_ref);
  }
  if(coord_ref_1){
    RMSD=rmsd_mclachlan_f(coord_ref_1, coord_lin, Ref.mass_atom, Ref.N_ref);
  }
  if(coord_full){
    float coord_ref[N_Cart];
    Write_ref_coord(coord_ref, Ref.N_ref, coord_full, Ref.atom_num);
    *RMSD_full=
      rmsd_mclachlan_f(coord_ref, coord_lin, Ref.mass_atom, Ref.N_ref);
  }
  //printf("RMSD_lin= %.2f (ini) %.2f (end) %.2f (torsional)\n",
  //	 RMSD, *RMSD_target, *RMSD_full);
  return(RMSD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rsi, -0x38(%rbp)
movq %rdi, %r13
movslq 0x10(%rbp), %r14
leal (%r14,%r14,2), %edi
leaq 0xf(,%rdi,4), %rbx
andq $-0x10, %rbx
movq %rsp, %r15
subq %rbx, %r15
movq %r15, %rsp
testq %r14, %r14
jle 0x389c5
movl (%rdx), %eax
cmpl $0x2, %edi
movl $0x1, %esi
cmovgel %edi, %esi
xorl %edi, %edi
movss (%r12,%rdi,4), %xmm0
testl %eax, %eax
jle 0x389b7
cvtss2sd %xmm0, %xmm0
movq 0x10(%rdx), %r8
xorl %r10d, %r10d
movq (%r8,%r10,8), %r11
movss (%r11,%rdi,4), %xmm1
mulss (%rcx,%r10,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r10
cmpq %r10, %rax
jne 0x38993
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r15,%rdi,4)
incq %rdi
cmpq %rsi, %rdi
jne 0x3897e
leaq 0x10(%rbp), %rax
testq %r9, %r9
je 0x389ee
movq 0x10(%rax), %rdx
movq %r9, %rdi
movq %r15, %rsi
movl %r14d, %ecx
callq 0x4dfa0
leaq 0x10(%rbp), %rax
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r13)
movq 0x40(%rbp), %r13
testq %r12, %r12
je 0x38a0f
movq 0x10(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %ecx
callq 0x4dfa0
cvtsd2ss %xmm0, %xmm0
jmp 0x38a12
xorps %xmm0, %xmm0
testq %r13, %r13
je 0x38a92
movss %xmm0, -0x2c(%rbp)
movq %rsp, %r12
movq %rsp, %rdi
subq %rbx, %rdi
movq %rdi, %rsp
testl %r14d, %r14d
leaq 0x10(%rbp), %r9
jle 0x38a6f
movq 0x28(%r9), %rax
xorl %ecx, %ecx
movq %rdi, %rdx
movl (%rax,%rcx,4), %esi
leal (%rsi,%rsi,2), %esi
movslq %esi, %rsi
leaq (,%rsi,4), %r8
addq %r13, %r8
xorl %esi, %esi
movss (%r8,%rsi), %xmm0
movss %xmm0, (%rdx,%rsi)
addq $0x4, %rsi
cmpl $0xc, %esi
jne 0x38a50
incq %rcx
addq %rsi, %rdx
cmpq %r14, %rcx
jne 0x38a3a
movq 0x10(%r9), %rdx
movq %r15, %rsi
movl %r14d, %ecx
callq 0x4dfa0
cvtsd2ss %xmm0, %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, (%rax)
movq %r12, %rsp
movss -0x2c(%rbp), %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/simulation.c
// Function: Test_standard
int Test_standard(struct bond *bonds, int natoms){
  int n=0;
  for(int i=0; i<natoms; i++){
    struct bond *bond=bonds+i;
    if((bond->len>=0)||(bond->angle>=0))continue;  // exclude pseudo-bonds
    if(bond->previous==NULL)continue;
    int na=Atom_type(bond->atom->name);
    if((na<0)||(na>4))continue;
    float d1=bond->l-BB_length[na], d2;
    if(bond->previous->previous){
      d2=bond->r_cos_theta/bond->l-cos(BB_angle[na]);
    }else{
      d2=0;
    }
    if((fabs(d1)>0.01)||(fabs(d2)>0.01)){
      printf("WARNING %c%d %s %.3f %.3f\n",
	     bond->atom->aa, bond->atom->res+1, bond->atom->name, d1, d2);
      n++;
    }
  }
  if(n){
    printf("WARNING, %d errors in standardize bonds\n", n); return(n);
  }
  printf("Standard bonds successfully tested\n");
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x3aad7
movq %rdi, %r14
movl %esi, %eax
shlq $0x6, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
leaq 0x2f4a3(%rip), %rbp     # 0x69e50
leaq 0x2f4bc(%rip), %r15     # 0x69e70
xorl %ebx, %ebx
cmpl $0x0, 0x34(%r14,%r13)
jns 0x3a9c6
cmpl $0x0, 0x38(%r14,%r13)
js 0x3a9d7
addq $0xc0, %r13
cmpq %r13, %r12
jne 0x3a9b6
jmp 0x3aac1
cmpq $0x0, 0x28(%r14,%r13)
je 0x3a9c6
movq (%r14,%r13), %rdi
addq $0x18, %rdi
callq 0xff04
cmpl $0x4, %eax
ja 0x3a9c6
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rbp,%rax,4), %xmm0
movsd 0x58(%r14,%r13), %xmm2
movq 0x28(%r14,%r13), %rcx
cmpq $0x0, 0x28(%rcx)
je 0x3aa5e
movsd 0x60(%r14,%r13), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtss2sd (%r15,%rax,4), %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x2130
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
jmp 0x3aa61
xorps %xmm1, %xmm1
subsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movaps %xmm0, %xmm2
movaps 0x1c876(%rip), %xmm3    # 0x572f0
andps %xmm3, %xmm2
movsd 0x1c8ab(%rip), %xmm4    # 0x57330
ucomisd %xmm4, %xmm2
ja 0x3aa9b
movaps %xmm1, %xmm2
andps %xmm3, %xmm2
ucomisd %xmm4, %xmm2
jbe 0x3a9c6
movq (%r14,%r13), %rcx
movsbl 0x68(%rcx), %esi
movl 0x64(%rcx), %edx
incl %edx
addq $0x18, %rcx
leaq 0x2103d(%rip), %rdi     # 0x5baf0
movb $0x2, %al
callq 0x20f0
incl %ebx
jmp 0x3a9c6
testl %ebx, %ebx
je 0x3aad7
leaq 0x2103f(%rip), %rdi     # 0x5bb0b
movl %ebx, %esi
xorl %eax, %eax
callq 0x20f0
jmp 0x3aae5
leaq 0x21303(%rip), %rdi     # 0x5bde1
callq 0x2090
xorl %ebx, %ebx
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/simulation.c
// Function: Compute_RMSD
float Compute_RMSD(float f, float *Diff_Tors, int naxes,
		   struct bond *bonds_ini, struct bond *bonds, int natoms1,
		   struct Reference Ref1, float *coord_ref_2)
{
  double diff_tors[naxes];
  for(int i=0; i<naxes; i++)diff_tors[i]=f*Diff_Tors[i];
  Copy_bonds(bonds, bonds_ini, natoms1);
  Build_up(bonds, natoms1, diff_tors, naxes);
  float coord_all[3*natoms1];
  Put_coord(coord_all, bonds, natoms1);
  float coord_new[Ref1.N_Cart];
  Write_ref_coord(coord_new, Ref1.N_ref, coord_all, Ref1.atom_num);
  float RMSD=
    rmsd_mclachlan_f(coord_ref_2, coord_new, Ref1.mass_atom, Ref1.N_ref);
  return(RMSD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r13
movl %esi, %r9d
movl %esi, %eax
movq %rsp, %rdx
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
subq %rcx, %rdx
movq %rdx, %rsp
testl %esi, %esi
jle 0x3b052
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3b038
leaq 0x10(%rbp), %r12
movq $0x0, 0x28(%r14)
testl %ebx, %ebx
jle 0x3b13e
movq %rdx, -0x38(%rbp)
movl %r9d, -0x2c(%rbp)
movq %r15, -0x40(%rbp)
xorl %r12d, %r12d
xorl %r15d, %r15d
leaq (%r12,%r13), %rsi
leaq (%r14,%r12), %rdi
movl $0xc0, %edx
callq 0x21b0
testl %r15d, %r15d
je 0x3b0b3
movq 0x28(%r13,%r12), %rax
subq %r13, %rax
shrq $0x6, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
leaq (%rax,%rax,2), %rax
shlq $0x6, %rax
addq %r14, %rax
movq %rax, 0x28(%r14,%r12)
incl %r15d
addq $0xc0, %r12
cmpl %r15d, %ebx
jne 0x3b078
movq %r14, %rdi
movl %ebx, %esi
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x15083
leal (%rbx,%rbx,2), %eax
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movl %ebx, %ecx
leaq 0x8(%r14), %rdx
xorl %esi, %esi
movq %rax, %rdi
movq -0x40(%rbp), %r15
leaq 0x10(%rbp), %r12
leaq (%rsi,%rsi,2), %r8
shlq $0x6, %r8
cmpl $0x0, 0x20(%r14,%r8)
js 0x3b163
xorl %r8d, %r8d
xorps %xmm0, %xmm0
cvtsd2ss (%rdx,%r8,2), %xmm0
movss %xmm0, (%rdi,%r8)
addq $0x4, %r8
cmpq $0xc, %r8
jne 0x3b111
incq %rsi
addq $0xc0, %rdx
addq %r8, %rdi
cmpq %rcx, %rsi
jne 0x3b0fe
jmp 0x3b163
movq %r14, %rdi
movl %ebx, %esi
movl %r9d, %ecx
callq 0x15083
leal (%rbx,%rbx,2), %eax
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movl 0x4(%r12), %ecx
movq %rsp, %rsi
leaq 0xf(,%rcx,4), %rcx
andq $-0x10, %rcx
subq %rcx, %rsi
movq %rsi, %rsp
movslq (%r12), %rcx
testq %rcx, %rcx
jle 0x3b1c3
movq 0x28(%r12), %rdx
xorl %edi, %edi
movq %rsi, %r8
movl (%rdx,%rdi,4), %r9d
leal (%r9,%r9,2), %r9d
movslq %r9d, %r9
leaq (%rax,%r9,4), %r10
xorl %r9d, %r9d
movss (%r10,%r9), %xmm0
movss %xmm0, (%r8,%r9)
addq $0x4, %r9
cmpl $0xc, %r9d
jne 0x3b1a2
incq %rdi
addq %r9, %r8
cmpq %rcx, %rdi
jne 0x3b190
movq 0x10(%r12), %rdx
movq %r15, %rdi
callq 0x4dfa0
cvtsd2ss %xmm0, %xmm0
leaq -0x28(%rbp), %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/force2confchange.c
// Function: Read_force
int Read_force(float *Force_input_cart, atom *atoms1,
	       int *atom_num1, int N_ref, char *FILE_FORCE)
{
  FILE *file_in=fopen(FILE_FORCE, "r");
  int iref=0, res; float f1, f2, f3;
  char name[20], aa1[5], string[1000];
  if(file_in==NULL){
    printf("ERROR, I could not find file with input force %s\n",
	   FILE_FORCE); return(-1);
  }
  while(fgets(string, sizeof(string), file_in)!=NULL){
    sscanf(string, "%s%s%d%f%f%f", name, aa1, &res, &f1, &f2, &f3);
    if(Find_atom_seq1(&iref, name, aa1, res, atoms1,atom_num1, N_ref)<0){
      printf("ERROR, reference number not found for %s", string);
      return(-1);
    }
    Force_input_cart[3*iref]=f1;
    Force_input_cart[3*iref+1]=f2;
    Force_input_cart[3*iref+2]=f3;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %r8, %r15
movq %rdi, %rbx
leaq 0x1e82b(%rip), %rsi     # 0x59e7e
movq %r8, %rdi
callq 0x2220
testq %rax, %rax
je 0x3b6fd
movq %rax, %r14
leaq 0x40(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %rax, %rdx
callq 0x2170
testq %rax, %rax
je 0x3b715
leaq 0x40(%rsp), %r12
leaq 0x14(%rsp), %r13
leaq 0x10(%rsp), %r15
xorl %ebp, %ebp
movq %r12, %rdi
leaq 0x208ac(%rip), %rsi     # 0x5bf49
leaq 0x20(%rsp), %rdx
leaq 0x1b(%rsp), %rcx
movq %r13, %r8
movq %r15, %r9
xorl %eax, %eax
leaq 0x8(%rsp), %r10
pushq %r10
leaq 0x14(%rsp), %r10
pushq %r10
callq 0x2200
addq $0x10, %rsp
movss 0x10(%rsp), %xmm0
movss %xmm0, (%rbx)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rbx)
movq %r12, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdx
callq 0x2170
testq %rax, %rax
jne 0x3b693
jmp 0x3b717
leaq 0x20813(%rip), %rdi     # 0x5bf17
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x3b717
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/mutation.c
// Function: Convert_to_tors
float *Convert_to_tors(float *Cart, int N3, float **J_ar, int N_axes)
{
  // Torsional force = J^t f = sum_i dr_i/dphi_a f_i
  float *Tors=malloc(N_axes*sizeof(float)); int a, i;
  for(a=0; a<N_axes; a++){
    double sum=0; float *J=J_ar[a], *f=Cart;
    for(i=0; i<N3; i++){sum+=(*J)*(*f); J++; f++;}
    Tors[a]=sum;
  }
  return(Tors);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %ecx, %r12
leaq (,%r12,4), %rdi
callq 0x21e0
testl %r12d, %r12d
jle 0x3f5a8
movl %r15d, %ecx
movl %ebp, %edx
xorl %esi, %esi
testl %ebp, %ebp
jle 0x3f598
movq (%rbx,%rsi,8), %rdi
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movss (%rdi,%r8,4), %xmm1
mulss (%r14,%r8,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r8
cmpl %r8d, %edx
jne 0x3f576
cvtsd2ss %xmm0, %xmm0
jmp 0x3f59b
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x3f567
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/mutation.c
// Function: Cosine
float Cosine(float *scale, float *xx, float *yy, int n)
{
  double sum_xy=0, sum_x2=0, sum_y2=0;
  float *x=xx, *y=yy;
  for(int i=0; i<n; i++){
    sum_xy+=(*x)*(*y);
    sum_x2+=(*x)*(*x);
    sum_y2+=(*y)*(*y);
    x++; y++;
  }
  if(sum_x2){
    *scale=sqrt(sum_y2/sum_x2);
    return(sum_xy/sqrt(sum_x2*sum_y2));
  }else{
    *scale=0;
    return(0);
  }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %ecx, %ecx
jle 0x3f620
movl %ecx, %eax
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
xorl %ecx, %ecx
movss (%rdx,%rcx,4), %xmm0
movss (%rsi,%rcx,4), %xmm1
movaps %xmm1, %xmm2
shufps $0x0, %xmm1, %xmm2      # xmm2 = xmm2[0,0],xmm1[0,0]
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm2, %xmm1
cvtps2pd %xmm1, %xmm1
addpd %xmm1, %xmm3
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm4
incq %rcx
cmpl %ecx, %eax
jne 0x3f5c9
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm3
jne 0x3f606
jnp 0x3f620
movapd %xmm4, %xmm0
divsd %xmm3, %xmm0
ucomisd %xmm1, %xmm0
movapd %xmm3, 0x10(%rsp)
jb 0x3f62b
sqrtsd %xmm0, %xmm0
jmp 0x3f642
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
jmp 0x3f67e
movsd %xmm4, 0x8(%rsp)
callq 0x22a0
movsd 0x8(%rsp), %xmm4
movapd 0x10(%rsp), %xmm3
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx)
mulsd %xmm3, %xmm4
xorps %xmm0, %xmm0
ucomisd %xmm0, %xmm4
jb 0x3f660
xorps %xmm0, %xmm0
sqrtsd %xmm4, %xmm0
jmp 0x3f66f
movapd %xmm4, %xmm0
callq 0x22a0
movapd 0x10(%rsp), %xmm3
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
divsd %xmm0, %xmm3
xorps %xmm0, %xmm0
cvtsd2ss %xmm3, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/mutation.c
// Function: Extract_reference_atoms
int Extract_reference_atoms(int *resatom, atom *atoms, int natoms,
			    struct residue *seq, int Nres)
{
  char SEL[4]="CA"; if(strcmp(REF_CC, "CB")==0)strcpy(SEL, "CB");
  int Na=0; 
  // resatom[i]= Reference atom for residue i
  // Center of mass and inertia tensor

  for(int i=0; i<natoms; i++){
    atom *atm=atoms+i;
    if((strncmp(atm->name, SEL, 2)!=0)&&
       ((seq[atm->res].amm!='G')||(strncmp(atm->name, "CA", 2)!=0)))continue;
    resatom[Na]=i; Na++;
  }
  if(Na!=Nres)printf("WARNING, %d residues expected, %d found\n", Nres, Na);
  if(Na > Nres){printf("Leaving\n"); return(0);}
  return(Na);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movl $0x4143, 0x8(%rsp)      # imm = 0x4143
leaq 0x29327(%rip), %rax     # 0x69e94
movzwl (%rax), %ecx
xorl $0x4243, %ecx           # imm = 0x4243
movzbl 0x2(%rax), %eax
orw %cx, %ax
jne 0x40b8b
movb $0x0, 0xa(%rsp)
movw $0x4243, 0x8(%rsp)      # imm = 0x4243
movl %r8d, 0xc(%rsp)
testl %edx, %edx
jle 0x40bf3
movl %edx, %ebx
addq $0x18, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbp
xorl %r13d, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2070
testl %eax, %eax
je 0x40bd6
movslq 0x4c(%r15), %rax
shlq $0x5, %rax
cmpb $0x47, 0x13(%r14,%rax)
jne 0x40be5
cmpb $0x43, (%r15)
jne 0x40be5
cmpb $0x41, 0x1(%r15)
jne 0x40be5
movslq %r13d, %r13
movq 0x10(%rsp), %rax
movl %r12d, (%rax,%r13,4)
incl %r13d
incq %r12
addq $0x70, %r15
cmpq %r12, %rbx
jne 0x40ba5
jmp 0x40bf6
xorl %r13d, %r13d
movl 0xc(%rsp), %ebx
cmpl %ebx, %r13d
je 0x40c12
leaq 0x1b411(%rip), %rdi     # 0x5c017
movl %ebx, %esi
movl %r13d, %edx
xorl %eax, %eax
callq 0x20f0
cmpl %ebx, %r13d
jle 0x40c26
leaq 0x1bfd8(%rip), %rdi     # 0x5cbf6
callq 0x2090
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq