LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/simulation.c
// Function: Test_buildup
float Test_buildup(struct bond *bonds, atom *atoms, int natoms, int naxes)
{
  printf("Testing build up\n");
  // Compute new conformation
  float coord_old[3*natoms], coord_new[3*natoms];
  Set_bonds_measure(bonds, natoms, atoms);
  Put_coord(coord_old, bonds, natoms);
  Build_up(bonds, natoms, NULL, naxes);
  Put_coord(coord_new, bonds, natoms);
  float mass[natoms]; for(int i=0; i<natoms; i++)mass[i]=1;
  float RMSD=rmsd_mclachlan_f(coord_old, coord_new, mass, natoms);
  printf("RMSD with no torsion change: %.2g\n", RMSD);
  if(RMSD > 0.5){
    printf("ERROR in Test_buildup, RMSD= %.2f\n", RMSD);
    exit(8);
  }
  return(RMSD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r12
leaq 0x219b3(%rip), %rdi     # 0x55cda
callq 0x2090
leal (%rbx,%rbx,2), %eax
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
movq %rsp, %r14
subq %rax, %r14
movq %r14, %rsp
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
movq %r12, %rdi
movl %ebx, %esi
movq %r13, %rdx
callq 0x139f6
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x2f358
xorl %r13d, %r13d
movq %r12, %rdi
movl %ebx, %esi
xorl %edx, %edx
movl -0x2c(%rbp), %ecx
callq 0x13d70
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x2f358
movl %ebx, %eax
movq %rsp, %rdx
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %rdx
movq %rdx, %rsp
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
cmpq %r13, %rax
je 0x343b9
movl $0x3f800000, (%rdx,%r13,4) # imm = 0x3F800000
incq %r13
jmp 0x343a7
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %ecx
callq 0x47a64
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
cvtss2sd %xmm0, %xmm0
leaq 0x212bf(%rip), %rdi     # 0x55699
movsd %xmm0, -0x38(%rbp)
movb $0x1, %al
callq 0x20f0
movss -0x2c(%rbp), %xmm0
ucomiss 0x1b722(%rip), %xmm0    # 0x4fb14
ja 0x34403
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x212b2(%rip), %rdi     # 0x556bc
movsd -0x38(%rbp), %xmm0
movb $0x1, %al
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/simulation.c
// Function: Test_standard
int Test_standard(struct bond *bonds, int natoms){
  int n=0;
  for(int i=0; i<natoms; i++){
    struct bond *bond=bonds+i;
    if((bond->len>=0)||(bond->angle>=0))continue;  // exclude pseudo-bonds
    if(bond->previous==NULL)continue;
    int na=Atom_type(bond->atom->name);
    if((na<0)||(na>4))continue;
    float d1=bond->l-BB_length[na], d2;
    if(bond->previous->previous){
      d2=bond->r_cos_theta/bond->l-cos(BB_angle[na]);
    }else{
      d2=0;
    }
    if((fabs(d1)>0.01)||(fabs(d2)>0.01)){
      printf("WARNING %c%d %s %.3f %.3f\n",
	     bond->atom->aa, bond->atom->res+1, bond->atom->name, d1, d2);
      n++;
    }
  }
  if(n){
    printf("WARNING, %d errors in standardize bonds\n", n); return(n);
  }
  printf("Standard bonds successfully tested\n");
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %esi
movq %rdi, %r14
imulq $0xc0, %rsi, %r13
leaq 0x2f271(%rip), %rbp     # 0x64e50
leaq 0x2f28a(%rip), %r15     # 0x64e70
xorl %ebx, %ebx
cmpq %r12, %r13
je 0x35ce5
cmpl $0x0, 0x34(%r14,%r12)
jns 0x35c01
cmpl $0x0, 0x38(%r14,%r12)
js 0x35c0a
addq $0xc0, %r12
jmp 0x35be8
cmpq $0x0, 0x28(%r14,%r12)
je 0x35c01
movq (%r14,%r12), %rdi
addq $0x18, %rdi
callq 0xf464
cmpl $0x4, %eax
ja 0x35c01
movl %eax, %eax
cvtss2sd (%rbp,%rax,4), %xmm0
movsd 0x58(%r14,%r12), %xmm2
movq 0x28(%r14,%r12), %rcx
cmpq $0x0, 0x28(%rcx)
je 0x35c85
movsd 0x60(%r14,%r12), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
movsd %xmm0, 0x10(%rsp)
cvtss2sd (%r15,%rax,4), %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x2130
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
jmp 0x35c88
xorps %xmm1, %xmm1
subsd %xmm0, %xmm2
cvtsd2ss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movaps %xmm0, %xmm2
movaps 0x1b5a2(%rip), %xmm3    # 0x51240
andps %xmm3, %xmm2
movsd 0x1b5e7(%rip), %xmm4    # 0x51290
ucomisd %xmm4, %xmm2
ja 0x35cbf
movaps %xmm1, %xmm2
andps %xmm3, %xmm2
ucomisd %xmm4, %xmm2
jbe 0x35c01
movq (%r14,%r12), %rcx
movsbl 0x68(%rcx), %esi
movl 0x64(%rcx), %edx
incl %edx
addq $0x18, %rcx
leaq 0x1fd79(%rip), %rdi     # 0x55a50
movb $0x2, %al
callq 0x20f0
incl %ebx
jmp 0x35c01
testl %ebx, %ebx
je 0x35cfb
leaq 0x1fd7b(%rip), %rdi     # 0x55a6b
movl %ebx, %esi
xorl %eax, %eax
callq 0x20f0
jmp 0x35d07
leaq 0x2003f(%rip), %rdi     # 0x55d41
callq 0x2090
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/simulation.c
// Function: Compute_RMSD
float Compute_RMSD(float f, float *Diff_Tors, int naxes,
		   struct bond *bonds_ini, struct bond *bonds, int natoms1,
		   struct Reference Ref1, float *coord_ref_2)
{
  double diff_tors[naxes];
  for(int i=0; i<naxes; i++)diff_tors[i]=f*Diff_Tors[i];
  Copy_bonds(bonds, bonds_ini, natoms1);
  Build_up(bonds, natoms1, diff_tors, naxes);
  float coord_all[3*natoms1];
  Put_coord(coord_all, bonds, natoms1);
  float coord_new[Ref1.N_Cart];
  Write_ref_coord(coord_new, Ref1.N_ref, coord_all, Ref1.atom_num);
  float RMSD=
    rmsd_mclachlan_f(coord_ref_2, coord_new, Ref1.mass_atom, Ref1.N_ref);
  return(RMSD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movl %r8d, %r14d
movq %rcx, %r15
movl %esi, %r12d
leaq 0x10(%rbp), %rbx
movl %esi, %eax
movq %rsp, %r13
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rax, %rcx
je 0x3619e
movss (%rdi,%rax,4), %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, (%r13,%rax,8)
incq %rax
jmp 0x36180
movq %r15, %rdi
movq %rdx, %rsi
movl %r14d, %edx
callq 0x301ca
movq %r15, %rdi
movl %r14d, %esi
movq %r13, %rdx
movl %r12d, %ecx
callq 0x13d70
leal (%r14,%r14,2), %eax
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
movq %rsp, %r12
subq %rax, %r12
movq %r12, %rsp
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x2f358
movl 0x4(%rbx), %eax
movq %rsp, %r14
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movl (%rbx), %r15d
movq 0x28(%rbx), %rcx
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x2f9b8
movq 0x10(%rbx), %rdx
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %ecx
callq 0x47a64
cvtsd2ss %xmm0, %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/force2confchange.c
// Function: Read_force
int Read_force(float *Force_input_cart, atom *atoms1,
	       int *atom_num1, int N_ref, char *FILE_FORCE)
{
  FILE *file_in=fopen(FILE_FORCE, "r");
  int iref=0, res; float f1, f2, f3;
  char name[20], aa1[5], string[1000];
  if(file_in==NULL){
    printf("ERROR, I could not find file with input force %s\n",
	   FILE_FORCE); return(-1);
  }
  while(fgets(string, sizeof(string), file_in)!=NULL){
    sscanf(string, "%s%s%d%f%f%f", name, aa1, &res, &f1, &f2, &f3);
    if(Find_atom_seq1(&iref, name, aa1, res, atoms1,atom_num1, N_ref)<0){
      printf("ERROR, reference number not found for %s", string);
      return(-1);
    }
    Force_input_cart[3*iref]=f1;
    Force_input_cart[3*iref+1]=f2;
    Force_input_cart[3*iref+2]=f3;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %r8, %r15
movq %rdi, %rbx
leaq 0x1d747(%rip), %rsi     # 0x53dde
movq %r8, %rdi
callq 0x2210
testq %rax, %rax
je 0x36729
movq %rax, %r14
leaq 0x40(%rsp), %r15
leaq 0x1b(%rsp), %rbp
leaq 0x14(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdx
callq 0x2170
testq %rax, %rax
je 0x36725
movq %r15, %rdi
leaq 0x1f7cb(%rip), %rsi     # 0x55ea9
leaq 0x20(%rsp), %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r13, %r9
xorl %eax, %eax
leaq 0x8(%rsp), %r10
pushq %r10
leaq 0x14(%rsp), %r10
pushq %r10
callq 0x21f0
popq %rcx
popq %rdx
movss 0x10(%rsp), %xmm0
movss %xmm0, (%rbx)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rbx)
jmp 0x366bf
xorl %eax, %eax
jmp 0x3673d
leaq 0x1f747(%rip), %rdi     # 0x55e77
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
pushq $-0x1
popq %rax
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/mutation.c
// Function: Mut_neighbor
int Mut_neighbor(int *mut_neigh, int Na,
		 char *AAwt, int *Posmut, char *AAmut, int Nmut,
		 int **clist, int **cnum, struct interaction *Int_list,
		 atom *atoms, int nres)
{
  int i, iter;
  for(i=0; i<Na; i++)mut_neigh[i]=0;
  for(int kmut=0; kmut<Nmut; kmut++){
    int pmut=Posmut[kmut];
    int aaw=Code_AA(AAwt[kmut]);   // wild-type aa
    int aam=Code_AA(AAmut[kmut]);  // mutated aa
    if((aaw==20)||(aam==20)){pmut--; iter=2;} //
    else{iter=1;}
    for(int it=0; it<iter; it++){
      if(pmut<0)continue;
      if(it==1){pmut=Posmut[kmut]+1; if(pmut>=nres)continue;}
      int *ii=cnum[pmut];  // interaction label of the contact
      int *ic=clist[pmut]; // residue in contact with pmut
      while(*ic >= 0){
	//if(abs(pmut-(*ic))<3)goto next; // short range contact discarded
	int res1=atoms[Int_list[*ii].i1].res, res2=atoms[Int_list[*ii].i2].res;
	if((res1 !=pmut)&&(res2!=pmut)){
	  printf("ERROR in mutation, interaction %d res %d - %d pmut= %d\n",
		 *ii, res1, res2, pmut); exit(8);
	}
	mut_neigh[res1]=1;
	mut_neigh[res2]=1;
	ic++; ii++;
      }
    }
  }
  int n=0; for(i=0; i<Na; i++)if(mut_neigh[i])n++;
  return(n-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %r11
movq %rdx, 0x18(%rsp)
movq %rdi, %r14
movq 0x88(%rsp), %rbx
movq 0x80(%rsp), %r15
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rax, %rsi
je 0x38847
andl $0x0, (%r14,%rax,4)
incq %rax
jmp 0x38838
movq %rsi, 0x10(%rsp)
xorl %r13d, %r13d
testl %r9d, %r9d
cmovlel %r13d, %r9d
movq %r9, 0x30(%rsp)
pushq $0x1
popq %rbp
movq %r11, 0x20(%rsp)
cmpq 0x30(%rsp), %r13
je 0x38944
movl (%r11,%r13,4), %r12d
movq 0x18(%rsp), %rax
movsbl (%rax,%r13), %edi
callq 0x1d91c
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax,%r13), %edi
callq 0x1d91c
movq 0x20(%rsp), %r11
cmpl $0x14, 0xc(%rsp)
sete %cl
cmpl $0x14, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
subl %eax, %r12d
incl %eax
xorl %edi, %edi
cmpl %eax, %edi
je 0x3893c
testl %r12d, %r12d
js 0x38935
cmpl $0x1, %edi
jne 0x388d6
movl (%r11,%r13,4), %r12d
incl %r12d
cmpl 0x90(%rsp), %r12d
jge 0x38935
movslq %r12d, %rcx
movq 0x78(%rsp), %rdx
movq (%rdx,%rcx,8), %r8
movq 0x70(%rsp), %rdx
movq (%rdx,%rcx,8), %r9
xorl %r10d, %r10d
cmpl $0x0, (%r9,%r10)
js 0x38935
movslq (%r8,%r10), %rsi
imulq $0xc8, %rsi, %rcx
movslq (%r15,%rcx), %rdx
imulq $0x70, %rdx, %rdx
movslq 0x64(%rbx,%rdx), %rdx
movslq 0x4(%r15,%rcx), %rcx
imulq $0x70, %rcx, %rcx
movl 0x64(%rbx,%rcx), %ecx
cmpl %r12d, %edx
je 0x38924
cmpl %r12d, %ecx
jne 0x38970
movslq %ecx, %rcx
movl %ebp, (%r14,%rdx,4)
movl %ebp, (%r14,%rcx,4)
addq $0x4, %r10
jmp 0x388ee
incl %edi
jmp 0x388b3
incq %r13
jmp 0x38863
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x10(%rsp), %rdx
cmpq %rcx, %rdx
je 0x3895f
cmpl $0x1, (%r14,%rcx,4)
sbbl $-0x1, %eax
incq %rcx
jmp 0x3894d
decl %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1dc8f(%rip), %rdi     # 0x56606
movl %r12d, %r8d
xorl %eax, %eax
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/mutation.c
// Function: Compute_mut_def
void Compute_mut_def(float *pred_mut_Cart, int N_Cart,
		     float *pred_mut_Tors, int N_axes,
		     float *DE, float *Force_coeff, float *Force,
		     struct Normal_Mode NM, float *sigma2, float mass)
{
  int a, i;
  for(i=0; i<N_Cart; i++)pred_mut_Cart[i]=0;
  for(i=0; i<N_axes; i++)pred_mut_Tors[i]=0;

  /*double F=0;
  for(i=0; i<N_Cart; i++){F+=Force[i]*Force[i];}
  printf("RMS of mutational force: %.3f\n", sqrt(3*F/N_Cart)); */
  double DE_tmp=0;

  // Compute predicted deformation of kinetic atoms (Cart)
  for(a=0; a<NM.N; a++){
    if((NM.Cart_coll[a]<COLL_THR_MUT)||(sigma2[a]<=0)){
      Force_coeff[a]=0; continue;
    }
    float *f=Force, *x=NM.Cart[a];
    double xf=0; // Projection of force on normal mode
    for(i=0; i<N_Cart; i++){xf+=(*x)*(*f); x++; f++;}
    Force_coeff[a]=xf;
    //(*DE)+=xf*xf/sigma2[a];
    DE_tmp+=xf*xf*sigma2[a]; // OK
    xf*=sigma2[a];
    float *m=pred_mut_Cart; x=NM.Cart[a];
    for(i=0; i<N_Cart; i++){
      (*m)+=(*x)*xf; x++; m++;
    }
    m=pred_mut_Tors; x=NM.Tors[a];
    for(i=0; i<N_axes; i++){
      (*m)+=(*x)*xf; x++; m++;
    }
  }
  *DE=DE_tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x110(%rsp), %rax
leaq 0x40(%rsp), %r15
movq 0x38(%rsp), %r10
xorl %r11d, %r11d
testl %esi, %esi
cmovlel %r11d, %esi
cmpq %r11, %rsi
je 0x3a150
andl $0x0, (%rdi,%r11,4)
incq %r11
jmp 0x3a141
xorl %r11d, %r11d
testl %ecx, %ecx
cmovlel %r11d, %ecx
cmpq %r11, %rcx
je 0x3a168
andl $0x0, (%rdx,%r11,4)
incq %r11
jmp 0x3a159
movl (%r15), %r11d
movq 0x68(%r15), %rbx
movq 0x38(%r15), %r14
movq 0x40(%r15), %r15
xorl %r12d, %r12d
testl %r11d, %r11d
cmovlel %r12d, %r11d
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
cmpq %r11, %r12
je 0x3a255
movss 0x29db3(%rip), %xmm2    # 0x63f4c
ucomiss (%rbx,%r12,4), %xmm2
ja 0x3a1ce
ucomiss (%rax,%r12,4), %xmm1
jae 0x3a1ce
movq (%r14,%r12,8), %r13
xorps %xmm2, %xmm2
xorl %ebp, %ebp
cmpl %ebp, %esi
je 0x3a1d5
movss (%r13,%rbp,4), %xmm3
mulss (%r10,%rbp,4), %xmm3
cvtss2sd %xmm3, %xmm3
addsd %xmm3, %xmm2
incq %rbp
jmp 0x3a1b0
andl $0x0, (%r9,%r12,4)
jmp 0x3a24d
cvtsd2ss %xmm2, %xmm3
movss %xmm3, (%r9,%r12,4)
cvtss2sd (%rax,%r12,4), %xmm3
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
xorl %ebp, %ebp
cmpl %ebp, %esi
je 0x3a215
cvtss2sd (%r13,%rbp,4), %xmm5
cvtss2sd (%rdi,%rbp,4), %xmm6
mulsd %xmm4, %xmm5
addsd %xmm6, %xmm5
cvtsd2ss %xmm5, %xmm5
movss %xmm5, (%rdi,%rbp,4)
incq %rbp
jmp 0x3a1ef
mulsd %xmm2, %xmm2
movq (%r15,%r12,8), %r13
xorl %ebp, %ebp
cmpl %ebp, %ecx
je 0x3a245
cvtss2sd (%r13,%rbp,4), %xmm5
cvtss2sd (%rdx,%rbp,4), %xmm6
mulsd %xmm4, %xmm5
addsd %xmm6, %xmm5
cvtsd2ss %xmm5, %xmm5
movss %xmm5, (%rdx,%rbp,4)
incq %rbp
jmp 0x3a21f
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm0
incq %r12
jmp 0x3a188
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/mutation.c
// Function: Convert_to_tors
float *Convert_to_tors(float *Cart, int N3, float **J_ar, int N_axes)
{
  // Torsional force = J^t f = sum_i dr_i/dphi_a f_i
  float *Tors=malloc(N_axes*sizeof(float)); int a, i;
  for(a=0; a<N_axes; a++){
    double sum=0; float *J=J_ar[a], *f=Cart;
    for(i=0; i<N3; i++){sum+=(*J)*(*f); J++; f++;}
    Tors[a]=sum;
  }
  return(Tors);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movslq %ecx, %r12
leaq (,%r12,4), %rdi
callq 0x21d0
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
testl %r12d, %r12d
cmovlel %ecx, %r12d
cmpq %r12, %rcx
je 0x3a2fa
movq (%rbx,%rcx,8), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpl %esi, %r14d
je 0x3a2ec
movss (%rdx,%rsi,4), %xmm1
mulss (%r15,%rsi,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x3a2cf
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
jmp 0x3a2c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/mutation.c
// Function: Cosine
float Cosine(float *scale, float *xx, float *yy, int n)
{
  double sum_xy=0, sum_x2=0, sum_y2=0;
  float *x=xx, *y=yy;
  for(int i=0; i<n; i++){
    sum_xy+=(*x)*(*y);
    sum_x2+=(*x)*(*x);
    sum_y2+=(*y)*(*y);
    x++; y++;
  }
  if(sum_x2){
    *scale=sqrt(sum_y2/sum_x2);
    return(sum_xy/sqrt(sum_x2*sum_y2));
  }else{
    *scale=0;
    return(0);
  }
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
xorpd %xmm4, %xmm4
xorpd %xmm3, %xmm3
cmpl %eax, %ecx
je 0x3a34c
movss (%rsi,%rax,4), %xmm0
movss (%rdx,%rax,4), %xmm1
movaps %xmm0, %xmm2
mulss %xmm1, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm3
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm1, %xmm1
cvtps2pd %xmm1, %xmm0
addpd %xmm0, %xmm4
incq %rax
jmp 0x3a31d
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2            # xmm2 = xmm2[1],xmm4[1]
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x3a35f
jnp 0x3a379
movapd %xmm4, %xmm0
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
movsd %xmm3, 0x8(%rsp)
jb 0x3a382
sqrtsd %xmm0, %xmm0
jmp 0x3a39f
andl $0x0, (%rbx)
xorpd %xmm0, %xmm0
jmp 0x3a3d1
movapd %xmm4, 0x20(%rsp)
movapd %xmm2, 0x10(%rsp)
callq 0x2290
movapd 0x10(%rsp), %xmm2
movapd 0x20(%rsp), %xmm4
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx)
mulsd %xmm4, %xmm2
xorps %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x3a3ba
sqrtsd %xmm2, %xmm0
jmp 0x3a3c3
movapd %xmm2, %xmm0
callq 0x2290
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/mutation.c
// Function: Extract_reference_atoms
int Extract_reference_atoms(int *resatom, atom *atoms, int natoms,
			    struct residue *seq, int Nres)
{
  char SEL[4]="CA"; if(strcmp(REF_CC, "CB")==0)strcpy(SEL, "CB");
  int Na=0; 
  // resatom[i]= Reference atom for residue i
  // Center of mass and inertia tensor

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, 0x10(%rsp)
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movl $0x4143, (%rsp)         # imm = 0x4143
leaq 0x2960e(%rip), %rdi     # 0x64e94
leaq 0xf903(%rip), %rsi      # 0x4b190
pushq $0x3
popq %rdx
callq 0x2200
testl %eax, %eax
jne 0x3b8a4
movb $0x0, 0x2(%rsp)
movw $0x4243, (%rsp)         # imm = 0x4243
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
addq $0x18, %r12
movq %rsp, %rbx
pushq $0x2
popq %r13
xorl %ebp, %ebp
cmpq %r14, %r15
je 0x3b90d
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2070
testl %eax, %eax
je 0x3b8f6
movslq 0x4c(%r12), %rax
shlq $0x5, %rax
movq 0x10(%rsp), %rcx
cmpb $0x47, 0x13(%rcx,%rax)
jne 0x3b904
cmpb $0x43, (%r12)
jne 0x3b904
cmpb $0x41, 0x1(%r12)
jne 0x3b904
movslq %ebp, %rbp
movq 0x8(%rsp), %rax
movl %r14d, (%rax,%rbp,4)
incl %ebp
incq %r14
addq $0x70, %r12
jmp 0x3b8bb
movl 0x4(%rsp), %ebx
cmpl %ebx, %ebp
je 0x3b927
leaq 0x1a663(%rip), %rdi     # 0x55f7f
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x20f0
cmpl %ebx, %ebp
jle 0x3b939
leaq 0x1b22c(%rip), %rdi     # 0x56b5e
callq 0x2090
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/Fit.c
// Function: Fit_1
float Fit_1(float *Y, float *X0, int N, float *A0, float *bias)
{
  float mu1=0;
  // 0: do not allow offset 1: do not penalize offset 0.5: penalize

  // Fit Y=XA with X=(1*n) setting bias b=0
  // and evaluating it as b=<Y>-<X>A
  // A=<X^T X>^{-1}<X^T Y>
  float *x[1]; x[0]=X0; int i;
  if(1){ // Compute also for variable X1, which is the same at all calls
    Y1=0; Y2=0; for(i=0; i<N; i++){Y1+=Y[i]; Y2+=Y[i]*Y[i];}
    Y1/=N; Y2=sqrt(Y2/N-Y1*Y1); 
  }

  int a=0;
  float *xa=x[a];
  double s=0; for(i=0; i<N; i++){s+=xa[i];} X_ave[a]=s/N;
  //s=0; for(i=0; i<N; i++){s+=xa[i]*xa[i];}
  //X_dev[a]=sqrt(s/N-X_ave[a]*X_ave[a]);
  s=0; for(i=0; i<N; i++){s+=xa[i]*Y[i];}
  corr_y[a]=s/N-X_ave[a]*Y1;
  s=0; for(i=0; i<N; i++){s+=xa[i]*xa[i];}
  Corr[a][a]=s/N-mu1*X_ave[a]*X_ave[a];

  double A=corr_y[a]/Corr[0][0];
  double r2=A*corr_y[a];
  (*bias)=Y1-X_ave[a]*A;
  *A0=A;

  return(sqrt(r2/Y2));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %r13d
cmovgl %edx, %r13d
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
cmpq %rax, %r13
je 0x3bc4d
movss (%r12,%rax,4), %xmm2
cvtss2sd %xmm2, %xmm3
addsd %xmm3, %xmm1
movsd %xmm1, 0x39dfc(%rip)    # 0x75a30
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, 0x39df0(%rip)    # 0x75a38
incq %rax
jmp 0x3bc19
cvtsi2sd %edx, %xmm6
divsd %xmm6, %xmm1
movsd %xmm1, 0x39dd3(%rip)    # 0x75a30
divsd %xmm6, %xmm0
mulsd %xmm1, %xmm1
subsd %xmm1, %xmm0
xorpd %xmm7, %xmm7
ucomisd %xmm7, %xmm0
jb 0x3bc79
sqrtsd %xmm0, %xmm0
jmp 0x3bc8e
movsd %xmm6, 0x8(%rsp)
callq 0x2290
xorpd %xmm7, %xmm7
movsd 0x8(%rsp), %xmm6
movsd %xmm0, 0x39da2(%rip)    # 0x75a38
xorl %eax, %eax
cmpq %rax, %r13
je 0x3bcac
cvtss2sd (%r15,%rax,4), %xmm1
addsd %xmm1, %xmm7
incq %rax
jmp 0x3bc98
divsd %xmm6, %xmm7
movsd %xmm7, 0x39d88(%rip)    # 0x75a40
xorpd %xmm1, %xmm1
xorl %eax, %eax
cmpq %rax, %r13
je 0x3bcdc
movss (%r15,%rax,4), %xmm2
mulss (%r12,%rax,4), %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm1
incq %rax
jmp 0x3bcbe
divsd %xmm6, %xmm1
movsd 0x39d48(%rip), %xmm2    # 0x75a30
movapd 0xf3d0(%rip), %xmm3     # 0x4b0c0
xorpd %xmm7, %xmm3
movapd %xmm7, %xmm4
mulsd %xmm2, %xmm4
subsd %xmm4, %xmm1
movsd %xmm1, 0x39d48(%rip)    # 0x75a50
xorpd %xmm4, %xmm4
xorl %eax, %eax
cmpq %rax, %r13
je 0x3bd2a
movss (%r15,%rax,4), %xmm5
mulss %xmm5, %xmm5
cvtss2sd %xmm5, %xmm5
addsd %xmm5, %xmm4
incq %rax
jmp 0x3bd0e
divsd %xmm6, %xmm4
movsd 0x1af02(%rip), %xmm5    # 0x56c38
mulsd %xmm7, %xmm5
mulsd %xmm7, %xmm5
addsd %xmm4, %xmm5
movsd %xmm5, 0x39d16(%rip)    # 0x75a60
movapd %xmm1, %xmm4
divsd %xmm5, %xmm4
mulsd %xmm4, %xmm1
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
cvtsd2ss %xmm3, %xmm2
movss %xmm2, (%r14)
cvtsd2ss %xmm4, %xmm2
movss %xmm2, (%rbx)
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x3bd83
sqrtsd %xmm1, %xmm0
jmp 0x3bd8c
movapd %xmm1, %xmm0
callq 0x2290
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/optimization.c
// Function: Find_max_quad
float Find_max_quad(float x1, float x2, float x3,
		    float y1, float y2, float y3,
		    float MIN, float MAX)
{

 float yprime_2=((y1-y2)/(x1-x2));
  float yprime_3=((y1-y3)/(x1-x3));
  if(yprime_2 == yprime_3){
    // Singular data, return maximum value
    printf("WARNING in Find_max_quad, equal derivatives\n");
    float xmax=x2, ymax=y2;
    if(y1>ymax){ymax=y1; xmax=x1;}
    if(y3>ymax){xmax=x3;}
    return(xmax);
  }
  float a=(yprime_2-yprime_3)/(x2-x3);
  if(a>0){
    // Second derivative is positive, no maximum!
    //printf("WARNING, second derivative >0\n");
    printf("WARNING in Find_max_quad, second derivative %.2g >0\n", a);
    float xmax=x2, ymax=y2;
    if(y1>ymax){ymax=y1; xmax=x1;}
    if(y3>ymax){xmax=x3;}
    return(xmax);
  }
  float x0=0.5*(x1+x2)-yprime_2/(2*a);
  //printf("a= %.2f x0= %.2f\n", a, x0);
  if(x0<MIN){x0=(x1+MIN)/2;}
  //else if(x0>MAX){x0=(x3+MAX)/2;}
  return(x0);
}

// Assembly:
subq $0x68, %rsp
movaps %xmm0, %xmm8
movaps %xmm3, %xmm0
shufps $0x0, %xmm3, %xmm0      # xmm0 = xmm0[0,0],xmm3[0,0]
movaps %xmm4, %xmm7
unpcklps %xmm5, %xmm7            # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
subps %xmm7, %xmm0
movaps %xmm8, %xmm9
shufps $0x0, %xmm8, %xmm9      # xmm9 = xmm9[0,0],xmm8[0,0]
movaps %xmm1, %xmm7
unpcklps %xmm2, %xmm7            # xmm7 = xmm7[0],xmm2[0],xmm7[1],xmm2[1]
subps %xmm7, %xmm9
divps %xmm9, %xmm0
movaps %xmm0, %xmm7
shufps $0x55, %xmm0, %xmm7     # xmm7 = xmm7[1,1],xmm0[1,1]
ucomiss %xmm7, %xmm0
jne 0x3be09
jp 0x3be09
leaq 0x1ae91(%rip), %rdi     # 0x56c75
movaps %xmm3, 0x50(%rsp)
movaps %xmm8, 0x10(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm5, 0x30(%rsp)
movaps %xmm4, (%rsp)
movaps %xmm1, 0x20(%rsp)
callq 0x2090
jmp 0x3be58
movaps %xmm0, %xmm9
subss %xmm7, %xmm9
movaps %xmm1, %xmm7
subss %xmm2, %xmm7
divss %xmm7, %xmm9
xorps %xmm7, %xmm7
ucomiss %xmm7, %xmm9
jbe 0x3be97
cvtss2sd %xmm9, %xmm0
leaq 0x1ae0d(%rip), %rdi     # 0x56c40
movb $0x1, %al
movaps %xmm3, 0x50(%rsp)
movaps %xmm8, 0x10(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm5, 0x30(%rsp)
movaps %xmm4, (%rsp)
movaps %xmm1, 0x20(%rsp)
callq 0x20f0
movaps 0x50(%rsp), %xmm0
movaps (%rsp), %xmm1
movaps %xmm1, %xmm2
cmpltss %xmm0, %xmm2
movaps 0x10(%rsp), %xmm3
andps %xmm2, %xmm3
andnps 0x20(%rsp), %xmm2
orps %xmm3, %xmm2
maxss %xmm1, %xmm0
cmpltss 0x30(%rsp), %xmm0
movaps %xmm0, %xmm1
andnps %xmm2, %xmm1
andps 0x40(%rsp), %xmm0
orps %xmm1, %xmm0
addq $0x68, %rsp
retq
addss %xmm8, %xmm1
cvtss2sd %xmm1, %xmm2
addss %xmm9, %xmm9
divss %xmm9, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0xf1ba(%rip), %xmm2     # 0x4b070
subsd %xmm0, %xmm2
cvtsd2ss %xmm2, %xmm2
addss %xmm6, %xmm8
mulss 0x13c48(%rip), %xmm8    # 0x4fb14
movaps %xmm2, %xmm0
cmpltss %xmm6, %xmm0
movaps %xmm0, %xmm1
andnps %xmm2, %xmm1
andps %xmm8, %xmm0
jmp 0x3be8f
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/optimization.c
// Function: Rearrange_points
void Rearrange_points(float *x1, float *x2, float *x3,
		      float *y1, float *y2, float *y3,
		      float x0, float y0)
{
  if(y0<*y1){
    *x3=*x2; *y3=*y2;
    *x2=*x1; *y2=*y1;
    *x1=x0;  *y1=y0;
  }else if(y0<*y2){
    *x3=*x2; *y3=*y2;
    *x2=x0;  *y2=y0;
  }else if(y0<*y3){
    *x1=*x2; *y1=*y2;
    *x2=x0; *y2=y0;
  }else{
    *x1=*x2; *y1=*y2;
    *x2=*x3; *y2=*y3;
    *x3=x0;  *y3=y0;
  }
}

// Assembly:
movss (%rcx), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x3befd
movss (%rsi), %xmm2
movss %xmm2, (%rdx)
movss (%r8), %xmm2
movss %xmm2, (%r9)
jmp 0x3bf36
movss (%r8), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x3bf15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r8, %rcx
movq %r9, %r8
jmp 0x3bf36
movss (%r9), %xmm2
ucomiss %xmm1, %xmm2
movss (%rsi), %xmm2
movss %xmm2, (%rdi)
movss (%r8), %xmm2
movss %xmm2, (%rcx)
movq %rdx, %rdi
movq %r9, %rcx
ja 0x3bf4d
movss (%rdi), %xmm2
movss %xmm2, (%rsi)
movss (%rcx), %xmm2
movss %xmm2, (%r8)
movq %rdi, %rsi
movq %rcx, %r8
movss %xmm0, (%rsi)
movss %xmm1, (%r8)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/output_tnm.c
// Function: Check_make_dir
int Check_make_dir(char *outdir){
  char name_out[1000]; FILE *file_out;
  if(outdir[0]=='\0')return(0);
  sprintf(name_out, "%s/%s", outdir, "tmp");
  file_out=fopen(name_out, "w");
  if(file_out!=NULL){fclose(file_out); return(1);}
  sprintf(name_out, "mkdir -p %s\n", outdir);
  if(system(name_out)==0)return(1);
  return(0);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x3ca16
pushq %r14
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rdi, %rbx
leaq 0x1a470(%rip), %rsi     # 0x56e4e
leaq 0x1a46f(%rip), %rcx     # 0x56e54
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x14754(%rip), %rsi     # 0x51150
movq %r14, %rdi
callq 0x2210
testq %rax, %rax
je 0x3ca19
movq %rax, %rdi
callq 0x20c0
pushq $0x1
popq %rax
jmp 0x3ca41
xorl %eax, %eax
retq
leaq 0x1a438(%rip), %rsi     # 0x56e58
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2260
movq %r14, %rdi
callq 0x20e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/output_tnm.c
// Function: Print_cart_fluct
void Print_cart_fluct(int *atom_num, int N_atom, float *fluct,
		      atom *atoms, struct residue *seq,
		      char *name, char *type)
{
  float MAX_B=50.0;
  int i, ia=0, n=1;
  FILE *file_out=fopen(name, "w");
  printf("Writing %s\n", name);
  fprintf(file_out, "REMARK %d B_factor = %s\n",n, type);

  { // Normalize such that max_fluctuation = MAX_B
    float max_f=0, norm;
    for(i=0; i<N_atom; i++)if(fluct[i]>max_f)max_f=fluct[i];
    norm=MAX_B/max_f; for(i=0; i<N_atom; i++)fluct[i]*=norm;
  }
  for(i=0; i<N_atom; i++){
    Print_atom(atoms+atom_num[i], &ia, fluct[i], seq, file_out);
  }
  fprintf(file_out, "TER\n");
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbp
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
andl $0x0, 0xc(%rsp)
leaq 0x146ca(%rip), %rsi     # 0x51150
movq %r9, %rdi
callq 0x2210
movq %rax, %r15
leaq 0xf20f(%rip), %rdi      # 0x4bca7
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x1a3ba(%rip), %rsi     # 0x56e65
pushq $0x1
popq %rdx
movq %r15, %rdi
movq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x2190
testl %r13d, %r13d
cmovlel %ebx, %r13d
xorps %xmm1, %xmm1
cmpq %rbx, %r13
je 0x3cade
movss (%r12,%rbx,4), %xmm0
maxss %xmm1, %xmm0
incq %rbx
movaps %xmm0, %xmm1
jmp 0x3cac7
movss 0x1a1be(%rip), %xmm0    # 0x56ca4
divss %xmm1, %xmm0
xorl %eax, %eax
cmpq %rax, %r13
je 0x3cb06
movss (%r12,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r12,%rax,4)
incq %rax
jmp 0x3caec
xorl %r14d, %r14d
leaq 0xc(%rsp), %rbx
cmpq %r14, %r13
je 0x3cb3c
movslq (%rbp,%r14,4), %rax
imulq $0x70, %rax, %rdi
addq 0x18(%rsp), %rdi
movss (%r12,%r14,4), %xmm0
movq %rbx, %rsi
movq 0x20(%rsp), %rdx
movq %r15, %rcx
callq 0x3cb67
incq %r14
jmp 0x3cb0e
leaq 0x1a33b(%rip), %rdi     # 0x56e7e
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x2280
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/output_tnm.c
// Function: Print_atom
void Print_atom(atom *atom, int *num, float B, struct residue *seq,
		FILE *file_out)
{
  struct residue *s=seq+atom->res;
  char aaname3[4]; Name3(aaname3, s->i_aa);
  (*num)++; int jatom=*num; if(jatom>99999)jatom=99999;
  fprintf(file_out,
	  "ATOM  %5d  %4s%3s %c%4d   %8.3f%8.3f%8.3f%6.2f%6.2f\n",
	  jatom, atom->name, aaname3, 'A', atom->res+1,
	  atom->r[0], atom->r[1], atom->r[2], 1.0, B);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movss %xmm0, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movslq 0x64(%rdi), %rax
shlq $0x5, %rax
movswl 0x14(%rdx,%rax), %esi
leaq 0x14(%rsp), %r14
movq %r14, %rdi
callq 0x24647
movl (%r15), %edx
incl %edx
movl %edx, (%r15)
movl $0x1869f, %eax          # imm = 0x1869F
cmpl %eax, %edx
cmovgel %eax, %edx
leaq 0x18(%r12), %rcx
movl 0x64(%r12), %eax
incl %eax
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movsd 0x10(%r12), %xmm2
cvtss2sd 0x10(%rsp), %xmm4
movl %eax, (%rsp)
leaq 0x1a345(%rip), %rsi     # 0x56f22
pushq $0x41
popq %r9
movsd 0xe45f(%rip), %xmm3     # 0x4b048
movq %rbx, %rdi
movq %r14, %r8
movb $0x5, %al
callq 0x2190
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/output_tnm.c
// Function: Print_structures
void Print_structures(char *pdbout,
		      double *atom_str1, atom *atoms1,
		      struct residue *seq1, char chain1,
		      double *atom_str2, atom *atoms2,
		      struct residue *seq2, char chain2,
		      int *atom_num, int N_ref, int N_cart,
		      float **Cart_mode, float *coeff,
		      int *sort, int N_MODE_PRINT, int N_modes)
{
  double *atom_tmp;
  int imod=0, kmod=0, nmod, i;
  if(N_MODE_PRINT<=0)return;
  if(N_MODE_PRINT < N_modes){nmod = N_MODE_PRINT;}else{nmod= N_modes;}

  // Print reference structure
  //Write_coord(pdbout,atom_str1,atoms1,atom_num,N_ref,seq1,chain1,kmod);
  // kmod++;
  atom_tmp=malloc(N_cart*sizeof(double));
  for(i=0; i<N_cart; i++)atom_tmp[i]=atom_str1[i];

  for(imod=0; imod< nmod; imod++){
    int ik=sort[imod];
    float *mode=Cart_mode[ik];
    /* Update intermediate structure */
    for(i=0;i<N_cart;i++)atom_tmp[i]+=coeff[ik]*mode[i];
    Write_coord(pdbout,atom_tmp,atoms1,atom_num,N_ref,seq1,chain1,kmod);
    kmod++;
  }

  // Print experimental structure 2
  //Write_coord(pdbout,atom_str2,atoms2,atom_num,N_ref,seq2,chain2,-1);
  printf("Writing %s\n", pdbout);
  free(atom_tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x8(%rsp)
movl 0xb8(%rsp), %r13d
testl %r13d, %r13d
jle 0x3cf0b
movq %rsi, %r14
movl 0xc0(%rsp), %ebx
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa8(%rsp), %r15
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x98(%rsp), %eax
movl 0x90(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq 0x88(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movslq %eax, %rbp
leaq (,%rbp,8), %rdi
movl %r8d, %r12d
callq 0x21d0
movl %r12d, %ecx
movq %rax, %r12
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
cmpq %rax, %rbp
je 0x3ce64
movsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
incq %rax
jmp 0x3ce4e
cmpl %ebx, %r13d
cmovll %r13d, %ebx
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
movsbl %cl, %r13d
cmpq %rbx, %r14
je 0x3cee2
movq 0x20(%rsp), %rax
movslq (%rax,%r14,4), %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rcx
xorl %edx, %edx
cmpq %rdx, %rbp
je 0x3ceb6
movss (%r15,%rax,4), %xmm0
mulss (%rcx,%rdx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%r12,%rdx,8)
incq %rdx
jmp 0x3ce91
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl 0x4(%rsp), %r8d
movq 0x30(%rsp), %r9
pushq %r14
pushq %r13
callq 0x3cf1a
popq %rcx
popq %rdx
incq %r14
jmp 0x3ce78
leaq 0xedbe(%rip), %rdi      # 0x4bca7
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x20f0
movq %r12, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
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/output_tnm.c
// Function: Print_change
int Print_change(float *Fluct_pred, float *Fluct_obs, int N,
		char *nameout, char *what)
{
  char namefile[200]; FILE *file_out; int i;
  sprintf(namefile, "%s_%s_dev.dat", nameout, what);
  file_out=fopen(namefile, "w");
  printf("Writing %s\n", namefile);

  fprintf(file_out, "# Squared deviation\n# Pred Obs\n");
  for(i=0; i<N; i++)
    fprintf(file_out, "%.4f %.4f\n", Fluct_pred[i], Fluct_obs[i]);
  fclose(file_out);
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x19d0c(%rip), %rsi     # 0x56f57
xorl %ebp, %ebp
movq %rsp, %r13
movq %r13, %rdi
movq %rcx, %rdx
movq %r8, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x13ee9(%rip), %rsi     # 0x51150
movq %r13, %rdi
callq 0x2210
movq %rax, %r12
leaq 0xea2e(%rip), %rdi      # 0x4bca7
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x19cdb(%rip), %rdi     # 0x56f65
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
callq 0x2280
testl %ebx, %ebx
cmovlel %ebp, %ebx
leaq 0x19ce1(%rip), %r13     # 0x56f85
cmpq %rbp, %rbx
je 0x3d2c7
cvtss2sd (%r15,%rbp,4), %xmm0
cvtss2sd (%r14,%rbp,4), %xmm1
movq %r12, %rdi
movq %r13, %rsi
movb $0x2, %al
callq 0x2190
incq %rbp
jmp 0x3d2a4
movq %r12, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Extract_atoms
int Extract_atoms(int *iref, int *iatom, int *atomres, // Output
		  struct residue *seq, float *mass,
		  atom *atoms, struct Reference Ref, char *ANAME)
{
  /* 
     iref[i]= representative atom (kin) of representative atom i (allostery)
     iatom=   atom number of representative atom i (allostery)
     atomres= representative atom (allostery) of residue
   */
  int ia, Na=0, Nres=atoms[Ref.atom_num[Ref.N_ref-1]].res+1;
  for(ia=0; ia<Nres; ia++)atomres[ia]=-1;
  for(ia=0; ia<Ref.N_ref; ia++){
    atom *atom_i=atoms+Ref.atom_num[ia];
    if((strncmp(atom_i->name, ANAME, 2)==0)||
       ((seq[atom_i->res].amm=='G')&&(strncmp(atom_i->name, "CA", 2)==0))){
      if(*mass==0)*mass=Ref.mass_atom[ia];
      iref[Na]=ia;
      iatom[Na]=Ref.atom_num[ia];
      //ires[Na]=atom_i->res;
      atomres[atom_i->res]=Na; Na++;
    }
  }
  /*for(ia=0; ia<Na; ia++){
    int r=(atoms+Ref.atom_num[iref[ia]])->res;
    printf("%d %c %s %s\n", ia, seq[r].amm, seq[r].pdbres,
    (atoms+Ref.atom_num[iref[ia]])->name);
   }
   exit(8);*/
  return(Na);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x70(%rsp), %rax
movq 0x28(%rax), %rbp
movslq (%rax), %rcx
movslq -0x4(%rbp,%rcx,4), %rsi
imulq $0x70, %rsi, %rsi
movslq 0x64(%r9,%rsi), %rdi
xorl %esi, %esi
cmpq %rdi, %rsi
jg 0x3eba3
orl $-0x1, (%rdx,%rsi,4)
incq %rsi
jmp 0x3eb95
movq %rdx, 0x18(%rsp)
xorl %r14d, %r14d
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
movq %rdx, 0x30(%rsp)
movq 0x10(%rax), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
cmpq %r14, 0x30(%rsp)
je 0x3ec74
movslq (%rbp,%r14,4), %rax
imulq $0x70, %rax, %rax
leaq (%rbx,%rax), %r12
leaq (%rbx,%rax), %r15
addq $0x18, %r15
movq %r15, %rdi
movq 0xa0(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x2070
testl %eax, %eax
je 0x3ec1f
movslq 0x64(%r12), %rax
shlq $0x5, %rax
movq 0x28(%rsp), %rcx
cmpb $0x47, 0x13(%rcx,%rax)
jne 0x3ec6c
cmpb $0x43, (%r15)
jne 0x3ec6c
cmpb $0x41, 0x19(%r12)
jne 0x3ec6c
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
ucomiss 0xc3dd(%rip), %xmm0     # 0x4b00c
jne 0x3ec41
jp 0x3ec41
movq (%rsp), %rcx
movss (%rcx,%r14,4), %xmm0
movss %xmm0, (%rax)
movslq %r13d, %r13
movq 0x8(%rsp), %rax
movl %r14d, (%rax,%r13,4)
movl (%rbp,%r14,4), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx,%r13,4)
movslq 0x64(%r12), %rax
movq 0x18(%rsp), %rcx
movl %r13d, (%rcx,%rax,4)
incl %r13d
incq %r14
jmp 0x3ebc5
movl %r13d, %eax
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/allostery.c
// Function: Pairwise_distances
void Pairwise_distances(float **d02ij, float ***r0ijk, 
			atom *atoms, int *iatom, int Na)
{
  int ia, ja, k;
  for(ia=0; ia<Na; ia++){
    double *ri=atoms[iatom[ia]].r;
    float *dij=malloc(Na*sizeof(float));
    d02ij[ia]=dij;
    float **rij=Allocate_mat2_f(Na,3);
    r0ijk[ia]=rij;
    for(ja=0; ja<ia; ja++){
      double *rj=atoms[iatom[ja]].r, sum=0;
      float *d=rij[ja];
      for(k=0; k<3; k++){
	*d=ri[k]-(*rj); sum+=(*d)*(*d); d++; rj++;
      }
      dij[ja]=sum;
      sum=sqrt(sum);
      d=rij[ja]; for(k=0; k<3; k++){(*d)/=sum; d++;}
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movslq %r8d, %rax
leaq (,%rax,4), %rcx
movq %rcx, 0x18(%rsp)
xorl %ebp, %ebp
testl %eax, %eax
movl $0x0, %eax
movl %r8d, 0xc(%rsp)
cmovgl %r8d, %eax
movq %rax, 0x30(%rsp)
cmpq 0x30(%rsp), %rbp
je 0x3edb9
movq 0x10(%rsp), %rax
movslq (%rax,%rbp,4), %rax
imulq $0x70, %rax, %rbx
addq %r15, %rbx
movq 0x18(%rsp), %rdi
callq 0x21d0
movq %rax, %r12
movq 0x20(%rsp), %rax
movq %r12, (%rax,%rbp,8)
movl 0xc(%rsp), %edi
pushq $0x3
popq %rsi
callq 0x4379e
movq %rax, %r13
movq 0x28(%rsp), %rax
movq %r13, (%rax,%rbp,8)
xorl %r14d, %r14d
cmpq %rbp, %r14
je 0x3edb1
movq 0x10(%rsp), %rax
movslq (%rax,%r14,4), %rax
imulq $0x70, %rax, %rax
addq %r15, %rax
movq (%r13,%r14,8), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x3ed67
movsd (%rbx,%rdx,8), %xmm1
subsd (%rax,%rdx,8), %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rcx,%rdx,4)
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x3ed3d
cvtsd2ss %xmm0, %xmm1
movss %xmm1, (%r12,%r14,4)
ucomisd 0xc2d7(%rip), %xmm0     # 0x4b050
jb 0x3ed81
sqrtsd %xmm0, %xmm0
jmp 0x3ed86
callq 0x2290
movq (%r13,%r14,8), %rax
xorl %ecx, %ecx
cmpl $0x3, %ecx
je 0x3eda9
cvtss2sd (%rax,%rcx,4), %xmm1
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rax,%rcx,4)
incq %rcx
jmp 0x3ed8d
incq %r14
jmp 0x3ed19
incq %rbp
jmp 0x3eccd
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/allostery.c
// Function: Eigenvalue_main
float Eigenvalue_main(double **Corr, int Na)
{
  int i;
  float *eigenval=malloc(Na*sizeof(double));
  float **eigenvec=malloc(Na*sizeof(float *));
  for(i=0; i<Na; i++)eigenvec[i]=malloc(Na*sizeof(float));
  d_Diagonalize(Na, Corr, eigenval, eigenvec, 1);
  float Ev=eigenval[0];
  Empty_matrix_f(eigenvec, Na); free(eigenval);
  return(Ev);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, (%rsp)
movslq %esi, %r15
leaq (,%r15,8), %r12
movq %r12, %rdi
callq 0x21d0
movq %rax, %r14
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
leaq (,%r15,4), %r13
xorl %ebp, %ebp
testl %r15d, %r15d
movl $0x0, %r15d
cmovgl %ebx, %r15d
cmpq %rbp, %r15
je 0x3ee57
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r12,%rbp,8)
incq %rbp
jmp 0x3ee41
pushq $0x1
popq %r8
movl %ebx, %edi
movq (%rsp), %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x444de
movss (%r14), %xmm0
movss %xmm0, (%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x436f0
movq %r14, %rdi
callq 0x2050
movss (%rsp), %xmm0
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/allostery.c
// Function: Print_names
void Print_names(int N, char **pdbres, char *amm, char *chain,
		 char *nameout1)
{
  int i;  char nameout[200];
  sprintf(nameout, "%s.names.dat", nameout1);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  for(i=0; i<N; i++){
    fprintf(file_out, "%d %c_%s_%c\n", i, amm[i], pdbres[i], chain[i]);
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
leaq 0x18454(%rip), %rsi     # 0x57314
movq %rsp, %rbp
movq %rbp, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x12279(%rip), %rsi     # 0x51150
movq %rbp, %rdi
callq 0x2210
movq %rax, %r13
leaq 0xcdbe(%rip), %rdi      # 0x4bca7
movq %rbp, %rsi
xorl %eax, %eax
callq 0x20f0
testl %r12d, %r12d
movl $0x0, %eax
cmovlel %eax, %r12d
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x3ef2c
movsbl (%r14,%rbp), %ecx
movq (%r15,%rbp,8), %r8
movsbl (%rbx,%rbp), %r9d
movq %r13, %rdi
leaq 0x18403(%rip), %rsi     # 0x57321
movl %ebp, %edx
xorl %eax, %eax
callq 0x2190
incq %rbp
jmp 0x3ef01
movq %r13, %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/allostery.c
// Function: Make_profile
float *Make_profile(float **Mat, int N, char PROF_TYPE, char *what)
{
  printf("Computing profiles of %s type %c\n", what, PROF_TYPE);
  float *prof=malloc(N*sizeof(float)); int i;
  float weight[N], sum_weight=0;
  if(PROF_TYPE=='A'){
    sum_weight=N; for(i=0; i<N; i++)weight[i]=1;
  }else{
    double **Mat2=Get_matrix_positive(Mat, N);
    if(PROF_TYPE=='P'){
      PE_profile(weight, Mat2, N);
    }else if(PROF_TYPE=='C'){
      float *c=EC_profile(NULL, Mat2, N, what);
      for(i=0; i<N; i++)weight[i]=c[i];
      free(c);
    }
    for(i=0; i<N; i++)sum_weight+=weight[i];
    Empty_matrix_d(Mat2, N);
  }
  for(i=0; i<N; i++){
    double sum=0; float *Ca=Mat[i];
    for(int j=0; j<N; j++)if(j!=i)sum+=Ca[j]*weight[j];
    prof[i]=sum/(sum_weight-weight[i]);
  }
  return(prof);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, -0x38(%rbp)
leaq 0x181bf(%rip), %rdi     # 0x5748b
xorl %ebx, %ebx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsi
xorl %eax, %eax
callq 0x20f0
movl %r14d, -0x2c(%rbp)
movslq %r14d, %r15
leaq (,%r15,4), %rdi
callq 0x21d0
movq %rax, %r14
movl %r15d, %r12d
movq %rsp, %r15
leaq 0xf(,%r12,4), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
cmpb $0x41, %r13b
jne 0x3f336
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
testl %ecx, %ecx
movl $0x0, %r13d
cmovgl %ecx, %r13d
cmpq %rbx, %r13
je 0x3f369
movl $0x3f800000, (%r15,%rbx,4) # imm = 0x3F800000
incq %rbx
jmp 0x3f324
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movl -0x2c(%rbp), %esi
callq 0x4213c
movsbl %r13b, %ecx
cmpl $0x43, %ecx
je 0x3f375
cmpl $0x50, %ecx
jne 0x3f3c1
movq %r15, %rdi
movq %rax, %rsi
movl -0x2c(%rbp), %edx
movq %rax, %r13
callq 0x4104f
movq %r13, %rax
jmp 0x3f3c1
cvtsi2ss %ecx, %xmm2
movq %rax, %rbx
jmp 0x3f3f7
xorl %ebx, %ebx
xorl %edi, %edi
movq %rax, -0x40(%rbp)
movq %rax, %rsi
movl -0x2c(%rbp), %r13d
movl %r13d, %edx
movq -0x48(%rbp), %rcx
callq 0x490b0
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
cmpq %rbx, %rcx
je 0x3f3b1
movss (%rax,%rbx,4), %xmm0
movss %xmm0, (%r15,%rbx,4)
incq %rbx
jmp 0x3f39c
movq %rax, %rdi
callq 0x2050
movq -0x38(%rbp), %rbx
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
movl -0x2c(%rbp), %esi
testl %esi, %esi
movl $0x0, %r13d
cmovgl %esi, %r13d
xorps %xmm0, %xmm0
cmpq %rcx, %r13
je 0x3f3e5
addss (%r15,%rcx,4), %xmm0
incq %rcx
jmp 0x3f3d5
movq %rax, %rdi
movss %xmm0, -0x2c(%rbp)
callq 0x4372a
movss -0x2c(%rbp), %xmm2
xorl %eax, %eax
cmpq %r13, %rax
je 0x3f449
movq (%rbx,%rax,8), %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %r12
je 0x3f429
cmpq %rdx, %rax
je 0x3f424
movss (%rcx,%rdx,4), %xmm1
mulss (%r15,%rdx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x3f407
movaps %xmm2, %xmm1
subss (%r15,%rax,4), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r14,%rax,4)
incq %rax
jmp 0x3f3f9
movq %r14, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ugobas[P]tnm/allostery.c
// Function: Negexp_distance
float **Negexp_distance(float **d02ij, int Na, float D)
{
  float **eij=Allocate_mat2_f(Na, Na);
  for(int i=0; i<Na; i++){
    eij[i][i]=1;
    for(int j=0; j<i; j++){
      eij[i][j]=exp(-sqrt(d02ij[i][j])/D);
      eij[j][i]=eij[i][j];
    }
  }
  return(eij);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x4379e
movq %rax, %r15
cvtss2sd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
cmpq %rbx, %r12
je 0x3f4ff
movq (%r15,%r12,8), %rax
movl $0x3f800000, (%rax,%r12,4) # imm = 0x3F800000
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x3f4fa
movq (%r14,%r12,8), %rax
cvtss2sd (%rax,%r13,4), %xmm0
ucomisd 0xbb93(%rip), %xmm0     # 0x4b050
jb 0x3f4c5
sqrtsd %xmm0, %xmm0
jmp 0x3f4ca
callq 0x2290
xorpd 0xbbee(%rip), %xmm0     # 0x4b0c0
divsd 0x8(%rsp), %xmm0
callq 0x22a0
cvtsd2ss %xmm0, %xmm0
movq (%r15,%r12,8), %rax
movss %xmm0, (%rax,%r13,4)
movq (%r15,%r13,8), %rax
movss %xmm0, (%rax,%r12,4)
incq %r13
jmp 0x3f4a6
incq %r12
jmp 0x3f492
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq