LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x32816
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x327f3
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x32955
imull $0x3, -0x30(%rbp), %eax
movl %eax, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x32931
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
leaq 0x59855(%rip), %rax     # 0x8c0b4
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x3286d
jmp 0x32923
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0x328d2
movq -0x50(%rbp), %rax
movss (%rax), %xmm0
movq -0x50(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x32897
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x48(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3283f
movsd -0x40(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3281d
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x351ad
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x37390
cmpl $0x0, %eax
je 0x35196
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3515d
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x351f6
movss 0x48b48(%rip), %xmm0    # 0x7dd34
movss %xmm0, -0x4(%rbp)
jmp 0x352cb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x35214
movss 0x48b3e(%rip), %xmm0    # 0x7dd48
movss %xmm0, -0x4(%rbp)
jmp 0x352cb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4f, %eax
jne 0x35232
movss 0x48b1c(%rip), %xmm0    # 0x7dd44
movss %xmm0, -0x4(%rbp)
jmp 0x352cb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x48, %eax
jne 0x3524d
movss 0x40e4a(%rip), %xmm0    # 0x76090
movss %xmm0, -0x4(%rbp)
jmp 0x352cb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x50, %eax
jne 0x35268
movss 0x48adf(%rip), %xmm0    # 0x7dd40
movss %xmm0, -0x4(%rbp)
jmp 0x352cb
movq -0x18(%rbp), %rdi
leaq 0x45c0c(%rip), %rsi     # 0x7ae7f
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x35291
movss 0x48ab2(%rip), %xmm0    # 0x7dd3c
movss %xmm0, -0x4(%rbp)
jmp 0x352cb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x352ac
movss 0x48a93(%rip), %xmm0    # 0x7dd38
movss %xmm0, -0x4(%rbp)
jmp 0x352cb
movq -0x18(%rbp), %rsi
leaq 0x48d74(%rip), %rdi     # 0x7e02b
movb $0x0, %al
callq 0x10d0
movss 0x48a6e(%rip), %xmm0    # 0x7dd34
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x353eb
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x54(%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x353db
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movl -0x20(%rbp), %esi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x353dd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35352
movl -0x18(%rbp), %esi
leaq 0x48b53(%rip), %rdi     # 0x7df48
movb $0x0, %al
callq 0x10d0
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
imull $0x3, -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0x354e0
jmp 0x3545b
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x28(%rcx), %rcx
movslq -0x10(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x35486
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3545b
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jl 0x354c4
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %esi
movq 0x28(%rcx), %rdx
movslq -0x10(%rbp), %rdi
movl (%rdx,%rdi,4), %edx
movl (%rcx), %ecx
movl (%rax), %r8d
leaq 0x48ab1(%rip), %rdi     # 0x7df64
movb $0x0, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3544a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/nma.c
// Function: Empty_Ref
void Empty_Ref(struct Reference *Ref){
  free(Ref->atom_num);
  free(Ref->mass_atom);
  free(Ref->mass_coord);
  free(Ref->mass_sqrt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x36662
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x365e7
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x365e5
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x36596
jmp 0x3663e
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3663c
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x365ed
jmp 0x3663e
movsd -0x30(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x36570
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x37237
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x37216
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x372eb
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
callq 0x351c0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x372db
movsd -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3729e
jmp 0x372dd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3723e
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x3731e
movsd -0x30(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x372f2
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
leaq 0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x10e0
leaq -0xf0(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x45ba0(%rip), %rsi     # 0x7e07a
movb $0x0, %al
callq 0x1200
leaq -0xf0(%rbp), %rsi
leaq 0x3efff(%rip), %rdi     # 0x774ee
movb $0x0, %al
callq 0x10d0
leaq -0xf0(%rbp), %rdi
leaq 0x43e6e(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
leaq 0x45b6c(%rip), %rsi     # 0x7e08a
movb $0x0, %al
callq 0x1150
movl $0x0, -0xfc(%rbp)
movl -0xfc(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x385ef
movq -0x110(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movslq -0xfc(%rbp), %rsi
imulq $0x158, %rsi, %rsi      # imm = 0x158
addq %rsi, %rdx
movq 0x8(%rdx), %rdx
movq (%rdx), %rdx
movslq 0x64(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq %rcx, -0x108(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movslq -0xfc(%rbp), %rdx
imulq $0x158, %rdx, %rdx      # imm = 0x158
addq %rdx, %rcx
movsbl (%rcx), %edx
movq -0x108(%rbp), %rcx
addq $0xd, %rcx
movq -0x108(%rbp), %rsi
movsbl 0xc(%rsi), %r8d
movq -0x108(%rbp), %rsi
movsbl 0x13(%rsi), %r9d
movq 0x50(%rax), %rax
movslq -0xfc(%rbp), %rsi
movss (%rax,%rsi,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x45adc(%rip), %rsi     # 0x7e0b0
movb $0x1, %al
callq 0x1150
movl -0xfc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xfc(%rbp)
jmp 0x3852f
movq -0xf8(%rbp), %rdi
callq 0x10a0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movss 0x4571f(%rip), %xmm0    # 0x7dd58
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x43e21(%rip), %xmm0    # 0x7c470
mulsd %xmm1, %xmm0
movss -0x2c(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movsd 0x43dd0(%rip), %xmm1    # 0x7c438
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x386e5
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x37390
cmpl $0x0, %eax
je 0x386ce
movq -0x8(%rbp), %rax
movss 0x1c(%rax), %xmm0
divss -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x386cc
jmp 0x386e5
jmp 0x386ce
movq -0x8(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3867c
movl -0x28(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x459cd(%rip), %rdi     # 0x7e0c0
movb $0x0, %al
callq 0x10d0
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3887b
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x37390
cmpl $0x0, %eax
je 0x38861
movl $0x18, %edi
callq 0x1180
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x18, %edi
callq 0x1180
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x3884c
movl $0xc, %edi
callq 0x1180
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0xc, %edi
callq 0x1180
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0x3883c
movq -0x8(%rbp), %rax
addq $0x20, %rax
movslq -0x30(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x387f2
jmp 0x3883e
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3879f
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x3885f
jmp 0x3887b
jmp 0x38861
movq -0x8(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3873c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x38ffd
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x38fdb
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x390d4
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3903c
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3902f
jmp 0x3903c
jmp 0x39031
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x39017
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, -0x28(%rbp)
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x34(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x390a9
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3909c
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x34(%rbp), %xmm0
jb 0x3909c
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, -0x28(%rbp)
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0x3909e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3905c
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39004
movq -0x30(%rbp), %rdi
callq 0x1040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3ac70
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3ac4c
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3ac01
movsd -0x30(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3abea
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3af66
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x41559(%rip), %xmm1    # 0x7c490
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0x3af59
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x3af5b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3af17
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1220
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/nma.c
// Function: Get_tors
int Get_tors(struct axe *axe, int naxe, int res, int a_ini){
  for(int a=a_ini; a<naxe; a++){
    if((axe[a].bond)->atom->res == res){
      return(a);
    }else if((axe[a].bond)->atom->res > res){
      return(-1);
    }
  }
  return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3b1d1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x158, %rcx, %rcx      # imm = 0x158
addq %rcx, %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x3b198
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3b1d8
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x158, %rcx, %rcx      # imm = 0x158
addq %rcx, %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
cmpl -0x18(%rbp), %eax
jle 0x3b1c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b1d8
jmp 0x3b1c4
jmp 0x3b1c6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3b167
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/Fit_B_factors.c
// Function: Compute_correlation
float Compute_correlation(float **Cart_mode, float *sigma2,
			  int N_modes, int i1, int i2)
{
  int ia, k1=3*i1, k2=3*i2;
  double corr=0;
  for(ia=0; ia< N_modes; ia++){
    if(sigma2[ia]==0)continue;
    float *x1=Cart_mode[ia]+k1;
    float *x2=Cart_mode[ia]+k2;
    double xx=x1[0]*x2[0]+x1[1]*x2[1]+x1[2]*x2[2];
    corr += xx*sigma2[ia];
  }
  return(corr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
imull $0x3, -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
imull $0x3, -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3c094
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3bfdb
jp 0x3bfdb
jmp 0x3c086
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movss (%rax), %xmm1
movq -0x40(%rbp), %rax
movss (%rax), %xmm2
movq -0x38(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x40(%rbp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x38(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x40(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3bfb3
movsd -0x30(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/Fit_B_factors.c
// Function: Print_data
void Print_data(float **X, float *Y, int N, int Npar, char *name){
  char nameout[100];
  sprintf(nameout, "%s_Bfact_data_fits.dat", name);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  int a,i;
  /*float *norm=malloc(Npar*sizeof(float)); 
  for(a=0; a<Npar; a++){
    double sum=0;
    for(i=0; i<N; i++)sum+=X[i][a]*X[i][a];
    norm[a]=sqrt(sum/N);
    }*/
  fprintf(file_out, "#Y ENM const x y z xx xy xz yy yz zz\n");
  for(i=0; i<N; i++){
    fprintf(file_out, "%.3f\t",Y[i]);
    for(a=0; a<Npar; a++)fprintf(file_out, "%.3f\t",X[i][a]);
    fprintf(file_out, "\n");
  }
  fclose(file_out);
  //free(norm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x421eb(%rip), %rsi     # 0x7e9fa
movb $0x0, %al
callq 0x1200
leaq -0x90(%rbp), %rdi
leaq 0x3fb4e(%rip), %rsi     # 0x7c372
callq 0x11b0
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rsi
leaq 0x3acb0(%rip), %rdi     # 0x774ee
movb $0x0, %al
callq 0x10d0
movq -0x98(%rbp), %rdi
leaq 0x421be(%rip), %rsi     # 0x7ea11
movb $0x0, %al
callq 0x1150
movl $0x0, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3c91f
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0xa0(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x421a2(%rip), %rsi     # 0x7ea37
movb $0x1, %al
callq 0x1150
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3c8f6
movq -0x98(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0xa0(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x9c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x42159(%rip), %rsi     # 0x7ea37
movb $0x1, %al
callq 0x1150
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x3c8a6
movq -0x98(%rbp), %rdi
leaq 0x41774(%rip), %rsi     # 0x7e078
movb $0x0, %al
callq 0x1150
movl -0xa0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa0(%rbp)
jmp 0x3c864
movq -0x98(%rbp), %rdi
callq 0x10a0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/Fit_B_factors.c
// Function: Find_outliers_mean
int Find_outliers_mean(int *outlier, float *y, int N, float sig){
  double y1=0; int i;
  for(i=0; i<N; i++)y1+=y[i];
  float max=sig*y1/N; int n=0;
  for(i=0; i<N; i++){
    if(outlier[i])continue;
    if(y[i]>max){outlier[i]=1; n++;}
  }
  return(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3c991
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3c963
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3ca0f
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3c9d7
jmp 0x3ca04
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x28(%rbp), %xmm0
jbe 0x3ca02
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3ca04
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3c9bf
movl -0x2c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/Fit_B_factors.c
// Function: Find_outliers_Z
int Find_outliers_Z(int *outlier, float *y, int N, float sig){
  double y1=0, y2=0; float *yy=y; int i;
  for(i=0; i<N; i++){
    y1+=*yy; y2+=(*yy)*(*yy); yy++;
  }
  y1/=N; y2=y2-N*y1*y1; if(N>1)y2=sqrt(y2/(N-1));
  float max=y1+sig*y2, min=y1-sig*y2; int n=0;
  for(i=0; i<N; i++){
    if(outlier[i])continue;
    if((y[i]>max)||(y[i]<min)){outlier[i]=1; n++;}
  }
  return(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3caaa
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
movq -0x30(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3ca57
cvtsi2sdl -0x14(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x3cb18
movsd -0x28(%rbp), %xmm0
movl -0x14(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x1220
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd -0x28(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3cbec
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3cb9d
jmp 0x3cbe1
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x38(%rbp), %xmm0
ja 0x3cbc7
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
movss -0x3c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x3cbdf
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3cbe1
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3cb85
movl -0x40(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/Fit_B_factors.c
// Function: Fit_no_outliers
float Fit_no_outliers(int *outlier, float *XX, float *YY, int N,
		      float *slope, float *offset)
{
  int k=0; float X[N], Y[N];
  for(int i=0; i<N; i++){
    if(outlier[i])continue;
    X[k]=XX[i]; Y[k]=YY[i]; k++;
  }
  float r=Corr_coeff(X, Y, k, slope, offset);
  return(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x1c(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x40(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x68(%rbp)
movq %rcx, %rsp
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rcx, %rsp
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3ccd4
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3cc8c
jmp 0x3ccc9
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq -0x54(%rbp), %rsi
movss (%rdx,%rsi,4), %xmm0
movslq -0x34(%rbp), %rdx
movss %xmm0, (%rcx,%rdx,4)
movq -0x18(%rbp), %rcx
movslq -0x54(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x3cc74
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x15750
movss %xmm0, -0x58(%rbp)
movss -0x58(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/ridge_regression.c
// Function: Compute_error
float Compute_error(float Lambda, float *lambda, float *ya2, float Y2, int P)
{
  double H1=0, H2l=0; int a;
  for(a=0; a<P; a++){
    float laLa=lambda[a]+Lambda;
    float yl=ya2[a]/laLa; H1+=yl;
    H2l+=yl*lambda[a]/laLa;
  }
  return(Y2-(H1*H1/H2l));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm1, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3e979
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
addss -0x4(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
divss -0x38(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movss -0x3c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
divss -0x38(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3e900
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd -0x28(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
divsd -0x30(%rbp), %xmm1
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/confchange.c
// Function: Select_cc2
int Select_cc2(float *dx2, int nres1, float *Dcart, atom *atoms1,
	       struct Reference Ref, char *name)
{
  int n=0, i, j;
  for(i=0; i<Ref.N_ref; i++){
    if(strncmp(atoms1[Ref.atom_num[i]].name, name, 2)!=0)continue;
    float *Dc=Dcart+3*i; double d2=0;
    for(j=0; j<3; j++){d2+=(*Dc)*(*Dc); Dc++;}
    dx2[n]=d2; n++;
    if(n > nres1){
      printf("ERROR in Select_cc2, too many %s atoms > %d residues\n",
	     name, nres1); return(0);
    }
  }
  if(n!=nres1){
    printf("WARNING in Select_cc2, %d %s atoms but %d residues\n",
	   n, name, nres1);
  }
  return(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x58(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl (%rcx), %eax
jge 0x4169c
movq -0x58(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x28(%rax), %rax
movslq -0x38(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x415e7
jmp 0x4168e
movq -0x20(%rbp), %rax
imull $0x3, -0x38(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x41647
movq -0x48(%rbp), %rax
movss (%rax), %xmm0
movq -0x48(%rbp), %rax
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4160c
movsd -0x50(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x4168c
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x3e66e(%rip), %rdi     # 0x7fcea
movb $0x0, %al
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x416c2
jmp 0x4168e
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x415a1
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x416bc
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0x3e66b(%rip), %rdi     # 0x7fd20
movb $0x0, %al
callq 0x10d0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/confchange.c
// Function: Periodic_angles
int Periodic_angles(double *dphi, struct axe *axe, int n)
{
  float pi=acos(-1), twopi=2*pi; int m=0;
  for(int i=0; i<n; i++){
    if(axe[i].type=='l')continue;
    if((dphi[i]<=pi)&&(dphi[i]>=-pi))continue;
    while(dphi[i]>pi)dphi[i]-=twopi;
    while(dphi[i]<-pi)dphi[i]+=twopi;
    m++;
  }
  printf("%d angles > pi=%.5f changed\n", m, pi);
  return(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd 0x32005(%rip), %xmm0    # 0x76030
callq 0x1110
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x32053(%rip), %xmm0    # 0x76094
mulss -0x18(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4416c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x158, %rcx, %rcx      # imm = 0x158
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0x44084
jmp 0x4415e
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x440ce
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movss -0x18(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x440ce
jmp 0x4415e
jmp 0x440d0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4410d
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x440d0
jmp 0x4410f
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movss -0x18(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44155
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x4410f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x44059
movl -0x20(%rbp), %esi
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3bbd5(%rip), %rdi     # 0x7fd54
movb $0x1, %al
callq 0x10d0
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/confchange.c
// Function: RMS
float RMS(float *v, int n, int *outlier){
  double RMS=0; int m=n;
  for(int i=0; i<n; i++){
    if(outlier && (outlier[i])){m--; continue;}
    RMS+=v[i]*v[i];
  }
  RMS=sqrt(RMS/m);
  return(RMS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x44213
cmpq $0x0, -0x18(%rbp)
je 0x441e0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x441e0
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x44208
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x441b8
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x1220
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/confchange.c
// Function: RMSD_confchange
float RMSD_confchange(float cc, float *mode, double *d_phi,
		      float *coord_all, float *coord_new,
		      double *d_phi_opt, int naxes, struct bond *bonds,
		      atom *atoms, int natoms, struct Reference Ref,
		      float *coord_2)
{
  // angular distance
  for(int i=0; i<naxes; i++)d_phi[i]=d_phi_opt[i]+cc*mode[i];
  Set_bonds_measure(bonds, natoms, atoms);
  Build_up(bonds, natoms, d_phi, naxes);
  Put_coord(coord_all, bonds, natoms);
  Write_ref_coord(coord_new, Ref.N_ref, coord_all, Ref.atom_num);
  float rmsd2=rmsd_mclachlan_f(coord_2, coord_new, Ref.mass_atom, Ref.N_ref);
  return(rmsd2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x58(%rbp), %rax
leaq 0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x46f7a
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movss -0x4(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x46f33
movq 0x10(%rbp), %rdi
movl 0x20(%rbp), %esi
movq 0x18(%rbp), %rdx
callq 0x1bf00
movq 0x10(%rbp), %rdi
movl 0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x1c4f0
movq -0x20(%rbp), %rdi
movq 0x10(%rbp), %rsi
movl 0x20(%rbp), %edx
callq 0x49770
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rdi
movl (%rax), %esi
movq -0x20(%rbp), %rdx
movq 0x28(%rax), %rcx
callq 0x4a1d0
movq -0x48(%rbp), %rax
movq 0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq 0x10(%rax), %rdx
movl (%rax), %ecx
callq 0x70af0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop