LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Compute_Hessian_INM
void Compute_Hessian_INM (double **Hessian, int N,
			  struct interaction *Int_list, int N_int,
			  atom *atoms)
{
  int i, j, n;

  for(i=0; i<N; i++)for(j=0; j<N; j++)Hessian[i][j]=0;

  for(n=0; n<N_int; n++){
    float h=Int_list[n].sec_der;
    i=(atoms+Int_list[n].i1)->res;
    j=(atoms+Int_list[n].i2)->res;
    Hessian[i][j]=-h; Hessian[j][i]=-h;
    Hessian[i][i]+=h; Hessian[j][j]+=h;
  }
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rdi, %r15
testl %esi, %esi
jle 0x23b46
movl %esi, %r13d
leaq (,%r13,8), %r12
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2110
incq %rbp
cmpq %rbp, %r13
jne 0x23b30
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x23bcc
movl %eax, %eax
imulq $0xc8, %rax, %rax
xorl %ecx, %ecx
movaps 0x2d4d0(%rip), %xmm0    # 0x51030
xorps %xmm1, %xmm1
cvtsd2ss 0x28(%r14,%rcx), %xmm1
movslq (%r14,%rcx), %rdx
imulq $0x70, %rdx, %rdx
movslq 0x64(%rbx,%rdx), %rdx
movslq 0x4(%r14,%rcx), %rsi
imulq $0x70, %rsi, %rsi
movslq 0x64(%rbx,%rsi), %rsi
xorps %xmm2, %xmm2
cvtss2sd %xmm1, %xmm2
xorps %xmm0, %xmm1
movq (%r15,%rdx,8), %rdi
cvtss2sd %xmm1, %xmm1
movsd %xmm1, (%rdi,%rsi,8)
movq (%r15,%rsi,8), %r8
movsd %xmm1, (%r8,%rdx,8)
movsd (%rdi,%rdx,8), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, (%rdi,%rdx,8)
addsd (%r8,%rsi,8), %xmm2
movsd %xmm2, (%r8,%rsi,8)
addq $0xc8, %rcx
cmpq %rcx, %rax
jne 0x23b60
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/nma.c
// Function: Compute_Bfact_INM
int Compute_Bfact_INM(float *B_CA, float *eigen_B, int N,
		      float *eigen_value, float **eigen_vector)
{
  int ia, i; double B, B_ia;
  for(i=0; i<N; i++)eigen_B[i]=0;

  for(i=0; i<N; i++){
    B=0;
    for(ia=0; ia<N; ia++){
      if(eigen_value[ia] < E_MIN)continue;
      B_ia= eigen_vector[ia][i]*eigen_vector[ia][i]/eigen_value[ia];
      B += B_ia; eigen_B[ia]+=B_ia;
    }
    B_CA[i]=B;
  }
  return(0);
}

// Assembly:
testl %edx, %edx
jle 0x23c81
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %r13d
leaq (,%r13,4), %rdx
xorl %ebp, %ebp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2110
leaq 0x454dc(%rip), %rax     # 0x690f4
movss (%rax), %xmm1
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movss (%r14,%rcx,4), %xmm2
ucomiss %xmm2, %xmm1
ja 0x23c59
movq (%rbx,%rcx,8), %rdx
movss (%rdx,%rbp,4), %xmm1
mulss %xmm1, %xmm1
divss %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtss2sd %xmm1, %xmm2
addsd %xmm2, %xmm0
addss (%r15,%rcx,4), %xmm1
movss %xmm1, (%r15,%rcx,4)
movss (%rax), %xmm1
incq %rcx
cmpq %rcx, %r13
jne 0x23c22
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r12,%rbp,4)
incq %rbp
cmpq %r13, %rbp
jne 0x23c18
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Compute_Bfact_ANM
int Compute_Bfact_ANM(float *B_CA, float *eigen_B, float *eigen_value,
		      float **eigen_vector, int N, int N_atoms)
{
  int ia, i_atom, j, k;
  double B, B_ia; float *ev;

  for(ia=0; ia< N; ia++)eigen_B[ia]=0;
  for(i_atom=0; i_atom<N_atoms; i_atom++){
    k = 3*i_atom; B=0;
    for(ia=0; ia< N; ia++){
      if(eigen_value[ia] < E_MIN)continue;
      ev=eigen_vector[ia]+k; B_ia=0;
      for(j=0; j<3; j++){B_ia += (*ev)*(*ev); ev++;}
      B_ia /= eigen_value[ia];
      B += B_ia; eigen_B[ia]+=B_ia;
    }
    B_CA[i_atom]=B;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %r8d, %ebp
testl %r8d, %r8d
jle 0x23f7b
leaq (,%rbp,4), %rdx
movq %r12, %rdi
xorl %esi, %esi
movl %r9d, 0x4(%rsp)
callq 0x2110
movl 0x4(%rsp), %r9d
testl %r9d, %r9d
jle 0x24025
movl %r9d, %eax
xorl %ecx, %ecx
leaq 0x45164(%rip), %rdx     # 0x690f4
xorl %esi, %esi
testl %ebx, %ebx
jle 0x2400b
movss (%rdx), %xmm1
xorpd %xmm0, %xmm0
xorl %edi, %edi
movss (%r15,%rdi,4), %xmm2
ucomiss %xmm2, %xmm1
ja 0x23ffd
movq (%r14,%rdi,8), %r8
addq %rcx, %r8
xorps %xmm1, %xmm1
xorl %r9d, %r9d
movss (%r8,%r9,4), %xmm3
mulss %xmm3, %xmm3
cvtss2sd %xmm3, %xmm3
addsd %xmm3, %xmm1
incq %r9
cmpl $0x3, %r9d
jne 0x23fb8
cvtss2sd %xmm2, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
xorps %xmm2, %xmm2
cvtss2sd (%r12,%rdi,4), %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, (%r12,%rdi,4)
movss (%rdx), %xmm1
incq %rdi
cmpq %rbp, %rdi
jne 0x23fa0
cvtsd2ss %xmm0, %xmm0
jmp 0x2400e
xorps %xmm0, %xmm0
movss %xmm0, (%r13,%rsi,4)
incq %rsi
addq $0xc, %rcx
cmpq %rax, %rsi
jne 0x23f92
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Transform_tors_modes
void Transform_tors_modes(float *Tors_mode, float *Masswtd_Tors_mode,
			  float **T_sqrt_tr, float **T_sqrt_inv_tr,
			  int N_modes, int N_axes)
{
  int ib, j;
  float *Mw_ev=Masswtd_Tors_mode;
  float *ev=Tors_mode;

  if(KINETIC==0){
    for(ib=0; ib<N_modes; ib++){
      *ev=*Mw_ev; ev++; Mw_ev++;
    }
  }else if(T_sqrt_inv_tr){
    // ev= T_sqrt_inv Masswtd_ev
    for(ib=0; ib<N_axes; ib++){
      double sum=0; float *t=T_sqrt_inv_tr[ib];
      Mw_ev=Masswtd_Tors_mode;
      for(j=0; j<N_modes; j++){
	sum+=(*Mw_ev)*(*t); Mw_ev++; t++;
      }
      *ev=sum; ev++;
    }
  }else{
    // Solve (L^t)EV = Mw_EV by backward_substitution
    // x_i =(v_i - sum_j>i L_ji x_j)/L_ii
    double x[N_modes];
    int nn=N_modes-1;
    double *x1=x+nn; Mw_ev=Masswtd_Tors_mode+nn; ev=Tors_mode+nn;
    for(ib=nn; ib>=0; ib--){
      *x1=*Mw_ev; double *x2=x1+1; float *t=T_sqrt_tr[ib]+ib+1;
      for(j=ib+1; j<N_modes; j++){*x1-= (*x2)*(*t); t++; x2++;}
      (*x1)/=T_sqrt_tr[ib][ib];
      *ev=*x1; ev--; Mw_ev--; x1--;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x445bc(%rip), %rax     # 0x68604
cmpl $0x0, (%rax)
je 0x240b2
testq %rcx, %rcx
je 0x240d6
testl %r9d, %r9d
jle 0x2418d
movl %r9d, %eax
movl %r8d, %edx
xorl %r9d, %r9d
testl %r8d, %r8d
jle 0x2409a
movq (%rcx,%r9,8), %r10
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
movss (%rsi,%r11,4), %xmm1
mulss (%r10,%r11,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r11
cmpl %r11d, %edx
jne 0x24078
cvtsd2ss %xmm0, %xmm0
jmp 0x2409d
xorps %xmm0, %xmm0
movss %xmm0, (%rdi)
addq $0x4, %rdi
incq %r9
cmpq %rax, %r9
jne 0x24068
jmp 0x2418d
testl %r8d, %r8d
jle 0x2418d
movl %r8d, %eax
xorl %ecx, %ecx
movss (%rsi,%rcx,4), %xmm0
movss %xmm0, (%rdi,%rcx,4)
incq %rcx
cmpl %ecx, %eax
jne 0x240c0
jmp 0x2418d
movq %rsp, %rax
movl %r8d, %ecx
movq %rsp, %r9
leaq 0xf(,%rcx,8), %r10
andq $-0x10, %r10
subq %r10, %r9
movq %r9, %rsp
testl %r8d, %r8d
jle 0x2418a
decl %r8d
leaq (%rdi,%r8,4), %rdi
leaq (%rsi,%r8,4), %rsi
leaq (%r9,%r8,8), %r9
leaq 0x4(,%r8,4), %r10
xorl %r11d, %r11d
movq %r9, %rbx
xorps %xmm0, %xmm0
cvtss2sd (%rsi), %xmm0
movsd %xmm0, (%rbx)
movq (%rdx,%r8,8), %r14
leaq 0x1(%r8), %r15
cmpq %rcx, %r15
jge 0x24156
leaq (%r14,%r10), %r15
movq %r11, %r12
xorps %xmm1, %xmm1
cvtss2sd (%r15,%r12,4), %xmm1
mulsd 0x8(%r9,%r12,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
incq %r12
testl %r12d, %r12d
jne 0x24136
xorps %xmm1, %xmm1
cvtss2sd (%r14,%r8,4), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi)
addq $-0x4, %rdi
addq $-0x4, %rsi
addq $-0x8, %rbx
leaq -0x1(%r8), %r14
decq %r11
testq %r8, %r8
movq %r14, %r8
jg 0x24117
movq %rax, %rsp
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Transform_tors_modes_old
void Transform_tors_modes_old(float *Tors_mode, float *Masswtd_Tors_mode,
			      double **T_sqrt, double **T_sqrt_inv,
			      int N_modes, int N_axes)
{
  int ib, j;
  float *Mw_ev=Masswtd_Tors_mode;
  float *ev=Tors_mode;

  if(KINETIC==0){
    for(ib=0; ib<N_modes; ib++)ev[ib]=Mw_ev[ib];
  }else if(T_sqrt_inv){
    // ev= T_sqrt_inv Masswtd_ev
    for(ib=0; ib<N_axes; ib++){
      double sum=0;
      for(j=0; j<N_modes; j++)sum+=Mw_ev[j]*T_sqrt_inv[j][ib];
      ev[ib]=sum;
    }
  }else{
    // Solve (L^t)EV = M_EV by backward_substitution
    // x_i =(v_i - sum_j>i L_ji x_j)/L_ii
    double *x=malloc(N_modes*sizeof(double));
    for(ib=N_modes-1; ib>=0; ib--){
      x[ib]=Mw_ev[ib];
      for(j=ib+1; j<N_modes; j++)x[ib]-= x[j]*T_sqrt[j][ib];
      x[ib]/=T_sqrt[ib][ib];
      ev[ib]=x[ib];
    }
    free(x);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x44452(%rip), %rax     # 0x68604
cmpl $0x0, (%rax)
je 0x24209
testq %rcx, %rcx
je 0x2422d
testl %r9d, %r9d
jle 0x24224
movl %r9d, %eax
movl %ebp, %edx
xorl %esi, %esi
testl %ebp, %ebp
jle 0x241f6
xorpd %xmm0, %xmm0
xorl %edi, %edi
xorps %xmm1, %xmm1
cvtss2sd (%rbx,%rdi,4), %xmm1
movq (%rcx,%rdi,8), %r8
mulsd (%r8,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rdx
jne 0x241d2
cvtsd2ss %xmm0, %xmm0
jmp 0x241f9
xorps %xmm0, %xmm0
movss %xmm0, (%r14,%rsi,4)
incq %rsi
cmpq %rax, %rsi
jne 0x241c8
jmp 0x24224
testl %ebp, %ebp
jle 0x24224
movl %ebp, %eax
xorl %ecx, %ecx
movss (%rbx,%rcx,4), %xmm0
movss %xmm0, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x24211
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movslq %ebp, %r12
leaq (,%r12,8), %rdi
callq 0x21e0
testl %ebp, %ebp
jle 0x242b8
movl %ebp, %esi
leaq (%r15,%rsi,8), %rcx
leaq (%rax,%rsi,8), %rdx
leaq -0x1(%rsi), %rdi
xorps %xmm0, %xmm0
cvtss2sd -0x4(%rbx,%rsi,4), %xmm0
movsd %xmm0, -0x8(%rax,%rsi,8)
cmpq %r12, %rsi
jge 0x2428e
xorl %r8d, %r8d
movsd (%rdx,%r8,8), %xmm1
movq (%rcx,%r8,8), %r9
mulsd (%r9,%rdi,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdi,8)
incq %r8
leal (%rsi,%r8), %r9d
cmpl %ebp, %r9d
jl 0x24269
movq (%r15,%rdi,8), %r8
divsd (%r8,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r14,%rdi,4)
addq $-0x8, %rcx
addq $-0x8, %rdx
cmpq $0x1, %rsi
movq %rdi, %rsi
jg 0x2424e
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Axes_path
void Axes_path(int *main1, int *main2, int *side1, int *side2,
	       struct axe *axes, int i, int nmain, int naxes)
{
  *main1=-1; *main2=-1; *side1=-1; *side2=-1;
  if(i < nmain){
    *main1=axes[i].first_main;
    *main2=i;
  }else{
    *main1=axes[i].first_main;
    *main2=axes[i].last_main;
    *side1=axes[i].first_side;
    *side2=i;
  }
  if((*main2 >= nmain) ||
     (*main2 < *main1)||
     (*side2 < *side1)||
     (*side2>=naxes)){
    printf("ERROR, wrong axes path\n");
    printf("i= %d res= %d main1= %d res=%d main2= %d res=%d",
	   i, (axes[i].bond)->atom->res,
	   *main1, (axes[*main1].bond)->atom->res,
	   *main2, (axes[*main2].bond)->atom->res);
    if(*side1>=0)
      printf(" side1= %d res=%d side2= %d res=%d\n",
	     *side1, (axes+*side1)->bond->atom->res,
	     *side2, (axes[*side2].bond)->atom->res);
    exit(8);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbp
movl 0x40(%rsp), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, (%rdi)
movl %ecx, (%rsi)
movl %ecx, (%rdx)
movl %ecx, (%r14)
movslq %r9d, %r12
imulq $0x158, %r12, %rcx      # imm = 0x158
cmpl %eax, %r9d
jge 0x2570c
movl 0x20(%rbx,%rcx), %ecx
movl %ecx, (%rbp)
movl %r12d, (%r13)
jmp 0x25729
movl 0x20(%rbx,%rcx), %edx
movl %edx, (%rbp)
movl 0x24(%rbx,%rcx), %edx
movl %edx, (%r13)
movl 0x28(%rbx,%rcx), %ecx
movl %ecx, (%r15)
movl %r12d, (%r14)
movl (%r13), %r9d
cmpl %eax, %r9d
jge 0x25751
cmpl (%rbp), %r9d
jl 0x25751
movl (%r14), %eax
cmpl 0x48(%rsp), %eax
jge 0x25751
cmpl (%r15), %eax
jl 0x25751
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33da7(%rip), %rdi     # 0x594ff
callq 0x2090
imulq $0x158, %r12, %rax      # imm = 0x158
movq 0x8(%rbx,%rax), %rax
movq (%rax), %rax
movl 0x64(%rax), %edx
movslq (%rbp), %rcx
imulq $0x158, %rcx, %rax      # imm = 0x158
movq 0x8(%rbx,%rax), %rax
movq (%rax), %rax
movl 0x64(%rax), %r8d
movslq (%r13), %r9
imulq $0x158, %r9, %rax       # imm = 0x158
movq 0x8(%rbx,%rax), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, (%rsp)
leaq 0x33bdb(%rip), %rdi     # 0x59381
movl %r12d, %esi
xorl %eax, %eax
callq 0x20f0
movslq (%r15), %rsi
testq %rsi, %rsi
js 0x257ee
imulq $0x158, %rsi, %rax      # imm = 0x158
movq 0x8(%rbx,%rax), %rax
movq (%rax), %rax
movl 0x64(%rax), %edx
movslq (%r14), %rcx
imulq $0x158, %rcx, %rax      # imm = 0x158
movq 0x8(%rbx,%rax), %rax
movq (%rax), %rax
movl 0x64(%rax), %r8d
leaq 0x33bca(%rip), %rdi     # 0x593b1
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Select_atoms
int Select_atoms(int *atom_num,  atom *atoms, int N_atoms, char *SEL)
{
  // if ali=1 select only aligned atoms, otherwise select all
  int i_atom, n=0; atom *atom1=atoms;
  for(i_atom=0; i_atom<N_atoms; i_atom++){
    if(Selection(atom1->name, atom1, SEL)){
	atom_num[n]=i_atom; n++;
    }
    atom1++;
  }
  return(n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x25a38
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
xorl %r14d, %r14d
xorl %r13d, %r13d
leaq 0x18(%r15), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26d70
testl %eax, %eax
je 0x25a2a
movslq %r14d, %r14
movl %r13d, (%r12,%r14,4)
incl %r14d
addq $0x70, %r15
incl %r13d
cmpl %r13d, %ebp
jne 0x25a0d
jmp 0x25a3b
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Mass
float Mass(atom *atom){
  char *atom_name=atom->name;
  if(atom_name[0]=='C')return(12);
  if(atom_name[0]=='N')return(14); // Adding one hydrogen atom mass
  if(atom_name[0]=='O')return(16);
  if(atom_name[0]=='H')return(1);
  if(atom_name[0]=='P')return(31);
  if(strncmp(atom_name, "SE", 2)==0)return(79); // Selenium
  if(atom_name[0]=='S')return(32);
  printf("WARNING, unusual atom %s\n", atom_name);
  return(12);
}

// Assembly:
movq %rdi, %rsi
movzbl 0x18(%rdi), %eax
movss 0x33234(%rip), %xmm0    # 0x58c90
leal -0x48(%rax), %ecx
cmpl $0xb, %ecx
ja 0x25a7d
leaq 0x331b1(%rip), %rax     # 0x58c1c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movss 0x2b6a0(%rip), %xmm0    # 0x5111c
retq
cmpl $0x43, %eax
je 0x25ad4
pushq %rax
addq $0x18, %rsi
leaq 0x333a6(%rip), %rdi     # 0x58e34
xorl %eax, %eax
callq 0x20f0
movss 0x331f3(%rip), %xmm0    # 0x58c90
addq $0x8, %rsp
retq
cmpb $0x45, 0x19(%rsi)
jne 0x25acc
movss 0x331e4(%rip), %xmm0    # 0x58c94
retq
movss 0x331e7(%rip), %xmm0    # 0x58ca0
retq
movss 0x331e2(%rip), %xmm0    # 0x58ca4
retq
movss 0x331d1(%rip), %xmm0    # 0x58c9c
retq
movss 0x331c4(%rip), %xmm0    # 0x58c98
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Align_references
int Align_references(struct ali_atoms *ali_atoms,
		     struct Reference Ref1, atom *atoms1)
{
  int N_ref=Ref1.N_ref;
  ali_atoms->ali1=malloc(N_ref*sizeof(int));
  ali_atoms->ali2=malloc(N_ref*sizeof(int));
  ali_atoms->mass=malloc(N_ref*sizeof(float));
  int iali=0;
  for(int i=0; i<N_ref; i++){
    int j=atoms1[Ref1.atom_num[i]].ali;
    if(j>=0){
      ali_atoms->ali1[iali]=Ref1.atom_num[i];
      ali_atoms->ali2[iali]=j;
      ali_atoms->mass[iali]=Ref1.mass_atom[i];
      iali++;
    }
  }
  printf("%d aligned reference atoms\n", iali);
  ali_atoms->N_ref=iali; ali_atoms->N_Cart=3*iali;
  return(iali);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x40(%rsp), %rbp
leaq (,%rbp,4), %r13
movq %r13, %rdi
callq 0x21e0
movq %rax, %r15
movq %rax, (%rbx)
movq %r13, %rdi
callq 0x21e0
movq %rax, %r12
movq %rax, 0x8(%rbx)
movq %r13, %rdi
callq 0x21e0
movq %rax, 0x10(%rbx)
testq %rbp, %rbp
jle 0x25b68
leaq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rcx
movq 0x28(%rdx), %rdx
xorl %esi, %esi
xorl %r13d, %r13d
movslq (%rdx,%rsi,4), %rdi
imulq $0x70, %rdi, %r8
movl 0x54(%r14,%r8), %r8d
testl %r8d, %r8d
js 0x25b5e
movslq %r13d, %r13
movl %edi, (%r15,%r13,4)
movl %r8d, (%r12,%r13,4)
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%r13,4)
incl %r13d
incq %rsi
cmpq %rsi, %rbp
jne 0x25b33
jmp 0x25b6b
xorl %r13d, %r13d
leaq 0x331f2(%rip), %rdi     # 0x58d64
movl %r13d, %esi
xorl %eax, %eax
callq 0x20f0
movl %r13d, 0x18(%rbx)
leal (%r13,%r13,2), %eax
movl %eax, 0x1c(%rbx)
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Match_references
void Match_references(int *kin_cc, struct Reference Ref1, struct Reference Ref)
{
  // kin_cc[i] = Kinetic atom corresponding to ref atom i in Ref1
  int j=0;
  for(int i=0; i<Ref1.N_ref; i++){
    while(Ref.atom_num[j]!=Ref1.atom_num[i])j++;
    if(j>=Ref.N_ref){
      printf("ERROR, unmatched reference %d atom %d out of %d %d\n",
	     i, Ref1.atom_num[i], Ref1.N_ref, Ref.N_ref); exit(8);
    }
    kin_cc[i]=j;
  }
}

// Assembly:
pushq %rax
movslq 0x10(%rsp), %rcx
testq %rcx, %rcx
jle 0x25be7
leaq 0x40(%rsp), %rdx
leaq 0x10(%rsp), %rsi
movq 0x28(%rdx), %rax
movq 0x28(%rsi), %r9
movl (%rdx), %r8d
xorl %esi, %esi
xorl %r10d, %r10d
movl (%r9,%rsi,4), %edx
movslq %r10d, %r10
decq %r10
movq %r10, %r11
incq %r10
cmpl %edx, 0x4(%rax,%r11,4)
jne 0x25bc9
cmpl %r10d, %r8d
jle 0x25be9
movl %r10d, (%rdi,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x25bbf
popq %rax
retq
leaq 0x33190(%rip), %rdi     # 0x58d80
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/ugobas[P]tnm/nma.c
// Function: Compute_MW
void Compute_MW(float *MW_Tors, float *Tors, struct Jacobian *J){
  // Compute Masswtd_Tors_dev = T_sqrt Delta_theta
  int N=J->N_axes, a, b;
  for(a=0; a<N; a++){
    double W=0;
    if(J->T_sqrt_inv){ // T_sqrt is not lower diagonal! DMW =L^t Dtheta
      for(b=0; b<N; b++)W+=J->T_sqrt[b][a]*Tors[b];
    }else{  // b<a
      for(b=a; b<N; b++)W+=J->T_sqrt[b][a]*Tors[b];
    }
    MW_Tors[a]=W;
  }
}

// Assembly:
movslq (%rdx), %rax
testq %rax, %rax
jle 0x26614
pushq %r14
pushq %rbx
movq 0x28(%rdx), %rcx
movq 0x30(%rdx), %rdx
xorl %r8d, %r8d
movq %rax, %r9
movq %rcx, %r10
movq %rsi, %r11
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x265d5
movq (%rcx,%rbx,8), %r14
xorps %xmm1, %xmm1
cvtss2sd (%rsi,%rbx,4), %xmm1
mulsd (%r14,%r8,8), %xmm1
addsd %xmm1, %xmm0
incq %rbx
cmpq %rbx, %rax
jne 0x265b5
jmp 0x265f4
movq (%r10,%rbx,8), %r14
xorps %xmm1, %xmm1
cvtss2sd (%r11,%rbx,4), %xmm1
mulsd (%r14,%r8,8), %xmm1
addsd %xmm1, %xmm0
incq %rbx
cmpq %rbx, %r9
jne 0x265d5
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
addq $0x4, %r11
addq $0x8, %r10
decq %r9
cmpq %rax, %r8
jne 0x265aa
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x49804
movq %rax, %r14
movq %rsp, %rdx
movl $0x3, %edi
movq %r15, %rsi
movq %rax, %rcx
movl $0x1, %r8d
callq 0x4a8b4
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 0x26c67
leaq 0x32193(%rip), %rdi     # 0x58dcf
movb $0x1, %al
callq 0x20f0
movq (%r14), %rax
xorl %ecx, %ecx
movapd 0x2a440(%rip), %xmm0    # 0x51090
movsd (%rax,%rcx,8), %xmm1
xorpd %xmm0, %xmm1
movlpd %xmm1, (%rax,%rcx,8)
incq %rcx
cmpq $0x3, %rcx
jne 0x26c50
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 0x26c73
incq %rax
cmpq $0x3, %rax
jne 0x26c69
movq %r14, %rdi
movl $0x3, %esi
callq 0x496ae
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26d25
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 0x25a4d
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 0x26cf5
movsd (%rsp), %xmm0
addsd %xmm2, %xmm0
incq %rbp
cmpq %r13, %rbp
jne 0x26cd4
jmp 0x26d28
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 0x26d2a
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/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:
movzbl (%rdx), %r8d
cmpl $0x43, %r8d
je 0x26d9f
cmpl $0x41, %r8d
jne 0x26dc3
cmpb $0x4c, 0x1(%rdx)
jne 0x26dc3
cmpb $0x48, (%rdi)
setne %al
leaq 0x422d1(%rip), %rcx     # 0x69064
cmpl $0x0, (%rcx)
setne %cl
orb %al, %cl
movzbl %cl, %eax
retq
cmpb $0x42, 0x1(%rdx)
jne 0x26dc3
cmpb $0x43, (%rdi)
jne 0x26e09
movl $0x1, %eax
cmpb $0x42, 0x1(%rdi)
je 0x26e0b
cmpb $0x47, 0x68(%rsi)
jne 0x26e09
cmpb $0x41, 0x1(%rdi)
jne 0x26e09
jmp 0x26e0b
movb (%rdi), %cl
cmpb $0x43, %cl
jne 0x26dd5
movl $0x1, %eax
cmpb $0x41, 0x1(%rdi)
je 0x26e0b
cmpl $0x45, %r8d
je 0x26df3
cmpl $0x42, %r8d
jne 0x26e09
cmpb $0x42, 0x1(%rdx)
jne 0x26e09
cmpb $0x4e, %cl
je 0x26dfe
cmpb $0x43, %cl
je 0x26dfe
jmp 0x26e09
cmpb $0x42, 0x1(%rdx)
jne 0x26e09
cmpb $0x4e, %cl
jne 0x26e0c
movl $0x1, %eax
cmpb $0x20, 0x1(%rdi)
je 0x26e0b
xorl %eax, %eax
retq
cmpb $0x43, %cl
jne 0x26e24
movl $0x1, %eax
cmpb $0x20, 0x1(%rdi)
je 0x26e0b
cmpb $0x42, 0x1(%rdi)
jne 0x26e09
jmp 0x26e0b
cmpb $0x4f, %cl
je 0x26dfe
jmp 0x26e09
// File: /workspace/github_c_makefile_star2_O3/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 0x273ed
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 0x4971a
xorps %xmm2, %xmm2
movq (%rsp), %rcx
movq %rax, (%rcx,%r15,8)
testl %ebp, %ebp
jle 0x273b0
leaq (,%r15,4), %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movss (%r14,%rdx,4), %xmm0
ucomiss %xmm2, %xmm0
jne 0x27350
jnp 0x273a8
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 0x2737d
incq %r8
incq %rdi
cmpq $0x3, %r8
jne 0x2735f
incq %rdx
cmpq %r13, %rdx
jne 0x27343
xorl %ecx, %ecx
cmpq $0x1, %rcx
ja 0x273d8
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 0x273bf
incq %rcx
cmpq $0x3, %rcx
jne 0x273b2
incq %r15
cmpq %r12, %r15
jne 0x27317
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/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 0x2744a
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 0x2747e
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 0x27525
movq 0x28(%rbx), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movss (%rcx,%rdx,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x2749f
jnp 0x27519
movss (%r8,%rdx,4), %xmm1
testl %r12d, %r12d
jle 0x274df
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 0x274b4
testl %r13d, %r13d
jle 0x27519
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 0x274ee
incq %rdx
cmpq %rax, %rdx
jne 0x27493
testl %r12d, %r12d
jle 0x27546
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 0x27530
testl %r13d, %r13d
jle 0x27567
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 0x27551
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/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 0x318d8(%rip), %rsi     # 0x58e83
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2270
leaq 0x2a790(%rip), %rdi     # 0x51d4f
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x2fc30(%rip), %rsi     # 0x57200
movq %r12, %rdi
callq 0x2220
movq %rax, %r15
leaq 0x318b1(%rip), %rdi     # 0x58e93
movl $0x25, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x2290
testl %ebp, %ebp
jle 0x2765c
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 0x31873(%rip), %rsi     # 0x58eb9
movb $0x1, %al
callq 0x21a0
incq %r12
addq $0x158, %r14            # imm = 0x158
cmpq %r12, %rbp
jne 0x2760d
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_O3/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 0x276d7
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 0x26d70
testl %eax, %eax
je 0x276cc
movss 0x4(%r13), %xmm0
divss 0x315f9(%rip), %xmm0    # 0x58cb4
movslq %r14d, %r14
movss %xmm0, (%r15,%r14,4)
incl %r14d
cmpl %ebp, %r14d
je 0x276dc
addq $0x70, %r13
decl %r12d
jne 0x2769a
jmp 0x276df
xorl %r14d, %r14d
jmp 0x276df
movl %ebp, %r14d
leaq 0x317e3(%rip), %rdi     # 0x58ec9
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_O3/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 0x27800
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 0x26d70
testl %eax, %eax
je 0x277ea
movl %r12d, 0xc(%rsp)
movl $0x18, %edi
callq 0x21e0
movq %rbx, 0x18(%rsp)
movslq %ebx, %rbx
movq %rax, (%r15,%rbx,8)
movl $0x18, %edi
callq 0x21e0
movq %rax, (%r14,%rbx,8)
movq %rbp, 0x20(%rsp)
xorl %r12d, %r12d
movl $0xc, %edi
callq 0x21e0
movq (%r14,%rbx,8), %rcx
movq %rax, (%rcx,%r12,8)
movl $0xc, %edi
callq 0x21e0
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 0x277b2
incq %r12
addq $0xc, %rbp
cmpq $0x3, %r12
jne 0x27784
movq 0x18(%rsp), %rbx
incl %ebx
cmpl 0x4(%rsp), %ebx
movq 0x20(%rsp), %rbp
movl 0xc(%rsp), %r12d
je 0x27800
addq $0x70, %r13
incl %r12d
addq $0x70, %rbp
cmpl 0x8(%rsp), %r12d
jne 0x2773a
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/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movslq %esi, %r12
leaq (,%r12,4), %rdi
callq 0x21e0
testl %r12d, %r12d
jle 0x27def
movl %r14d, %ecx
leal 0x3(%r14), %edx
leaq -0x1(%rcx), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %edx
shlq $0x4, %rdx
movdqa 0x2936e(%rip), %xmm1    # 0x51010
movdqa 0x29376(%rip), %xmm2    # 0x51020
xorl %esi, %esi
movdqa 0x2937c(%rip), %xmm3    # 0x51030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x2e4bc(%rip), %xmm5    # 0x56180
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x27d00
movl $0x1, (%rax,%rsi)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x27d17
movl $0x1, 0x4(%rax,%rsi)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %edi
testb $0x1, %dil
je 0x27d57
movl $0x1, 0x8(%rax,%rsi)
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x27d6a
movl $0x1, 0xc(%rax,%rsi)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rsi
cmpq %rsi, %rdx
jne 0x27cc4
testl %r14d, %r14d
jle 0x27def
xorl %edx, %edx
xorl %esi, %esi
cmpl $0x0, (%rax,%rsi,4)
jne 0x27d98
incq %rsi
cmpq %rsi, %rcx
jne 0x27d88
movl %ecx, %esi
leal 0x1(%rsi), %edi
cmpl %r14d, %edi
jge 0x27dda
movl %esi, %edi
leaq (%r15,%rdi,4), %r8
movss (%r8), %xmm0
leaq (%rax,%rdi,4), %r9
movl $0x1, %r10d
cmpl $0x0, (%r9,%r10,4)
je 0x27dce
movss (%r8,%r10,4), %xmm1
ucomiss %xmm0, %xmm1
jb 0x27dce
leal (%rdi,%r10), %esi
movaps %xmm1, %xmm0
incq %r10
leal (%rdi,%r10), %r11d
cmpl %r14d, %r11d
jl 0x27db5
movl %esi, (%rbx,%rdx,4)
movslq %esi, %rsi
movl $0x0, (%rax,%rsi,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x27d86
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/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 0x30f79(%rip), %rsi     # 0x59159
movq %rdx, %rdi
movq %rcx, %rdx
movb $0x1, %al
callq 0x21a0
testl %ebp, %ebp
jle 0x2821f
movl %ebp, %r13d
xorl %r15d, %r15d
leaq 0x30f78(%rip), %r12     # 0x59176
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r15,4), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movb $0x1, %al
callq 0x21a0
incq %r15
cmpq %r15, %r13
jne 0x281fe
leaq 0x2fec5(%rip), %rdi     # 0x580eb
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2290
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
leaq 0x50(%rsp), %r12
movslq 0xc(%r12), %r15
leaq (,%r15,4), %rdi
callq 0x21e0
movq %rax, %r14
movl %r15d, %ebx
movq %r13, (%rsp)
movq %rax, 0x8(%r13)
testq %r15, %r15
jle 0x292dc
leaq (,%rbx,4), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
movslq 0x8(%r12), %rbp
leaq (,%rbp,4), %r12
movq %r12, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rsp), %rax
movq %r15, 0x18(%rax)
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
movl %ebp, %r13d
movq (%rsp), %rax
movq %r12, 0x10(%rax)
testq %rbp, %rbp
jle 0x29339
leaq (,%r13,4), %rbp
movq %r15, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2110
movq %r12, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2110
leaq 0x50(%rsp), %rbp
movslq (%rbp), %rdi
shlq $0x2, %rdi
callq 0x21e0
movq (%rsp), %rcx
movq %rax, 0x20(%rcx)
movslq 0x10(%rbp), %rax
testq %rax, %rax
jle 0x29436
movq 0xc0(%rbp), %rcx
movq 0x20(%rbp), %rdx
movq %rdx, (%rsp)
movq 0x28(%rbp), %rsi
movq 0x38(%rbp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x40(%rbp), %r8
movq 0x48(%rbp), %r9
xorl %r10d, %r10d
xorps %xmm0, %xmm0
cmpl $0x0, (%rcx,%r10,4)
je 0x2942a
movss (%rsi,%r10,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x293a6
jnp 0x2942a
movq (%rsp), %rdx
movss (%rdx,%r10,4), %xmm1
movq 0x10(%rsp), %rdx
mulss (%rdx,%r10,4), %xmm1
movq (%r8,%r10,8), %r11
movq (%r9,%r10,8), %rbp
testl %ebx, %ebx
jle 0x293ef
movq 0x8(%rsp), %rdx
movq (%rdx,%r10,8), %rdi
xorl %edx, %edx
movss (%rdi,%rdx,4), %xmm2
mulss %xmm1, %xmm2
addss (%r14,%rdx,4), %xmm2
movss %xmm2, (%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rbx
jne 0x293d2
testl %r13d, %r13d
jle 0x2942a
xorl %edi, %edi
movss (%r11,%rdi,4), %xmm2
mulss %xmm1, %xmm2
addss (%r15,%rdi,4), %xmm2
movss %xmm2, (%r15,%rdi,4)
movss (%rbp,%rdi,4), %xmm2
mulss %xmm1, %xmm2
addss (%r12,%rdi,4), %xmm2
movss %xmm2, (%r12,%rdi,4)
incq %rdi
cmpq %rdi, %r13
jne 0x293f6
incq %r10
cmpq %rax, %r10
jne 0x2938a
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/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 0x29484
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 0x29458
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi,%rcx,4)
incq %rcx
cmpq %rax, %rcx
jne 0x2944d
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2950b
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 0x294de
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%r10,4)
incq %r10
cmpq %rax, %r10
jne 0x294d3
movl %ebx, %ecx
movq %rsp, %r15
leaq 0xf(,%rcx,4), %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
testl %r14d, %r14d
jle 0x29579
cmpl $0x2, %ebx
movl $0x1, %ecx
cmovgel %ebx, %ecx
xorl %esi, %esi
testl %edx, %edx
jle 0x29568
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 0x29542
cvtsd2ss %xmm0, %xmm0
jmp 0x2956b
xorps %xmm0, %xmm0
movss %xmm0, (%r15,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x29534
movl %ebx, %edi
movl %ebx, %esi
callq 0x49804
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 0x23c84
addq $0x10, %rsp
testl %r14d, %r14d
jle 0x295f5
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 0x295ca
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rdx,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x295c1
movq %r12, %rdi
movl %ebx, %esi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x496ae
// File: /workspace/github_c_makefile_star2_O3/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 0x29641
movl %esi, %eax
xorps %xmm2, %xmm2
xorl %ecx, %ecx
movaps 0x2dcba(%rip), %xmm3    # 0x572e0
movaps %xmm2, %xmm4
movss (%rdi,%rcx,4), %xmm2
andps %xmm3, %xmm2
maxss %xmm4, %xmm2
incq %rcx
cmpq %rcx, %rax
jne 0x29626
cvtss2sd %xmm2, %xmm2
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x29651
sqrtsd %xmm0, %xmm0
jmp 0x29665
pushq %rax
movsd %xmm2, (%rsp)
callq 0x22a0
movsd (%rsp), %xmm2
addq $0x8, %rsp
divsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl 0x40(%rsp), %r13d
testl %esi, %esi
jle 0x296a3
movl %ebp, %edx
shlq $0x2, %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2110
testl %r13d, %r13d
jle 0x297c1
movslq %ebp, %rax
movl %r13d, %ecx
movq %rcx, (%rsp)
addq $0x8, %r14
xorl %edx, %edx
xorl %esi, %esi
imulq $0x70, %rdx, %rcx
leaq (%rbx,%rcx), %rdi
movslq 0x18(%rbx,%rcx), %r9
movl 0x1c(%rbx,%rcx), %ecx
addl %r9d, %ecx
decl %ecx
movslq %ecx, %r8
cmpl $0x0, (%r15,%r9,4)
jne 0x296e6
cmpl $0x0, 0x4(%r15,%r9,4)
je 0x29744
cmpl %ebp, %esi
jge 0x2973c
movslq %esi, %r11
leal 0x1(%r11), %r10d
imulq $0x158, %r11, %r13      # imm = 0x158
addq %r14, %r13
movq (%r13), %rcx
movq (%rcx), %rcx
movslq 0x64(%rcx), %rcx
cmpl %r9d, %ecx
je 0x29724
cmpq %rcx, %r9
jl 0x2973c
incq %r11
incl %r10d
addq $0x158, %r13            # imm = 0x158
cmpq %rax, %r11
jl 0x296fb
jmp 0x2973c
testq %r11, %r11
js 0x2973c
movl %r11d, %ecx
movl $0x1, (%r12,%rcx,4)
movl %r10d, %esi
cmpl %ebp, %r10d
jl 0x296ea
incq %r9
cmpq %r8, %r9
jl 0x296d7
cmpl $0x0, (%r15,%r8,4)
jne 0x29753
cmpl $0x0, -0x4(%r15,%r8,4)
je 0x297b4
cmpl %ebp, %esi
jge 0x297a8
movslq %esi, %r10
leal 0x1(%r10), %r9d
imulq $0x158, %r10, %r11      # imm = 0x158
addq %r14, %r11
movq (%r11), %rcx
movq (%rcx), %rcx
movslq 0x64(%rcx), %rcx
cmpl %r8d, %ecx
je 0x29790
cmpq %rcx, %r8
jl 0x297a8
incq %r10
incl %r9d
addq $0x158, %r11            # imm = 0x158
cmpq %rax, %r10
jl 0x29768
jmp 0x297a8
testq %r10, %r10
js 0x297a8
movl %r10d, %ecx
movl $0x1, (%r12,%rcx,4)
movl %r9d, %esi
cmpl %ebp, %r9d
jl 0x29757
decq %r8
movslq 0x18(%rdi), %rcx
cmpq %rcx, %r8
jg 0x29744
incq %rdx
cmpq (%rsp), %rdx
jne 0x296be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq