LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Tors_fraction
float Tors_fraction(struct Tors *Diff, float *mass)
{
  double MRR=0, MRT=0, MRW=0, mtot=0; int i;
  // Torsional part / Total
  if(Diff->RMSD==0){
    for(i=0; i<Diff->N_Cart; i++){
      MRR+=mass[i]*Diff->Cart[i]*Diff->Cart[i]; mtot+=mass[i];
    }
    Diff->RMSD=sqrt(MRR/mtot);
    Diff->M=mtot;
  }else{
    mtot=Diff->M; MRR=Diff->M*Diff->RMSD*Diff->RMSD;
  }
  for(i=0; i<Diff->N_axes; i++){
    MRW += Diff->MW_Tors[i]*Diff->MW_Tors[i];
    MRT += Diff->Tors[i]*Diff->Tors[i];
  }
  Diff->RMSD_W=sqrt(MRW/mtot);
  Diff->RMSD_Tors=sqrt(MRT/Diff->N_axes);
  Diff->RMSD_NoTors=sqrt((MRR-MRW)/mtot);
  return(MRW/MRR);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movss 0x30(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x26b30
jp 0x26b30
movslq 0x4(%rbx), %rax
xorps %xmm1, %xmm1
xorpd %xmm4, %xmm4
xorpd %xmm5, %xmm5
testq %rax, %rax
jle 0x26b1c
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm0
movss (%rcx,%rdx,4), %xmm2
xorps %xmm3, %xmm3
cvtss2sd %xmm0, %xmm3
mulss %xmm2, %xmm0
mulss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm4
addsd %xmm3, %xmm5
incq %rdx
cmpq %rdx, %rax
jne 0x26aef
movapd %xmm4, %xmm0
divsd %xmm5, %xmm0
ucomisd %xmm1, %xmm0
jb 0x26b47
sqrtsd %xmm0, %xmm0
jmp 0x26b62
movss 0x3c(%rbx), %xmm1
cvtss2sd %xmm1, %xmm5
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm4
jmp 0x26b77
movsd %xmm4, (%rsp)
movsd %xmm5, 0x8(%rsp)
callq 0x2290
movsd 0x8(%rsp), %xmm5
movsd (%rsp), %xmm4
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%rbx)
xorps %xmm0, %xmm0
cvtsd2ss %xmm5, %xmm0
movss %xmm0, 0x3c(%rbx)
movslq (%rbx), %rax
xorps %xmm1, %xmm1
xorpd %xmm3, %xmm3
xorps %xmm2, %xmm2
testq %rax, %rax
jle 0x26bbd
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm2
movss (%rdx,%rsi,4), %xmm0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm3
incq %rsi
cmpq %rsi, %rax
jne 0x26b93
movapd %xmm2, %xmm0
divsd %xmm5, %xmm0
ucomisd %xmm1, %xmm0
movsd %xmm4, (%rsp)
movsd %xmm5, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
jb 0x26be2
sqrtsd %xmm0, %xmm0
jmp 0x26bf3
movsd %xmm3, 0x18(%rsp)
callq 0x2290
movsd 0x18(%rsp), %xmm3
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x34(%rbx)
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx), %xmm0
divsd %xmm0, %xmm3
xorps %xmm4, %xmm4
ucomisd %xmm4, %xmm3
jb 0x26c19
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x26c25
movapd %xmm3, %xmm0
callq 0x2290
xorps %xmm4, %xmm4
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x38(%rbx)
movapd %xmm1, %xmm0
subsd %xmm3, %xmm0
divsd %xmm2, %xmm0
ucomisd %xmm4, %xmm0
jb 0x26c57
sqrtsd %xmm0, %xmm0
jmp 0x26c67
callq 0x2290
movsd 0x10(%rsp), %xmm3
movsd (%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x2c(%rbx)
divsd %xmm1, %xmm3
xorps %xmm0, %xmm0
cvtsd2ss %xmm3, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Get_rotation
void Get_rotation(double **inertia, double **rotation)
{
  int i, j;
  double **e_vec=Allocate_mat2_d(3,3), e_val[3], det;

  //svdcmp(inertia, 3, 3, e_val, e_vec);
  dd_Diagonalize(3, inertia, e_val, e_vec, 1);

  // Test determinant
  det=
    e_vec[0][0]*(e_vec[1][1]*e_vec[2][2]-e_vec[1][2]*e_vec[2][1])-
    e_vec[0][1]*(e_vec[1][0]*e_vec[2][2]-e_vec[1][2]*e_vec[2][0])+
    e_vec[0][2]*(e_vec[1][0]*e_vec[2][1]-e_vec[1][1]*e_vec[2][0]);
  if(det<0){
    printf("Determinant = %.3f\n", det);
    for(j=0; j<3; j++)e_vec[0][j]=-e_vec[0][j];
  }

  for(i=0; i<3; i++){
    for(j=0; j<3; j++)rotation[i][j]=e_vec[i][j];
  }

  // Clean
  Empty_matrix_d(e_vec, 3);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x3, %edi
movl $0x3, %esi
callq 0x49798
movq %rax, %r14
movq %rsp, %rdx
movl $0x3, %edi
movq %r15, %rsi
movq %rax, %rcx
movl $0x1, %r8d
callq 0x4a819
movq (%r14), %rax
movq 0x8(%r14), %rcx
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
movq 0x10(%r14), %rdx
movsd 0x10(%rdx), %xmm4
movsd 0x10(%rcx), %xmm5
movsd (%rdx), %xmm3
movsd 0x8(%rdx), %xmm6
movapd %xmm1, %xmm2
mulsd %xmm4, %xmm2
mulsd %xmm0, %xmm4
mulsd %xmm6, %xmm0
mulsd %xmm5, %xmm6
mulsd %xmm3, %xmm5
subsd %xmm5, %xmm4
mulsd 0x8(%rax), %xmm4
subsd %xmm6, %xmm2
mulsd (%rax), %xmm2
subsd %xmm4, %xmm2
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm0
mulsd 0x10(%rax), %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2710f
leaq 0x31d37(%rip), %rdi     # 0x58e1b
movb $0x1, %al
callq 0x20f0
movq (%r14), %rax
xorl %ecx, %ecx
movapd 0x29f98(%rip), %xmm0    # 0x51090
movsd (%rax,%rcx,8), %xmm1
xorpd %xmm0, %xmm1
movlpd %xmm1, (%rax,%rcx,8)
incq %rcx
cmpq $0x3, %rcx
jne 0x270f8
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
movq (%rbx,%rax,8), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x2711b
incq %rax
cmpq $0x3, %rax
jne 0x27111
movq %r14, %rdi
movl $0x3, %esi
callq 0x49642
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Center_of_mass
double Center_of_mass(double *r_sum, atom *atoms, int *atom_ref, int N_ref)
{
  int i, j, i_atom; double m_tot=0;
  for(j=0; j<3; j++)r_sum[j]=0;
  for(i_atom=0; i_atom<N_ref; i_atom++){
    i=atom_ref[i_atom];
    double m=Mass(atoms+i), *r=atoms[i].r;
    m_tot+=m; for(j=0; j<3; j++)r_sum[j]+=m*r[j];
  }
  for(j=0; j<3; j++)r_sum[j]/=m_tot;
  return(m_tot);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %ecx, %ecx
jle 0x271cd
movq %rdx, %r14
movq %rsi, %r15
movl %ecx, %r13d
xorps %xmm0, %xmm0
xorl %ebp, %ebp
movsd %xmm0, (%rsp)
movslq (%r14,%rbp,4), %rax
imulq $0x70, %rax, %r12
addq %r15, %r12
movq %r12, %rdi
callq 0x25e79
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
xorl %eax, %eax
movsd (%r12,%rax,8), %xmm1
mulsd %xmm2, %xmm1
addsd (%rbx,%rax,8), %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x2719d
movsd (%rsp), %xmm0
addsd %xmm2, %xmm0
incq %rbp
cmpq %r13, %rbp
jne 0x2717c
jmp 0x271d0
xorps %xmm0, %xmm0
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x271d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Selection
int Selection (char *atom_name, atom *atom, char *SEL){
  if(strncmp(SEL, "ALL", 2)==0){               // All atoms
    if((atom_name[0]=='H')&&(HYD_REF==0)){return(0);}
    else{return(1);}
  }else if(strncmp(SEL, "CB", 2)==0){          // CB
    if(strncmp(atom_name,"CB",2)==0)return(1);
    if((atom->aa=='G')&&(strncmp(atom_name,"CA",2)==0))
      return(1);
  }else if(strncmp(atom_name,"CA",2)==0){      // CA or BB or EB
    return(1);
  }else if(strncmp(SEL, "BB", 2)==0){          // BB: N-CA-C
    if(strncmp(atom_name,"N ",2)==0)return(1);
    if(strncmp(atom_name,"C ",2)==0)return(1);
  }else if(strncmp(SEL, "EB", 2)==0){          // EB: N-CA-CB-C-O
    if(strncmp(atom_name,"N ",2)==0)return(1);
    if(strncmp(atom_name,"C ",2)==0)return(1);
    if(strncmp(atom_name,"O ",2)==0)return(1);
    if(strncmp(atom_name,"CB",2)==0)return(1);
  }
  return(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x29f4e(%rip), %rsi     # 0x5117e
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
je 0x27317
leaq 0x29f78(%rip), %rsi     # 0x511c4
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
je 0x27332
leaq 0x2df02(%rip), %rsi     # 0x5516a
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
movl $0x1, %ebx
testl %eax, %eax
je 0x27392
leaq 0x2b607(%rip), %rsi     # 0x52890
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
je 0x27360
leaq 0x29fbe(%rip), %rsi     # 0x51263
movl $0x2, %edx
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x27390
leaq 0x2ec62(%rip), %rsi     # 0x55f23
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x27392
leaq 0x2ec49(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x27392
leaq 0x2ec30(%rip), %rsi     # 0x55f29
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x27392
leaq 0x29eaf(%rip), %rsi     # 0x511c4
jmp 0x2737f
cmpb $0x48, (%r14)
setne %al
leaq 0x41d3f(%rip), %rcx     # 0x69064
cmpl $0x0, (%rcx)
setne %cl
orb %al, %cl
movzbl %cl, %ebx
jmp 0x27392
leaq 0x29e8b(%rip), %rsi     # 0x511c4
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
movl $0x1, %ebx
testl %eax, %eax
je 0x27392
cmpb $0x47, 0x68(%r12)
jne 0x27390
leaq 0x2de0c(%rip), %rsi     # 0x5516a
jmp 0x2737f
leaq 0x2ebbc(%rip), %rsi     # 0x55f23
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x27392
leaq 0x2eba7(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x27392
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Compute_anisou
void Compute_anisou(float ***aniso_pred, int N_modes, int N_ref,
		    float *one_over_omega2, float **Cart_mode)
{
  // Predicted anisotropic temperature factors
  int ia, i_atom, i, j;
  float *Cmode, Cmode1[3], Cmode2[3];

  for(i_atom=0; i_atom<N_ref; i_atom++){
    int k = 3*i_atom;
    float **anisou=Allocate_mat2_f(3,3);
    aniso_pred[i_atom]=anisou;

    for(ia=0; ia< N_modes; ia++){
      if(one_over_omega2[ia] == 0)continue;
      Cmode=Cart_mode[ia];
      for(i=0; i<3; i++){
	Cmode1[i]=Cmode[k+i];
	Cmode2[i]=Cmode1[i]*one_over_omega2[ia];
	for(j=0; j<=i; j++)anisou[i][j]+=Cmode1[i]*Cmode2[j];
      }
    }
    for(i=0; i<3; i++)for(j=i+1; j<3; j++)anisou[i][j]=anisou[j][i];
  }
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
testl %edx, %edx
jle 0x279af
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movl %edx, %r12d
movl %esi, %r13d
xorl %r15d, %r15d
movl $0x3, %edi
movl $0x3, %esi
callq 0x496ae
xorps %xmm2, %xmm2
movq (%rsp), %rcx
movq %rax, (%rcx,%r15,8)
testl %ebp, %ebp
jle 0x27972
leaq (,%r15,4), %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movss (%r14,%rdx,4), %xmm0
ucomiss %xmm2, %xmm0
jne 0x27912
jnp 0x2796a
movq (%rbx,%rdx,8), %rsi
addq %rcx, %rsi
movl $0x1, %edi
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
movss (%r14,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp,%r8,4)
movq (%rax,%r8,8), %r9
xorl %r10d, %r10d
movss 0xc(%rsp,%r10,4), %xmm1
mulss %xmm0, %xmm1
addss (%r9,%r10,4), %xmm1
movss %xmm1, (%r9,%r10,4)
incq %r10
cmpq %r10, %rdi
jne 0x2793f
incq %r8
incq %rdi
cmpq $0x3, %r8
jne 0x27921
incq %rdx
cmpq %r13, %rdx
jne 0x27905
xorl %ecx, %ecx
cmpq $0x1, %rcx
ja 0x2799a
movq (%rax,%rcx,8), %rdx
movq %rcx, %rsi
movq 0x8(%rax,%rsi,8), %rdi
movss (%rdi,%rcx,4), %xmm0
movss %xmm0, 0x4(%rdx,%rsi,4)
incq %rsi
cmpq $0x2, %rsi
jne 0x27981
incq %rcx
cmpq $0x3, %rcx
jne 0x27974
incq %r15
cmpq %r12, %r15
jne 0x278d9
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/nma.c
// Function: Predict_fluctuations
void Predict_fluctuations(struct Normal_Mode *NM, float *sigma2)
{
  int naxe=NM->N_axes, ncart=NM->N_Cart, i, a;
  double tors_fluct[naxe];
  for(a=0; a<naxe; a++)tors_fluct[a]=0;
  double cart_fluct[ncart];
  for(i=0; i<ncart; i++)cart_fluct[i]=0;
  for(int ia=0; ia< NM->N; ia++){
    if(NM->sigma2[ia]==0)continue;
    float w=sigma2[ia]; //NM->
    float *u=NM->Tors[ia];
    for(a=0; a<naxe; a++){
      tors_fluct[a]+=w*(*u)*(*u); u++;
    }
    float *x=NM->Cart[ia];
    for(i=0; i<ncart; i++){
      cart_fluct[i]+=w*(*x)*(*x); x++;
    }
  }
  // Copy in struct NM
  for(a=0; a<naxe; a++)NM->tors_fluct[a]=tors_fluct[a];
  for(a=0; a<ncart; a++)NM->cart_fluct[a]=cart_fluct[a];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r8
movq %rdi, %rbx
movl 0x8(%rdi), %r12d
movl 0xc(%rdi), %r13d
movq %rsp, %r14
leaq 0xf(,%r12,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testl %r12d, %r12d
jle 0x27a0c
leaq (,%r12,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %r8, %r15
callq 0x2110
movq %r15, %r8
movq %rsp, %r15
leaq 0xf(,%r13,8), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
testl %r13d, %r13d
jle 0x27a40
leaq (,%r13,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %r8, -0x30(%rbp)
callq 0x2110
movq -0x30(%rbp), %r8
movslq (%rbx), %rax
testq %rax, %rax
jle 0x27ae7
movq 0x28(%rbx), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movss (%rcx,%rdx,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x27a61
jnp 0x27adb
movss (%r8,%rdx,4), %xmm1
testl %r12d, %r12d
jle 0x27aa1
movq 0x40(%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %edi, %edi
movss (%rsi,%rdi,4), %xmm2
movaps %xmm1, %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
addsd (%r14,%rdi,8), %xmm2
movsd %xmm2, (%r14,%rdi,8)
incq %rdi
cmpq %rdi, %r12
jne 0x27a76
testl %r13d, %r13d
jle 0x27adb
movq 0x38(%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %edi, %edi
movss (%rsi,%rdi,4), %xmm2
movaps %xmm1, %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
addsd (%r15,%rdi,8), %xmm2
movsd %xmm2, (%r15,%rdi,8)
incq %rdi
cmpq %rdi, %r13
jne 0x27ab0
incq %rdx
cmpq %rax, %rdx
jne 0x27a55
testl %r12d, %r12d
jle 0x27b08
movq 0x50(%rbx), %rax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtsd2ss (%r14,%rcx,8), %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
cmpq %rcx, %r12
jne 0x27af2
testl %r13d, %r13d
jle 0x27b29
movq 0x58(%rbx), %rax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtsd2ss (%r15,%rcx,8), %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
cmpq %rcx, %r13
jne 0x27b13
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/nma.c
// Function: Print_tors_fluct2
void Print_tors_fluct2(struct Normal_Mode NM, struct axe *axe, int naxe,
		       struct residue *res, char *nameout1)
{
  // Print in file
  char namefile[200]="";
  sprintf(namefile, "%s.MSF_tors.dat", nameout1);
  printf("Writing %s\n", namefile);
  FILE *file_out=fopen(namefile, "w");
  fprintf(file_out, "# dof(type, res, chain, _a.a.)\tfluct\n");
  for(int a=0; a<naxe; a++){
    struct residue *r=res+(axe[a].bond)->atom->res;
    fprintf(file_out, "%c%s%c_%c\t%.3g\n",
	    axe[a].type, r->pdbres, r->chain, r->amm, NM.tors_fluct[a]);
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %r12
movl $0xc8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2110
leaq 0x31365(%rip), %rsi     # 0x58ed2
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x2a15a(%rip), %rdi     # 0x51cdb
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x2f6ae(%rip), %rsi     # 0x57240
movq %r12, %rdi
callq 0x2210
movq %rax, %r15
leaq 0x3133e(%rip), %rdi     # 0x58ee2
movl $0x25, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x2280
testl %ebp, %ebp
jle 0x27c1e
leaq 0x100(%rsp), %rax
movq 0x50(%rax), %r13
movl %ebp, %ebp
addq $0x8, %r14
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax), %rax
movslq 0x64(%rax), %rax
shlq $0x5, %rax
movsbl -0x8(%r14), %edx
leaq (%rbx,%rax), %rcx
addq $0xd, %rcx
movsbl -0x1(%rcx), %r8d
movsbl 0x6(%rcx), %r9d
xorps %xmm0, %xmm0
cvtss2sd (%r13,%r12,4), %xmm0
movq %r15, %rdi
leaq 0x31300(%rip), %rsi     # 0x58f08
movb $0x1, %al
callq 0x2190
incq %r12
addq $0x158, %r14            # imm = 0x158
cmpq %r12, %rbp
jne 0x27bcf
movq %r15, %rdi
callq 0x20c0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Set_B_exp
int Set_B_exp(atom *atom, int N_atoms, int N_res, float *B_exp, char *REF){
  int i, nca=0;
  float pi=3.1415, norm=8.0*pi*pi/3.0;
  for(i=0; i<N_atoms; i++){
    if(Selection(atom->name, atom, REF)){
      B_exp[nca]=atom->B_factor/norm; nca++;
      if(nca==N_res)break;
    }
    atom++;
  }
  printf("B factors: %d %s atoms selected\n", nca, REF);
  return(nca);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
testl %esi, %esi
jle 0x27c99
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r13
addq $0x18, %r13
xorl %r14d, %r14d
leaq -0x18(%r13), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x27218
testl %eax, %eax
je 0x27c8e
movss 0x4(%r13), %xmm0
divss 0x31083(%rip), %xmm0    # 0x58d00
movslq %r14d, %r14
movss %xmm0, (%r15,%r14,4)
incl %r14d
cmpl %ebp, %r14d
je 0x27c9c
addq $0x70, %r13
decl %r12d
jne 0x27c5c
jmp 0x27c9c
xorl %r14d, %r14d
leaq 0x31275(%rip), %rdi     # 0x58f18
movl %r14d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x20f0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Set_anisou
void Set_anisou(atom *atom, int N_atoms, int nca,
		float ***anisou, float ***aniso_pred, char *REF)
{
  int i_atom, i, j, ica=0;

  for(i_atom=0; i_atom<N_atoms; i_atom++){
    if(Selection(atom->name, atom, REF)){
      anisou[ica]=malloc(3*sizeof(float *));
      aniso_pred[ica]=malloc(3*sizeof(float *));
      for(i=0; i<3; i++){
	aniso_pred[ica][i]=malloc(3*sizeof(float));
	anisou[ica][i]=malloc(3*sizeof(float));
	for(j=0; j<3; j++)anisou[ica][i][j]=atom->anisou[i][j];
      }
      ica++; if(ica==nca)break;
    }
    atom++;
  }
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x10(%rsp)
movl %edx, 0x4(%rsp)
movl %esi, 0x8(%rsp)
testl %esi, %esi
jle 0x27dbd
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
leaq 0x20(%rdi), %rbp
xorl %ebx, %ebx
xorl %r12d, %r12d
leaq 0x18(%r13), %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0x27218
testl %eax, %eax
je 0x27da7
movl %r12d, 0xc(%rsp)
movl $0x18, %edi
callq 0x21d0
movq %rbx, 0x18(%rsp)
movslq %ebx, %rbx
movq %rax, (%r15,%rbx,8)
movl $0x18, %edi
callq 0x21d0
movq %rax, (%r14,%rbx,8)
movq %rbp, 0x20(%rsp)
xorl %r12d, %r12d
movl $0xc, %edi
callq 0x21d0
movq (%r14,%rbx,8), %rcx
movq %rax, (%rcx,%r12,8)
movl $0xc, %edi
callq 0x21d0
movq (%r15,%rbx,8), %rcx
movq %rax, (%rcx,%r12,8)
movq (%r15,%rbx,8), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movss (%rbp,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x27d6f
incq %r12
addq $0xc, %rbp
cmpq $0x3, %r12
jne 0x27d41
movq 0x18(%rsp), %rbx
incl %ebx
cmpl 0x4(%rsp), %ebx
movq 0x20(%rsp), %rbp
movl 0xc(%rsp), %r12d
je 0x27dbd
addq $0x70, %r13
incl %r12d
addq $0x70, %rbp
cmpl 0x8(%rsp), %r12d
jne 0x27cf7
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/nma.c
// Function: f_sort
void f_sort(float d[], int n, int *i_rank)
{
  // Sort the vector d from large to small.
  // Returns i_rank[i]= index of object at rank i
  int k,j,i, jmax, *not_ranked=malloc(n*sizeof(int));
  float d_max;

  for (i=0; i<n; i++)not_ranked[i]=1;
  for (k=0; k<n; k++) {
    for(i=0; i<n; i++)if(not_ranked[i])break;
    d_max=d[jmax=i];
    for (j=i+1;j<n; j++){
      if(not_ranked[j]&&(d[j] >= d_max))d_max=d[jmax=j];
    }
    i_rank[k]=jmax; not_ranked[jmax]=0;
  }
  free(not_ranked);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r15
leaq (,%r15,4), %rdi
callq 0x21d0
movl %r15d, %ecx
testl %r15d, %r15d
jle 0x28249
xorl %edx, %edx
movl $0x1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x2823a
testl %ebp, %ebp
jle 0x282b7
xorl %edx, %edx
xorl %esi, %esi
cmpl $0x0, (%rax,%rsi,4)
jne 0x28261
incq %rsi
cmpq %rsi, %rcx
jne 0x28251
movl %ecx, %esi
leal 0x1(%rsi), %edi
cmpl %ebp, %edi
jge 0x282a2
movl %esi, %edi
leaq (%r14,%rdi,4), %r8
movss (%r8), %xmm0
leaq (%rax,%rdi,4), %r9
movl $0x1, %r10d
cmpl $0x0, (%r9,%r10,4)
je 0x28296
movss (%r8,%r10,4), %xmm1
ucomiss %xmm0, %xmm1
jb 0x28296
leal (%rdi,%r10), %esi
movaps %xmm1, %xmm0
incq %r10
leal (%rdi,%r10), %r11d
cmpl %ebp, %r11d
jl 0x2827d
movl %esi, (%rbx,%rdx,4)
movslq %esi, %rsi
movl $0x0, (%rax,%rsi,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x2824f
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Print_B
void Print_B(float *B, int nca, FILE *file_out, char *model, float cc)
{
  int i;
  fprintf(file_out, "# B factors: %s, corr.=%.3f\n", model, cc);
  for(i=0; i<nca; i++)fprintf(file_out, "%3d\t%7.3f\n", i, B[i]);
  fprintf(file_out, "&\n"); fflush(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
leaq 0x30b20(%rip), %rsi     # 0x591ac
movq %rdx, %rdi
movq %rcx, %rdx
movb $0x1, %al
callq 0x2190
testl %ebp, %ebp
jle 0x286cb
movl %ebp, %r13d
xorl %r15d, %r15d
leaq 0x30b1f(%rip), %r12     # 0x591c9
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r15,4), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movb $0x1, %al
callq 0x2190
incq %r15
cmpq %r15, %r13
jne 0x286aa
leaq 0x2fa59(%rip), %rdi     # 0x5812b
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2280
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Compute_force
void Compute_force(struct Tors *Force, float *cc, struct Normal_Mode NM)
{
  // Compute force from projection of conformation change on normal modes
  int i, a;
  Force->Cart=malloc(NM.N_Cart*sizeof(float));
  for(i=0; i<NM.N_Cart; i++)Force->Cart[i]=0;
  Force->Tors=malloc(NM.N_axes*sizeof(float));
  Force->MW_Tors=malloc(NM.N_axes*sizeof(float));
  for(i=0; i<NM.N_axes; i++){Force->Tors[i]=0; Force->MW_Tors[i]=0;}
  Force->coeff=malloc(NM.N*sizeof(float));
  for(a=0; a<NM.N_relevant; a++){
    if((NM.select[a]==0)||(NM.sigma2[a]==0))continue;
    float c=NM.omega2[a]*cc[a];
    float *x=NM.Cart[a], *u=NM.Tors[a], *w=NM.MW_Tors[a];
    for(i=0; i<NM.N_Cart; i++){Force->Cart[i]+=c*(*x); x++;}
    for(i=0; i<NM.N_axes; i++){
      Force->Tors[i]+=c*(*u); u++;
      Force->MW_Tors[i]+=c*(*w); w++;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %r13
leaq 0x60(%rsp), %r12
movslq 0xc(%r12), %rbx
leaq (,%rbx,4), %r15
movq %r15, %rdi
callq 0x21d0
movq %rax, %r14
movq %rax, 0x8(%r13)
movq %rbx, (%rsp)
testq %rbx, %rbx
jle 0x29628
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2110
movslq 0x8(%r12), %rbx
leaq (,%rbx,4), %rbp
movq %rbp, %rdi
callq 0x21d0
movq %rax, %r15
movq %rax, 0x18(%r13)
movq %rbp, %rdi
callq 0x21d0
movq %rax, %r12
movq %rax, 0x10(%r13)
testq %rbx, %rbx
jle 0x29672
movq %r15, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2110
movq %r12, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2110
leaq 0x60(%rsp), %rbp
movslq (%rbp), %rdi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, 0x20(%r13)
movslq 0x10(%rbp), %rax
testq %rax, %rax
jle 0x29780
movq 0xc0(%rbp), %rcx
movq 0x20(%rbp), %rdx
movq %rdx, 0x18(%rsp)
movq 0x28(%rbp), %rsi
movq 0x38(%rbp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x40(%rbp), %rdx
movq %rdx, 0x10(%rsp)
movq 0x48(%rbp), %r9
movl (%rsp), %r10d
movl %ebx, %r11d
xorl %r13d, %r13d
xorps %xmm0, %xmm0
cmpl $0x0, (%rcx,%r13,4)
je 0x29774
movss (%rsi,%r13,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x296e8
jnp 0x29774
movq 0x18(%rsp), %rdx
movss (%rdx,%r13,4), %xmm1
movq 0x20(%rsp), %rdx
mulss (%rdx,%r13,4), %xmm1
movq 0x10(%rsp), %rdx
movq (%rdx,%r13,8), %rbp
movq (%r9,%r13,8), %rdi
cmpl $0x0, (%rsp)
jle 0x2973b
movq 0x8(%rsp), %rdx
movq (%rdx,%r13,8), %rdx
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm2
mulss %xmm1, %xmm2
addss (%r14,%r8,4), %xmm2
movss %xmm2, (%r14,%r8,4)
incq %r8
cmpq %r8, %r10
jne 0x2971d
testl %ebx, %ebx
jle 0x29774
xorl %edx, %edx
movss (%rbp,%rdx,4), %xmm2
mulss %xmm1, %xmm2
addss (%r15,%rdx,4), %xmm2
movss %xmm2, (%r15,%rdx,4)
movss (%rdi,%rdx,4), %xmm2
mulss %xmm1, %xmm2
addss (%r12,%rdx,4), %xmm2
movss %xmm2, (%r12,%rdx,4)
incq %rdx
cmpq %rdx, %r11
jne 0x29741
incq %r13
cmpq %rax, %r13
jne 0x296cc
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/nma.c
// Function: Cartesian_force
void Cartesian_force(float *Cart_force, float *atom_diff,
		     double **Hessian,int N_Cart)
{
  int i, j;
  for(i=0; i<N_Cart; i++){
    double sum=0;
    for(j=0; j<N_Cart; j++)sum+=Hessian[i][j]*atom_diff[j];
    Cart_force[i]=sum;
  }
}

// Assembly:
testl %ecx, %ecx
jle 0x297ce
movl %ecx, %eax
xorl %ecx, %ecx
movq (%rdx,%rcx,8), %r8
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
xorps %xmm1, %xmm1
cvtss2sd (%rsi,%r9,4), %xmm1
mulsd (%r8,%r9,8), %xmm1
addsd %xmm1, %xmm0
incq %r9
cmpq %r9, %rax
jne 0x297a2
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi,%rcx,4)
incq %rcx
cmpq %rax, %rcx
jne 0x29797
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Torsional_force
void Torsional_force(struct Tors Force, struct Tors *Diff, double **Hessian,
		     int N_axes, int N_ref, int *atom_num,
		     float **Jacobian_ar, int N_int,
		     struct interaction *Int_list, atom *atoms, int natoms)
{
  int N_Cart=3*N_ref, i, j, a; double sum;
  for(i=0; i<N_axes; i++){
    sum=0;
    for(j=0; j<N_axes; j++)sum += Hessian[i][j]*Diff->MW_Tors[j];
    Force.Tors[i]=sum;
  }
  // Cartesian force fr= HrJDelta_theta
  float dr[N_Cart];
  for(i=0; i<N_Cart; i++){
    sum=0; for(a=0; a<N_axes; a++)sum+=Jacobian_ar[a][i]*Diff->Tors[a];
    dr[i]=sum;
  }
  double **H=Allocate_mat2_d(N_Cart, N_Cart);
  Compute_Hessian_ANM(H,N_ref,atom_num,Int_list,N_int,atoms,natoms);
  for(i=0; i<N_Cart; i++){
    sum=0; for(j=0; j<N_Cart; j++)sum += H[i][j]*dr[j];
    Force.Cart[i]=sum;
  }
  Empty_matrix_d(H, N_Cart);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x50(%rbp)
movl %ecx, %r14d
movl 0x68(%rbp), %eax
movq %rax, -0x48(%rbp)
movq 0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x50(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq 0x10(%rbp), %r13
leal (%r14,%r14,2), %ebx
movl %edx, %eax
testl %edx, %edx
jle 0x29855
movq 0x18(%r13), %rcx
movq 0x10(%rdi), %r8
xorl %r10d, %r10d
movq (%rsi,%r10,8), %r11
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
xorps %xmm1, %xmm1
cvtss2sd (%r8,%r15,4), %xmm1
mulsd (%r11,%r15,8), %xmm1
addsd %xmm1, %xmm0
incq %r15
cmpq %r15, %rax
jne 0x29828
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%r10,4)
incq %r10
cmpq %rax, %r10
jne 0x2981d
movl %ebx, %ecx
movq %rsp, %r15
leaq 0xf(,%rcx,4), %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
testl %r14d, %r14d
jle 0x298c3
cmpl $0x2, %ebx
movl $0x1, %ecx
cmovgel %ebx, %ecx
xorl %esi, %esi
testl %edx, %edx
jle 0x298b2
movq 0x18(%rdi), %r8
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movq (%r9,%r10,8), %r11
movss (%r11,%rsi,4), %xmm1
mulss (%r8,%r10,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r10
cmpq %r10, %rax
jne 0x2988c
cvtsd2ss %xmm0, %xmm0
jmp 0x298b5
xorps %xmm0, %xmm0
movss %xmm0, (%r15,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x2987e
movl %ebx, %edi
movl %ebx, %esi
callq 0x49798
movq %rax, %r12
subq $0x8, %rsp
movq %rax, %rdi
movl %r14d, %esi
movq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movq -0x40(%rbp), %r9
pushq -0x48(%rbp)
callq 0x240b1
addq $0x10, %rsp
testl %r14d, %r14d
jle 0x2993f
movq 0x8(%r13), %rax
cmpl $0x2, %ebx
movl $0x1, %ecx
cmovgel %ebx, %ecx
xorl %edx, %edx
movq (%r12,%rdx,8), %rsi
xorps %xmm0, %xmm0
xorl %edi, %edi
xorps %xmm1, %xmm1
cvtss2sd (%r15,%rdi,4), %xmm1
mulsd (%rsi,%rdi,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rcx
jne 0x29914
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rdx,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x2990b
movq %r12, %rdi
movl %ebx, %esi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x49642
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Compute_Max_dev
float Compute_Max_dev(float *Cart_mode, float omega2, int N_Cart,
		      float *mass_sqrt)
{
  float Max_dev=0; int i;
  for(i=0; i< N_Cart; i++){
    float x=fabs(Cart_mode[i]); //*mass_sqrt[i];
    if(x>Max_dev)Max_dev=x;
  }
  return(Max_dev/sqrt(omega2));
}

// Assembly:
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
testl %esi, %esi
jle 0x2998b
movl %esi, %eax
xorps %xmm2, %xmm2
xorl %ecx, %ecx
movaps 0x2d9b0(%rip), %xmm3    # 0x57320
movaps %xmm2, %xmm4
movss (%rdi,%rcx,4), %xmm2
andps %xmm3, %xmm2
maxss %xmm4, %xmm2
incq %rcx
cmpq %rcx, %rax
jne 0x29970
cvtss2sd %xmm2, %xmm2
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x2999b
sqrtsd %xmm0, %xmm0
jmp 0x299af
pushq %rax
movsd %xmm2, (%rsp)
callq 0x2290
movsd (%rsp), %xmm2
addq $0x8, %rsp
divsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/nma.c
// Function: Tors_outliers
void Tors_outliers(int *outlier_tors, int naxe, int *outlier, int Na,
		   struct axe *axe, struct chain *chains, int Nchain)
{
  int a=0, a_ini=0;
  for(a=0; a<naxe; a++)outlier_tors[a]=0;
  for(int c=0; c<Nchain; c++){
    struct chain *ch=chains+c;
    int i=ch->ini_res, end_res=ch->ini_res+ch->nres-1;
    while(1){
      if((outlier[i]==0)&&(outlier[i+1]==0))break;
      while(1){
	int a=Get_tors(axe, naxe, i, a_ini);
	if(a>=0){outlier_tors[a]=1; a_ini=a+1;}
	else{break;}
      }
      i++; if(i>=end_res)break;
    }
    i=end_res;
    while(1)
    	{if((outlier[i]==0)&&(outlier[i-1]==0))break;
      	 while(1){
			int a=Get_tors(axe, naxe, i, a_ini);
			if(a>=0){outlier_tors[a]=1; a_ini=a+1;}
			else{break;}
      		}
      	i--;
      	if(i<=ch->ini_res)break;
    	}
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl 0x50(%rsp), %r13d
testl %esi, %esi
jle 0x299f2
movl %ebp, %edx
shlq $0x2, %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2110
testl %r13d, %r13d
jle 0x29b33
movslq %ebp, %rax
movl %r13d, %ecx
movq %rcx, 0x8(%rsp)
addq $0x8, %r14
xorl %edx, %edx
xorl %ecx, %ecx
imulq $0x70, %rdx, %rsi
movq 0x10(%rsp), %r8
leaq (%r8,%rsi), %rdi
movslq 0x18(%r8,%rsi), %r9
movl 0x1c(%r8,%rsi), %esi
addl %r9d, %esi
decl %esi
movslq %esi, %r8
cmpl $0x0, (%r15,%r9,4)
jne 0x29a3c
cmpl $0x0, 0x4(%r15,%r9,4)
je 0x29aa7
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmpl %ebp, %ecx
jge 0x29a86
movslq %ecx, %r13
imulq $0x158, %r13, %r11      # imm = 0x158
incq %r13
addq %r14, %r11
movl %ecx, %esi
movq (%r11), %rbx
movq (%rbx), %rbx
movslq 0x64(%rbx), %rbx
cmpl %r9d, %ebx
je 0x29a83
cmpq %rbx, %r9
jl 0x29a86
incl %esi
leaq 0x1(%r13), %rbx
addq $0x158, %r11            # imm = 0x158
cmpq %rax, %r13
movq %rbx, %r13
jl 0x29a58
jmp 0x29a86
movl %esi, %r10d
testl %r10d, %r10d
js 0x29a9a
movl %r10d, %ecx
movl $0x1, (%r12,%rcx,4)
leal 0x1(%r10), %ecx
testl %r10d, %r10d
jns 0x29a3c
incq %r9
cmpq %r8, %r9
jl 0x29a2d
cmpl $0x0, (%r15,%r8,4)
jne 0x29ab6
cmpl $0x0, -0x4(%r15,%r8,4)
je 0x29b25
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
cmpl %ebp, %ecx
jge 0x29b00
movslq %ecx, %r11
imulq $0x158, %r11, %r10      # imm = 0x158
incq %r11
addq %r14, %r10
movl %ecx, %esi
movq (%r10), %rbx
movq (%rbx), %rbx
movslq 0x64(%rbx), %rbx
cmpl %r8d, %ebx
je 0x29afd
cmpq %rbx, %r8
jl 0x29b00
incl %esi
leaq 0x1(%r11), %rbx
addq $0x158, %r10            # imm = 0x158
cmpq %rax, %r11
movq %rbx, %r11
jl 0x29ad2
jmp 0x29b00
movl %esi, %r9d
testl %r9d, %r9d
js 0x29b14
movl %r9d, %ecx
movl $0x1, (%r12,%rcx,4)
leal 0x1(%r9), %ecx
testl %r9d, %r9d
jns 0x29ab6
decq %r8
movslq 0x18(%rdi), %rsi
cmpq %rsi, %r8
jg 0x29aa7
incq %rdx
cmpq 0x8(%rsp), %rdx
jne 0x29a0e
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/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 0x29b88
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 0x29b89
jg 0x29b88
incl %ecx
addq $0x158, %rdi            # imm = 0x158
leaq 0x1(%r8), %r9
cmpq %rsi, %r8
movq %r9, %r8
jl 0x29b62
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a665
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 0x2a614
jnp 0x2a658
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 0x2a607
cvtsd2ss %xmm0, %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2eeed(%rip), %rsi     # 0x59950
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x2c7c4(%rip), %rsi     # 0x57240
movq %r13, %rdi
callq 0x2210
movq %rax, %r12
leaq 0x2724d(%rip), %rdi     # 0x51cdb
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x2eec8(%rip), %rdi     # 0x59967
movl $0x25, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x2280
testl %ebp, %ebp
jle 0x2ab25
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %r14d
xorl %ebx, %ebx
leaq 0x2eec3(%rip), %r13     # 0x5998d
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbx,4), %xmm0
movq %r12, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x2190
cmpl $0x0, 0xc(%rsp)
jle 0x2ab0e
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 0x2190
incq %rbp
cmpq %rbp, %r14
jne 0x2aaed
movl $0xa, %edi
movq %r12, %rsi
callq 0x2140
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x2aaca
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_O1/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:
movl %edx, %ecx
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x2ab5f
xorl %eax, %eax
xorps %xmm2, %xmm2
cvtss2sd (%rsi,%rax,4), %xmm2
addsd %xmm2, %xmm1
incq %rax
cmpq %rax, %rcx
jne 0x2ab4b
testl %edx, %edx
jle 0x2aba3
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 0x2ab9a
movss (%rsi,%rdx,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2ab9a
movl $0x1, (%rdi,%rdx,4)
incl %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x2ab81
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movapd %xmm0, %xmm3
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
testl %edx, %edx
jle 0x2abf5
xorpd %xmm4, %xmm4
xorl %eax, %eax
xorpd %xmm0, %xmm0
movss (%rbx,%rax,4), %xmm1
xorps %xmm2, %xmm2
cvtss2sd %xmm1, %xmm2
addsd %xmm2, %xmm4
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpl %eax, %r12d
jne 0x2abcf
jmp 0x2abfd
xorpd %xmm0, %xmm0
xorpd %xmm4, %xmm4
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
divsd %xmm1, %xmm4
mulsd %xmm4, %xmm1
mulsd %xmm4, %xmm1
subsd %xmm1, %xmm0
cmpl $0x2, %r15d
jl 0x2ac57
leal -0x1(%r15), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2ac3a
sqrtsd %xmm0, %xmm0
jmp 0x2ac57
movss %xmm3, 0xc(%rsp)
movsd %xmm4, 0x10(%rsp)
callq 0x2290
movsd 0x10(%rsp), %xmm4
movss 0xc(%rsp), %xmm3
testl %r15d, %r15d
jle 0x2acac
xorps %xmm1, %xmm1
cvtss2sd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addsd %xmm4, %xmm0
cvtsd2ss %xmm0, %xmm0
subsd %xmm1, %xmm4
xorps %xmm1, %xmm1
cvtsd2ss %xmm4, %xmm1
xorl %ecx, %ecx
xorl %eax, %eax
cmpl $0x0, (%r14,%rcx,4)
jne 0x2aca2
movss (%rbx,%rcx,4), %xmm2
ucomiss %xmm0, %xmm2
ja 0x2ac98
ucomiss %xmm2, %xmm1
jbe 0x2aca2
movl $0x1, (%r14,%rcx,4)
incl %eax
incq %rcx
cmpq %rcx, %r12
jne 0x2ac82
jmp 0x2acae
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ad15
xorl %ecx, %ecx
xorl %r10d, %r10d
cmpl $0x0, (%rdi,%rcx,4)
jne 0x2ad0b
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 0x2ace9
jmp 0x2ad18
xorl %r10d, %r10d
movq %rax, %rdi
movq %r11, %rsi
movl %r10d, %edx
movq %r8, %rcx
movq %r9, %r8
callq 0x10d91
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rbp
testq %rbp, %rbp
jle 0x2d935
movq %rcx, %r15
movq %rdx, %r12
leaq 0x50(%rsp), %rax
movq 0x28(%rax), %r13
xorl %ebx, %ebx
xorl %r14d, %r14d
movslq (%r13,%rbx,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 0x2d927
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 0x2d8f2
cvtsd2ss %xmm0, %xmm0
movslq %r14d, %rax
movq 0x10(%rsp), %rcx
movss %xmm0, (%rcx,%rax,4)
cmpl 0x4(%rsp), %r14d
jge 0x2d959
incl %r14d
incq %rbx
addq $0xc, %r12
cmpq %rbp, %rbx
jne 0x2d8c8
jmp 0x2d938
xorl %r14d, %r14d
movl 0x4(%rsp), %ecx
cmpl %ecx, %r14d
je 0x2d973
leaq 0x2d0f6(%rip), %rdi     # 0x5aa3e
movl %r14d, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x20f0
jmp 0x2d973
leaq 0x2d0a8(%rip), %rdi     # 0x5aa08
xorl %r14d, %r14d
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x20f0
movl %r14d, %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/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 $0x48, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
leal (%rcx,%rcx,2), %eax
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
movq %rsp, %rdx
subq %rax, %rdx
movq %rdx, -0x38(%rbp)
movq %rdx, %rsp
movq %rsp, %rdx
subq %rax, %rdx
movq %rdx, -0x30(%rbp)
movq %rdx, %rsp
movq %rcx, -0x58(%rbp)
movl %ecx, %eax
movq %rsp, %rcx
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movslq 0x58(%rbp), %rax
testq %rax, %rax
jle 0x2ee76
leaq 0x40(%rbp), %rcx
leaq 0x10(%rbp), %rdx
movq 0x28(%rdx), %r12
movq 0x10(%rcx), %r13
shlq $0x2, %rax
leaq (%rax,%rax,2), %rax
movq %rax, -0x60(%rbp)
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %ebx, %ebx
movslq (%r12), %rax
imulq $0x70, %rax, %rax
movq -0x68(%rbp), %rcx
leaq (%rcx,%rax), %rdi
addq $0x18, %rdi
movl $0x2, %edx
leaq 0x2637a(%rip), %rsi     # 0x5516a
callq 0x2070
testl %eax, %eax
jne 0x2ee5e
movss (%r13), %xmm0
movslq %ebx, %rax
movq -0x40(%rbp), %rcx
movss %xmm0, (%rcx,%rax,4)
cmpl -0x58(%rbp), %eax
jge 0x2ee9e
movq %r15, %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %rax
movq -0x50(%rbp), %rcx
addq %rax, %rcx
addq -0x48(%rbp), %rax
incl %ebx
movslq %r14d, %r14
movl 0x8(%rax), %edx
movq -0x38(%rbp), %rsi
movl %edx, 0x8(%rsi,%r14,4)
movq (%rax), %rax
movq %rax, (%rsi,%r14,4)
movl 0x8(%rcx), %eax
movq -0x30(%rbp), %rdx
movl %eax, 0x8(%rdx,%r14,4)
movq (%rcx), %rax
movq %rax, (%rdx,%r14,4)
addl $0x3, %r14d
addq $0xc, %r15
addq $0x4, %r13
addq $0x4, %r12
cmpq %r15, -0x60(%rbp)
jne 0x2edd0
jmp 0x2ee78
xorl %ebx, %ebx
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl %ebx, %ecx
callq 0x4e010
cvtsd2ss %xmm0, %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bede(%rip), %rdi     # 0x5ad83
callq 0x2090
movl $0x8, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O1/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 0x2f13d
movl %edx, %eax
xorl %ecx, %ecx
movapd 0x28271(%rip), %xmm0    # 0x57330
movsd 0x2ac11(%rip), %xmm1    # 0x59cd8
movsd 0x2ac11(%rip), %xmm2    # 0x59ce0
movsd 0x2ac11(%rip), %xmm3    # 0x59ce8
movsd 0x2ac11(%rip), %xmm4    # 0x59cf0
xorl %ebx, %ebx
imulq $0x158, %rcx, %rdx      # imm = 0x158
cmpb $0x6c, (%rsi,%rdx)
je 0x2f133
movsd (%rdi,%rcx,8), %xmm5
andpd %xmm0, %xmm5
ucomisd %xmm5, %xmm1
jae 0x2f133
movsd (%rdi,%rcx,8), %xmm5
ucomisd %xmm1, %xmm5
jbe 0x2f117
addsd %xmm2, %xmm5
ucomisd %xmm1, %xmm5
ja 0x2f108
movsd %xmm5, (%rdi,%rcx,8)
movsd (%rdi,%rcx,8), %xmm5
ucomisd %xmm5, %xmm3
jbe 0x2f131
addsd %xmm4, %xmm5
ucomisd %xmm5, %xmm3
ja 0x2f122
movsd %xmm5, (%rdi,%rcx,8)
incl %ebx
incq %rcx
cmpq %rax, %rcx
jne 0x2f0e1
jmp 0x2f13f
xorl %ebx, %ebx
leaq 0x2b92c(%rip), %rdi     # 0x5aa72
movsd 0x2ab8a(%rip), %xmm0    # 0x59cd8
movl %ebx, %esi
movb $0x1, %al
callq 0x20f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2f195
movl %esi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x2f17a
cmpl $0x0, (%rdx,%rcx,4)
je 0x2f17a
decl %esi
jmp 0x2f18b
movss (%rdi,%rcx,4), %xmm2
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x2f16b
jmp 0x2f199
xorpd %xmm0, %xmm0
xorps %xmm2, %xmm2
cvtsi2sd %esi, %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x2f1b0
sqrtsd %xmm0, %xmm0
jmp 0x2f1ba
pushq %rax
callq 0x2290
addq $0x8, %rsp
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30e68
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 0x30e46
movq %r14, %rdi
movl %r12d, %esi
callq 0x1512b
movq %r14, %rdi
movl %r12d, %esi
movq %r13, %rdx
movl %ebp, %ecx
callq 0x154bb
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x32b1e
leaq 0x58(%rsp), %r14
movl (%r14), %ebp
movq 0x28(%r14), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x33198
movq 0x10(%r14), %rdx
movq 0x88(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x4e010
cvtsd2ss %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq