LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/kinetic_tnm.c
// Function: Empty_Jacobian
void Empty_Jacobian(struct Jacobian J)
{
  if(J.T!=NULL)Empty_matrix_d(J.T, J.N_axes);
  if(J.Jacobian_ar!=NULL)Empty_matrix_f(J.Jacobian_ar, J.N_axes);
  if(J.Jtilde_ar!=NULL)Empty_matrix_f(J.Jtilde_ar, J.N_axes);
  if(J.T_sqrt!=NULL)Empty_matrix_d(J.T_sqrt, J.N_axes);
  if(J.T_sqrt_inv!=NULL)Empty_matrix_f(J.T_sqrt_inv, J.N_axes);
  if(J.T_sqrt_tr!=NULL)Empty_matrix_f(J.T_sqrt_tr, J.N_kin); //modyves: this was never freed
}

// Assembly:
pushq %rbx
leaq 0x10(%rsp), %rbx
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x21129
movl (%rbx), %esi
callq 0x4372a
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x21139
movl (%rbx), %esi
callq 0x436f0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x21149
movl (%rbx), %esi
callq 0x436f0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x21159
movl (%rbx), %esi
callq 0x4372a
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x21169
movl (%rbx), %esi
callq 0x436f0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2117b
movl 0x8(%rbx), %esi
popq %rbx
jmp 0x436f0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nma.c
// Function: Empty_Normal_modes
void Empty_Normal_modes(struct Normal_Mode NM)
{

  // Cleaning normal modes
  Empty_matrix_f(NM.Cart, NM.N);
  Empty_matrix_f(NM.Tors, NM.N);
  Empty_matrix_f(NM.MW_Tors, NM.N);
  free(NM.omega2);
  free(NM.omega);
  free(NM.select); //modyves: was never freed
  free(NM.sigma2);
  free(NM.Cart_coll);
  free(NM.Tors_coll);
  free(NM.MW_Tors_coll);
  free(NM.Tors_frac);
  free(NM.sort);
  free(NM.Anharmonicity);
  free(NM.Anharm_struct);
  free(NM.Max_factor);
  free(NM.Max_RMSD);
  free(NM.Max_dev); 
  free(NM.cart_fluct);
  free(NM.tors_fluct);
  free(NM.confchange2);

}

// Assembly:
pushq %rbx
movq 0x48(%rsp), %rdi
movl 0x10(%rsp), %ebx
movl %ebx, %esi
callq 0x436f0
movq 0x50(%rsp), %rdi
movl %ebx, %esi
callq 0x436f0
movq 0x58(%rsp), %rdi
movl %ebx, %esi
callq 0x436f0
movq 0x30(%rsp), %rdi
callq 0x2050
movq 0x28(%rsp), %rdi
callq 0x2050
movq 0xd0(%rsp), %rdi
callq 0x2050
movq 0x38(%rsp), %rdi
callq 0x2050
movq 0x78(%rsp), %rdi
callq 0x2050
movq 0x80(%rsp), %rdi
callq 0x2050
movq 0x88(%rsp), %rdi
callq 0x2050
movq 0x70(%rsp), %rdi
callq 0x2050
movq 0xc8(%rsp), %rdi
callq 0x2050
movq 0xa8(%rsp), %rdi
callq 0x2050
movq 0xb0(%rsp), %rdi
callq 0x2050
movq 0xb8(%rsp), %rdi
callq 0x2050
movq 0xc0(%rsp), %rdi
callq 0x2050
movq 0x90(%rsp), %rdi
callq 0x2050
movq 0x68(%rsp), %rdi
callq 0x2050
movq 0x60(%rsp), %rdi
callq 0x2050
movq 0x40(%rsp), %rdi
popq %rbx
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nma.c
// Function: Normal_modes_INM
void Normal_modes_INM(int N,           //degrees of freedom
		      struct interaction *Int_list, int N_int,
		      atom *atoms, int N_atoms,
		      double **Hessian, float **eigen_vector,
		      float *eigen_value, float *eigen_B,
		      float *B_CA, float *Cart_collectivity)
{
  int i;

  Compute_Hessian_INM(Hessian, N, Int_list, N_int, atoms);
  d_Diagonalize(N, Hessian, eigen_value, eigen_vector, -1);
  Compute_Bfact_INM(B_CA, eigen_B, N, eigen_value, eigen_vector);
  for(i=0; i<N; i++)
    Cart_collectivity[i]=Collectivity_norm2(eigen_vector[i], N)/N;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %rcx, %r8
movl %edx, %ecx
movq %rsi, %rdx
movl %edi, %ebx
movq 0x60(%rsp), %r12
movq 0x40(%rsp), %r14
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbp
movq %r9, %rdi
movl %ebx, %esi
callq 0x2174e
pushq $-0x1
popq %r8
movl %ebx, %edi
movq %r15, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x444de
movq 0x58(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %rbp, %rcx
movq %r14, %r8
callq 0x217fd
cvtsi2ss %ebx, %xmm0
movss %xmm0, 0x4(%rsp)
xorl %r15d, %r15d
testl %ebx, %ebx
movl $0x0, %r13d
cmovgl %ebx, %r13d
cmpq %r15, %r13
je 0x2173f
movq (%r14,%r15,8), %rdi
movl %ebx, %esi
callq 0x100f2
divss 0x4(%rsp), %xmm0
movss %xmm0, (%r12,%r15,4)
incq %r15
jmp 0x2171e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %r9d
cmovgl %esi, %r9d
movl %esi, %esi
cmpq %r9, %rax
je 0x2177e
xorl %r10d, %r10d
cmpq %r10, %rsi
je 0x21779
movq (%rdi,%rax,8), %r11
andq $0x0, (%r11,%r10,8)
incq %r10
jmp 0x21766
incq %rax
jmp 0x2175e
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0xc8, %rcx, %rcx
movaps 0x2f0cd(%rip), %xmm0    # 0x50860
cmpq %rax, %rcx
je 0x217fc
cvtsd2ss 0x28(%rdx,%rax), %xmm1
movslq (%rdx,%rax), %rsi
imulq $0x70, %rsi, %rsi
movslq 0x64(%r8,%rsi), %rsi
movslq 0x4(%rdx,%rax), %r9
imulq $0x70, %r9, %r9
movslq 0x64(%r8,%r9), %r9
cvtss2sd %xmm1, %xmm2
xorps %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movq (%rdi,%rsi,8), %r10
movsd %xmm1, (%r10,%r9,8)
movq (%rdi,%r9,8), %r11
movsd %xmm1, (%r11,%rsi,8)
movsd (%r10,%rsi,8), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, (%r10,%rsi,8)
addsd (%r11,%r9,8), %xmm2
movsd %xmm2, (%r11,%r9,8)
addq $0xc8, %rax
jmp 0x21793
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %r9d, %r9d
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
cmpq %r9, %rax
je 0x21819
andl $0x0, (%rsi,%r9,4)
incq %r9
jmp 0x2180a
pushq %rbx
movl %edx, %edx
xorl %r9d, %r9d
leaq 0x428ce(%rip), %r10     # 0x640f4
cmpq %rax, %r9
je 0x21881
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0x21872
movss (%rcx,%r11,4), %xmm1
movss (%r10), %xmm2
ucomiss %xmm1, %xmm2
ja 0x2186d
movq (%r8,%r11,8), %rbx
movss (%rbx,%r9,4), %xmm2
mulss %xmm2, %xmm2
divss %xmm1, %xmm2
cvtss2sd %xmm2, %xmm1
addsd %xmm1, %xmm0
addss (%rsi,%r11,4), %xmm2
movss %xmm2, (%rsi,%r11,4)
incq %r11
jmp 0x21832
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi,%r9,4)
incq %r9
jmp 0x21826
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
cmpq %rax, %r8
je 0x21b2d
andl $0x0, (%rsi,%rax,4)
incq %rax
jmp 0x21b1f
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
testl %r9d, %r9d
cmovlel %eax, %r9d
leaq 0x425b2(%rip), %r10     # 0x640f4
xorl %r11d, %r11d
cmpq %r9, %r11
je 0x21bc4
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
cmpq %r8, %rbx
je 0x21bb1
movss (%rdx,%rbx,4), %xmm1
movss (%r10), %xmm2
ucomiss %xmm1, %xmm2
ja 0x21bac
movq (%rcx,%rbx,8), %r14
addq %rax, %r14
xorps %xmm2, %xmm2
xorl %r15d, %r15d
cmpl $0x3, %r15d
je 0x21b8e
movss (%r14,%r15,4), %xmm3
mulss %xmm3, %xmm3
cvtss2sd %xmm3, %xmm3
addsd %xmm3, %xmm2
incq %r15
jmp 0x21b71
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm2
addsd %xmm2, %xmm0
cvtss2sd (%rsi,%rbx,4), %xmm1
addsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rsi,%rbx,4)
incq %rbx
jmp 0x21b50
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi,%r11,4)
incq %r11
addq $0xc, %rax
jmp 0x21b45
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x41a26(%rip), %rax     # 0x63604
cmpl $0x0, (%rax)
je 0x21c3b
testq %rcx, %rcx
je 0x21c5c
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
testl %r9d, %r9d
cmovlel %eax, %r9d
cmpq %r9, %rax
je 0x21d0f
movq (%rcx,%rax,8), %rdx
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
cmpl %r10d, %r8d
je 0x21c2a
movss (%rsi,%r10,4), %xmm1
mulss (%rdx,%r10,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r10
jmp 0x21c0c
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi)
addq $0x4, %rdi
incq %rax
jmp 0x21bf8
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
cmpl %eax, %r8d
je 0x21d0f
movss (%rsi,%rax,4), %xmm0
movss %xmm0, (%rdi,%rax,4)
incq %rax
jmp 0x21c44
movq %rsp, %rax
movl %r8d, %ecx
movq %rsp, %r10
leaq 0xf(,%rcx,8), %r9
andq $-0x10, %r9
subq %r9, %r10
movq %r10, %rsp
leal -0x1(%r8), %r9d
movslq %r8d, %r11
leaq (%r10,%r11,8), %r10
addq $-0x8, %r10
leaq (%rsi,%r11,4), %rsi
addq $-0x4, %rsi
leaq (%rdi,%r11,4), %rdi
addq $-0x4, %rdi
testl %r9d, %r9d
js 0x21d0c
movl %r9d, %r11d
leaq (,%r11,4), %r14
cvtss2sd (%rsi), %xmm0
movsd %xmm0, (%r10)
movq (%rdx,%r11,8), %rbx
addq %rbx, %r14
addq $0x4, %r14
xorl %r15d, %r15d
leal (%rcx,%r15), %r12d
cmpl %r8d, %r12d
jge 0x21ce1
cvtss2sd (%r14,%r15,4), %xmm1
mulsd 0x8(%r10,%r15,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r10)
incq %r15
jmp 0x21cbd
cvtss2sd (%rbx,%r11,4), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%r10)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi)
addq $-0x4, %rdi
addq $-0x4, %rsi
addq $-0x8, %r10
decl %r9d
decq %rcx
jmp 0x21c96
movq %rax, %rsp
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x418d0(%rip), %rax     # 0x63604
cmpl $0x0, (%rax)
je 0x21d83
testq %rcx, %rcx
je 0x21dac
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
testl %r9d, %r9d
cmovlel %eax, %r9d
cmpq %r9, %rax
je 0x21da0
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x21d74
cvtss2sd (%r14,%rdx,4), %xmm1
movq (%rcx,%rdx,8), %rsi
mulsd (%rsi,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x21d57
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r15,%rax,4)
incq %rax
jmp 0x21d4c
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %rax, %rbx
je 0x21da0
movss (%r14,%rax,4), %xmm0
movss %xmm0, (%r15,%rax,4)
incq %rax
jmp 0x21d8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movslq %ebx, %rdi
shlq $0x3, %rdi
callq 0x21d0
movl %ebx, %esi
leaq (%r12,%rsi,8), %rcx
leaq (%rax,%rsi,8), %rdx
testl %esi, %esi
jle 0x21e27
leaq -0x1(%rsi), %rdi
cvtss2sd (%r14,%rdi,4), %xmm0
movsd %xmm0, (%rax,%rdi,8)
xorl %r8d, %r8d
leal (%rsi,%r8), %r9d
cmpl %ebx, %r9d
jge 0x21e02
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
jmp 0x21ddb
movq (%r12,%rdi,8), %rsi
divsd (%rsi,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r15,%rdi,4)
addq $-0x8, %rcx
addq $-0x8, %rdx
movq %rdi, %rsi
jmp 0x21dc5
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbp
orl $-0x1, (%rdi)
movq %rsi, %r13
orl $-0x1, (%rsi)
movq %rdx, %r15
orl $-0x1, (%rdx)
movq %rcx, %r14
orl $-0x1, (%rcx)
movq %r8, %rbx
movl 0x40(%rsp), %eax
movslq %r9d, %r12
imulq $0x158, %r12, %rcx      # imm = 0x158
cmpl %eax, %r9d
jge 0x230ef
movl 0x20(%rbx,%rcx), %ecx
movl %ecx, (%rbp)
movl %r12d, (%r13)
jmp 0x2310c
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 0x23134
cmpl (%rbp), %r9d
jl 0x23134
movl (%r14), %eax
cmpl 0x48(%rsp), %eax
jge 0x23134
cmpl (%r15), %eax
jl 0x23134
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30324(%rip), %rdi     # 0x5345f
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 0x30158(%rip), %rdi     # 0x532e1
movl %r12d, %esi
xorl %eax, %eax
callq 0x20f0
movslq (%r15), %rsi
testq %rsi, %rsi
js 0x231d1
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 0x30147(%rip), %rdi     # 0x53311
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/nma.c
// Function: Set_reference
int Set_reference(// Output:
		  struct Reference *Ref,
		  // Input:
		  int ini_ref, char *SEL, atom *atoms,
		  int ini_atom, int natoms)
{
  // Set reference atoms
  Ref->atom_num=malloc(natoms*sizeof(int));
  int N_ref=
    Select_atoms(Ref->atom_num+ini_ref, atoms+ini_atom, natoms, SEL);
  Ref->N_ref=N_ref;
  Ref->N_Cart=3*N_ref;
  printf("%d atoms out of %d selected for kinetic energy (%s)\n",
	 N_ref, natoms, SEL);
  Ref->mass_atom=malloc(N_ref*sizeof(float));
  Ref->mass_coord=malloc(Ref->N_Cart*sizeof(float));
  Ref->mass_sqrt=malloc(Ref->N_Cart*sizeof(float));

  float *ma=Ref->mass_atom, *mc=Ref->mass_coord, *ms=Ref->mass_sqrt;
  int *a_num=Ref->atom_num;
  double mass_sum=0;
  for(int i=ini_ref; i<ini_ref+N_ref; i++){
    (*a_num)+=ini_atom;
    (*ma) = Mass(atoms+(*a_num));
    mass_sum+=(*ma);
    for(int j=0; j<3; j++){*mc = *ma; *ms=sqrt(*ma); mc++; ms++;}
    ma++; a_num++;
  }
  Ref->mass_sum=mass_sum;
  return(N_ref);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r13d
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movslq %r9d, %r12
leaq (,%r12,4), %rdi
callq 0x21d0
movq %rax, 0x28(%r14)
movslq %ebp, %rcx
movq %rcx, 0x8(%rsp)
leaq (%rax,%rcx,4), %rdi
movslq %r13d, %rax
movq %rax, 0x20(%rsp)
imulq $0x70, %rax, %rsi
movq %rbx, 0x28(%rsp)
addq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x2336a
movl %eax, %ebx
movl %eax, (%r14)
leal (%rbx,%rbx,2), %eax
movl %eax, 0x4(%r14)
leaq 0x2fa48(%rip), %rdi     # 0x52c8f
movl %ebx, %esi
movl %r12d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x20f0
movq %rbx, 0x10(%rsp)
movslq %ebx, %rbx
leaq (,%rbx,4), %rdi
callq 0x21d0
movq %rax, %r12
movq %rax, 0x10(%r14)
movslq 0x4(%r14), %r15
shlq $0x2, %r15
movq %r15, %rdi
callq 0x21d0
movq %rax, %r13
movq %rax, 0x18(%r14)
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
movq %rax, 0x20(%r14)
movq %r14, 0x18(%rsp)
movq 0x28(%r14), %r14
addl 0x8(%rsp), %ebx
movq %rbx, 0x30(%rsp)
xorps %xmm0, %xmm0
cmpl 0x30(%rsp), %ebp
jge 0x23348
movsd %xmm0, 0x40(%rsp)
movl %ebp, 0x8(%rsp)
movslq (%r14), %rax
addq 0x20(%rsp), %rax
movl %eax, (%r14)
imulq $0x70, %rax, %rdi
addq 0x28(%rsp), %rdi
callq 0x233c9
movss %xmm0, (%r12)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
xorl %ebp, %ebp
xorl %ebx, %ebx
cmpl $0x3, %ebp
je 0x23323
movss (%r12), %xmm0
movss %xmm0, (%r13,%rbp,4)
ucomiss 0x27d05(%rip), %xmm0    # 0x4b00c
jb 0x2330f
sqrtss %xmm0, %xmm0
jmp 0x23314
callq 0x21c0
movss %xmm0, (%r15,%rbp,4)
addq $-0x4, %rbx
incq %rbp
jmp 0x232ee
movsd 0x40(%rsp), %xmm0
addsd 0x38(%rsp), %xmm0
addq $0x4, %r12
addq $0x4, %r14
movl 0x8(%rsp), %ebp
incl %ebp
subq %rbx, %r13
subq %rbx, %r15
jmp 0x232ad
cvtsd2ss %xmm0, %xmm0
movq 0x18(%rsp), %rax
movss %xmm0, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
testl %edx, %edx
cmovlel %r13d, %ebp
xorl %r12d, %r12d
cmpl %r13d, %ebp
je 0x233b7
leaq 0x18(%r14), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24672
testl %eax, %eax
je 0x233ae
movslq %r12d, %r12
movl %r13d, (%r15,%r12,4)
incl %r12d
addq $0x70, %r14
incl %r13d
jmp 0x2338c
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2f818(%rip), %xmm0    # 0x52bf0
leal -0x48(%rax), %ecx
cmpl $0xb, %ecx
ja 0x233f9
leaq 0x2f795(%rip), %rax     # 0x52b7c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movss 0x27c18(%rip), %xmm0    # 0x4b010
retq
cmpl $0x43, %eax
je 0x23450
pushq %rax
addq $0x18, %rsi
leaq 0x2f98a(%rip), %rdi     # 0x52d94
xorl %eax, %eax
callq 0x20f0
movss 0x2f7d7(%rip), %xmm0    # 0x52bf0
addq $0x8, %rsp
retq
cmpb $0x45, 0x19(%rsi)
jne 0x23448
movss 0x2f7c8(%rip), %xmm0    # 0x52bf4
retq
movss 0x2f7cb(%rip), %xmm0    # 0x52c00
retq
movss 0x2f7c6(%rip), %xmm0    # 0x52c04
retq
movss 0x2f7b5(%rip), %xmm0    # 0x52bfc
retq
movss 0x2f7a8(%rip), %xmm0    # 0x52bf8
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rbp, %r13
shlq $0x2, %r13
movq %r13, %rdi
callq 0x21d0
movq %rax, %r15
movq %rax, (%rbx)
movq %r13, %rdi
callq 0x21d0
movq %rax, %r12
movq %rax, 0x8(%rbx)
movq %r13, %rdi
callq 0x21d0
movq %rax, 0x10(%rbx)
movq 0x50(%rsp), %rcx
movq 0x68(%rsp), %rdx
xorl %esi, %esi
testl %ebp, %ebp
movl $0x0, %edi
cmovgl %ebp, %edi
xorl %r13d, %r13d
cmpq %rsi, %rdi
je 0x234e5
movslq (%rdx,%rsi,4), %r8
imulq $0x70, %r8, %r9
movl 0x54(%r14,%r9), %r9d
testl %r9d, %r9d
js 0x234e0
movslq %r13d, %r13
movl %r8d, (%r15,%r13,4)
movl %r9d, (%r12,%r13,4)
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%r13,4)
incl %r13d
incq %rsi
jmp 0x234b0
leaq 0x2f7d8(%rip), %rdi     # 0x52cc4
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_O2/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 %rbx
movl 0x10(%rsp), %ecx
movq 0x68(%rsp), %rax
movq 0x38(%rsp), %r9
movl 0x40(%rsp), %r8d
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %r10d
cmovgl %ecx, %r10d
xorl %r11d, %r11d
cmpq %r10, %rsi
je 0x23562
movl (%r9,%rsi,4), %edx
movslq %r11d, %r11
decq %r11
movq %r11, %rbx
incq %r11
cmpl %edx, 0x4(%rax,%rbx,4)
jne 0x23548
cmpl %r11d, %r8d
jle 0x23564
movl %r11d, (%rdi,%rsi,4)
incq %rsi
jmp 0x23539
popq %rbx
retq
leaq 0x2f775(%rip), %rdi     # 0x52ce0
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdx), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
cmpq %r8, %rcx
je 0x23f0b
cmpq $0x0, 0x30(%rdx)
je 0x23ed4
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
cmpq %r9, %rax
je 0x23efd
movq 0x28(%rdx), %r10
movq (%r10,%r9,8), %r10
cvtss2sd (%rsi,%r9,4), %xmm1
mulsd (%r10,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %r9
jmp 0x23eb2
xorpd %xmm0, %xmm0
movq %rcx, %r9
cmpq %r9, %rax
je 0x23efd
movq 0x28(%rdx), %r10
movq (%r10,%r9,8), %r10
cvtss2sd (%rsi,%r9,4), %xmm1
mulsd (%r10,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %r9
jmp 0x23edb
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdi,%rcx,4)
incq %rcx
jmp 0x23e9f
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x40, %rsp
movq %rdi, %rbx
movss 0x30(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x23f7d
jp 0x23f7d
movl 0x4(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorpd %xmm3, %xmm3
cmpq %rcx, %rax
je 0x23f5e
movss (%rsi,%rcx,4), %xmm0
movq 0x8(%rbx), %rdx
movss (%rdx,%rcx,4), %xmm1
movaps %xmm0, %xmm2
mulss %xmm1, %xmm2
mulss %xmm1, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
cvtps2pd %xmm2, %xmm0
addpd %xmm0, %xmm3
incq %rcx
jmp 0x23f31
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
movapd %xmm3, %xmm0
divsd %xmm2, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x23f94
sqrtsd %xmm0, %xmm0
jmp 0x23faf
movss 0x3c(%rbx), %xmm1
cvtss2sd %xmm1, %xmm2
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm3
jmp 0x23fc1
movapd %xmm3, (%rsp)
movapd %xmm2, 0x10(%rsp)
callq 0x2290
movapd 0x10(%rsp), %xmm2
movapd (%rsp), %xmm3
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%rbx)
cvtsd2ss %xmm2, %xmm0
movss %xmm0, 0x3c(%rbx)
movl (%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorpd %xmm4, %xmm4
cmpq %rcx, %rax
je 0x23ff7
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rsi
movss (%rdx,%rcx,4), %xmm0
movss (%rsi,%rcx,4), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm1, %xmm1
cvtps2pd %xmm1, %xmm0
addpd %xmm0, %xmm4
incq %rcx
jmp 0x23fce
movapd %xmm4, %xmm0
unpckhpd %xmm4, %xmm0            # xmm0 = xmm0[1],xmm4[1]
movapd %xmm0, 0x20(%rsp)
divsd %xmm2, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movaps %xmm3, (%rsp)
movaps %xmm2, 0x10(%rsp)
jb 0x24021
sqrtsd %xmm0, %xmm0
jmp 0x24035
movapd %xmm4, 0x30(%rsp)
callq 0x2290
xorps %xmm1, %xmm1
movapd 0x30(%rsp), %xmm4
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x34(%rbx)
cvtsi2sdl (%rbx), %xmm0
divsd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jb 0x24052
sqrtsd %xmm4, %xmm0
jmp 0x2405b
movapd %xmm4, %xmm0
callq 0x2290
movapd (%rsp), %xmm2
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x38(%rbx)
movapd %xmm2, %xmm0
subsd 0x20(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x24089
sqrtsd %xmm0, %xmm0
jmp 0x24093
callq 0x2290
movapd (%rsp), %xmm2
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x2c(%rbx)
movapd 0x20(%rsp), %xmm0
divsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x3
popq %rbp
movl %ebp, %edi
movl %ebp, %esi
callq 0x43878
movq %rax, %r14
movq %rsp, %rdx
pushq $0x1
popq %r8
movl %ebp, %edi
movq %r15, %rsi
movq %rax, %rcx
callq 0x44825
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 0x24555
leaq 0x2e807(%rip), %rdi     # 0x52d2f
movb $0x1, %al
callq 0x20f0
movq (%r14), %rax
xorl %ecx, %ecx
movapd 0x26b84(%rip), %xmm0    # 0x4b0c0
cmpq $0x3, %rcx
je 0x24555
movsd (%rax,%rcx,8), %xmm1
xorpd %xmm0, %xmm1
movlpd %xmm1, (%rax,%rcx,8)
incq %rcx
jmp 0x2453c
xorl %eax, %eax
cmpq $0x3, %rax
je 0x24581
movq (%r14,%rax,8), %rcx
movq (%rbx,%rax,8), %rdx
xorl %esi, %esi
cmpq $0x3, %rsi
je 0x2457c
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x24567
incq %rax
jmp 0x24557
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x4372a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x3, %rax
je 0x245c0
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x245b0
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
xorps %xmm0, %xmm0
cmpq %r14, %rbp
je 0x2461d
movsd %xmm0, (%rsp)
movslq (%r15,%rbp,4), %rax
imulq $0x70, %rax, %r13
addq %r12, %r13
movq %r13, %rdi
callq 0x233c9
cvtss2sd %xmm0, %xmm2
xorl %eax, %eax
cmpq $0x3, %rax
je 0x2460f
movsd (%r13,%rax,8), %xmm1
mulsd %xmm2, %xmm1
addsd (%rbx,%rax,8), %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x245ef
movsd (%rsp), %xmm0
addsd %xmm2, %xmm0
incq %rbp
jmp 0x245cc
xorl %eax, %eax
cmpq $0x3, %rax
je 0x24638
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x2461f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x246a1
cmpl $0x41, %r8d
jne 0x246c3
cmpb $0x4c, 0x1(%rdx)
jne 0x246c3
cmpb $0x48, (%rdi)
setne %al
leaq 0x3f9cf(%rip), %rcx     # 0x64064
cmpl $0x0, (%rcx)
setne %cl
orb %al, %cl
movzbl %cl, %eax
retq
cmpb $0x42, 0x1(%rdx)
jne 0x246c3
cmpb $0x43, (%rdi)
jne 0x24702
pushq $0x1
popq %rax
cmpb $0x42, 0x1(%rdi)
je 0x24704
cmpb $0x47, 0x68(%rsi)
jne 0x24702
cmpb $0x41, 0x1(%rdi)
jne 0x24702
jmp 0x24704
movb (%rdi), %cl
pushq $0x1
popq %rax
cmpb $0x43, %cl
jne 0x246d3
cmpb $0x41, 0x1(%rdi)
je 0x24704
cmpl $0x45, %r8d
je 0x246f1
cmpl $0x42, %r8d
jne 0x24702
cmpb $0x42, 0x1(%rdx)
jne 0x24702
cmpb $0x4e, %cl
je 0x246fc
cmpb $0x43, %cl
je 0x246fc
jmp 0x24702
cmpb $0x42, 0x1(%rdx)
jne 0x24702
cmpb $0x4e, %cl
jne 0x24705
cmpb $0x20, 0x1(%rdi)
je 0x24704
xorl %eax, %eax
retq
cmpb $0x43, %cl
jne 0x24718
cmpb $0x20, 0x1(%rdi)
je 0x24704
cmpb $0x42, 0x1(%rdi)
jne 0x24702
jmp 0x24704
cmpb $0x4f, %cl
je 0x246fc
jmp 0x24702
// File: /workspace/github_c_makefile_star2_O2/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 %r8, %rbx
movq %rcx, %r14
movl %esi, %r15d
xorl %r13d, %r13d
testl %esi, %esi
cmovlel %r13d, %r15d
movl %edx, %r12d
testl %edx, %edx
cmovlel %r13d, %r12d
movq %rdi, (%rsp)
pushq $0x1
popq %rbp
cmpq %r12, %r13
je 0x24cbc
pushq $0x3
popq %rdi
movl %edi, %esi
callq 0x4379e
xorps %xmm2, %xmm2
movq (%rsp), %rcx
movq %rax, (%rcx,%r13,8)
imulq $0xc, %r13, %rcx
xorl %edx, %edx
cmpq %r15, %rdx
je 0x24c85
movss (%r14,%rdx,4), %xmm0
ucomiss %xmm2, %xmm0
jne 0x24c2e
jp 0x24c2e
incq %rdx
jmp 0x24c17
movq (%rbx,%rdx,8), %rsi
addq %rcx, %rsi
xorl %edi, %edi
movq %rbp, %r8
cmpq $0x3, %rdi
je 0x24c29
movss (%rsi,%rdi,4), %xmm0
movss (%r14,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp,%rdi,4)
movq (%rax,%rdi,8), %r9
xorl %r10d, %r10d
cmpq %r10, %r8
je 0x24c7d
movss 0xc(%rsp,%r10,4), %xmm1
mulss %xmm0, %xmm1
addss (%r9,%r10,4), %xmm1
movss %xmm1, (%r9,%r10,4)
incq %r10
jmp 0x24c5c
incq %rdi
incq %r8
jmp 0x24c3a
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x24cb4
movq %rcx, %rdx
cmpq $0x2, %rdx
je 0x24caf
movq 0x8(%rax,%rdx,8), %rsi
movss (%rsi,%rcx,4), %xmm0
movq (%rax,%rcx,8), %rsi
movss %xmm0, 0x4(%rsi,%rdx,4)
incq %rdx
jmp 0x24c90
incq %rcx
jmp 0x24c87
incq %r13
jmp 0x24bf3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl 0x8(%rdi), %r8d
movl 0xc(%rdi), %r9d
movq %rsp, %rax
leaq 0xf(,%r8,8), %rcx
andq $-0x10, %rcx
subq %rcx, %rax
movq %rax, %rsp
xorl %edx, %edx
testl %r8d, %r8d
movl $0x0, %ecx
cmovgl %r8d, %ecx
cmpq %rdx, %rcx
je 0x24d0b
andq $0x0, (%rax,%rdx,8)
incq %rdx
jmp 0x24cfc
movq %rsp, %rdx
leaq 0xf(,%r9,8), %r8
andq $-0x10, %r8
subq %r8, %rdx
movq %rdx, %rsp
xorl %r10d, %r10d
testl %r9d, %r9d
movl $0x0, %r8d
cmovgl %r9d, %r8d
cmpq %r10, %r8
je 0x24d3f
andq $0x0, (%rdx,%r10,8)
incq %r10
jmp 0x24d30
movl (%rdi), %r9d
xorl %r10d, %r10d
testl %r9d, %r9d
cmovlel %r10d, %r9d
xorps %xmm0, %xmm0
cmpq %r9, %r10
je 0x24dda
movq 0x28(%rdi), %r11
movss (%r11,%r10,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x24d6e
jp 0x24d6e
incq %r10
jmp 0x24d4f
movss (%rsi,%r10,4), %xmm1
movq 0x40(%rdi), %r11
movq (%r11,%r10,8), %r11
xorl %ebx, %ebx
cmpq %rbx, %rcx
je 0x24da7
movss (%r11,%rbx,4), %xmm2
movaps %xmm1, %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
cvtss2sd %xmm3, %xmm2
addsd (%rax,%rbx,8), %xmm2
movsd %xmm2, (%rax,%rbx,8)
incq %rbx
jmp 0x24d7e
movq 0x38(%rdi), %r11
movq (%r11,%r10,8), %r11
xorl %ebx, %ebx
cmpq %rbx, %r8
je 0x24d69
movss (%r11,%rbx,4), %xmm2
movaps %xmm1, %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
cvtss2sd %xmm3, %xmm2
addsd (%rdx,%rbx,8), %xmm2
movsd %xmm2, (%rdx,%rbx,8)
incq %rbx
jmp 0x24db1
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x24df5
cvtsd2ss (%rax,%rsi,8), %xmm0
movq 0x50(%rdi), %r9
movss %xmm0, (%r9,%rsi,4)
incq %rsi
jmp 0x24ddc
xorl %eax, %eax
cmpq %rax, %r8
je 0x24e0f
cvtsd2ss (%rdx,%rax,8), %xmm0
movq 0x58(%rdi), %rcx
movss %xmm0, (%rcx,%rax,4)
incq %rax
jmp 0x24df7
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq %rsp, %r13
xorl %ebp, %ebp
movl $0xc8, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x2110
leaq 0x2df95(%rip), %rsi     # 0x52de3
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x26e45(%rip), %rdi     # 0x4bca7
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x2c2dd(%rip), %rsi     # 0x51150
movq %r13, %rdi
callq 0x2210
movq %rax, %r12
leaq 0x2df6e(%rip), %rdi     # 0x52df3
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rcx
callq 0x2280
movq 0x150(%rsp), %r13
testl %r14d, %r14d
cmovlel %ebp, %r14d
addq $0x8, %r15
cmpq %rbp, %r14
je 0x24ef4
movq (%r15), %rax
movq (%rax), %rax
movslq 0x64(%rax), %rax
shlq $0x5, %rax
movsbl -0x8(%r15), %edx
leaq (%rbx,%rax), %rcx
addq $0xd, %rcx
movsbl -0x1(%rcx), %r8d
movsbl 0x6(%rcx), %r9d
cvtss2sd (%r13,%rbp,4), %xmm0
movq %r12, %rdi
leaq 0x2df38(%rip), %rsi     # 0x52e19
movb $0x1, %al
callq 0x2190
incq %rbp
addq $0x158, %r15            # imm = 0x158
jmp 0x24ea6
movq %r12, %rdi
callq 0x20c0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r13
xorl %r14d, %r14d
testl %esi, %esi
cmovlel %r14d, %r12d
addq $0x18, %r13
subl $0x1, %r12d
jb 0x24f75
leaq -0x18(%r13), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x24672
testl %eax, %eax
je 0x24f6c
movss 0x4(%r13), %xmm0
divss 0x2dcb9(%rip), %xmm0    # 0x52c14
movslq %r14d, %r14
movss %xmm0, (%r15,%r14,4)
incl %r14d
cmpl %ebp, %r14d
je 0x24f72
addq $0x70, %r13
jmp 0x24f34
movl %ebp, %r14d
leaq 0x2dead(%rip), %rdi     # 0x52e29
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_O2/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 $0x38, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %r14
movq %rcx, %r15
movl %edx, 0x10(%rsp)
movq %rdi, %rbx
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %esi
movl %esi, 0x14(%rsp)
leaq 0x20(%rdi), %r13
pushq $0xc
popq %rbp
movl $0x0, 0xc(%rsp)
cmpl 0x14(%rsp), %r12d
je 0x250ad
leaq 0x18(%rbx), %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rdx
callq 0x24672
testl %eax, %eax
je 0x2509d
movq %r12, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
pushq $0x18
popq %r12
movq %r12, %rdi
callq 0x21d0
movslq 0xc(%rsp), %rbx
movq %rax, (%r15,%rbx,8)
movq %r12, %rdi
callq 0x21d0
movq %rax, (%r14,%rbx,8)
movq %r13, 0x20(%rsp)
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x2507e
movq %rbp, %rdi
callq 0x21d0
movq (%r14,%rbx,8), %rcx
movq %rax, (%rcx,%r12,8)
movq %rbp, %rdi
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
cmpq $0x3, %rcx
je 0x25075
movss (%r13,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
jmp 0x2505e
incq %r12
addq $0xc, %r13
jmp 0x2502e
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0x10(%rsp), %eax
movq 0x30(%rsp), %rbx
movq 0x28(%rsp), %r12
movq 0x20(%rsp), %r13
je 0x250ad
addq $0x70, %rbx
incl %r12d
addq $0x70, %r13
jmp 0x24fd7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %esi, %esi
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %ebp, %ecx
movl %r15d, %edx
cmpq %rsi, %rcx
je 0x25518
movl $0x1, (%rax,%rsi,4)
incq %rsi
jmp 0x25507
xorl %esi, %esi
cmpq %rcx, %rsi
je 0x25572
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x25531
cmpl $0x0, (%rax,%rdi,4)
jne 0x25539
incq %rdi
jmp 0x25521
movq %rdx, %rdi
movl %edx, %r8d
jmp 0x2553c
movl %edi, %r8d
movss (%r14,%rdi,4), %xmm0
incq %rdi
cmpl %ebp, %edi
jge 0x25562
cmpl $0x0, (%rax,%rdi,4)
je 0x25542
movss (%r14,%rdi,4), %xmm1
ucomiss %xmm0, %xmm1
jb 0x25542
movl %edi, %r8d
movaps %xmm1, %xmm0
jmp 0x25542
movl %r8d, (%rbx,%rsi,4)
movslq %r8d, %rdi
andl $0x0, (%rax,%rdi,4)
incq %rsi
jmp 0x2551a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
cvtss2sd %xmm0, %xmm0
leaq 0x2d782(%rip), %rsi     # 0x530b9
movq %rdx, %rdi
movq %rcx, %rdx
movb $0x1, %al
callq 0x2190
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
leaq 0x2d781(%rip), %r13     # 0x530d6
cmpq %r12, %r14
je 0x25975
cvtss2sd (%r15,%r12,4), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movb $0x1, %al
callq 0x2190
incq %r12
jmp 0x25955
leaq 0x2c6cf(%rip), %rdi     # 0x5204b
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2280
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21e0