LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/align_tnm.c
// Function: Match_chains_by_length
void Match_chains_by_length(int *match1,
			    struct chain *chains1, int Nchain1,
			    struct chain *chains2, int Nchain2)
{
  int match2[Nchain2], free1[Nchain1], free2[Nchain2], i, j;
  for(i=0; i<Nchain1; i++){match1[i]=-1; free1[i]=1;}
  for(i=0; i<Nchain2; i++){match2[i]=-1; free2[i]=1;}
  Best_match(match1, free1, chains1, Nchain1, chains2, Nchain2);
  Best_match(match2, free2, chains2, Nchain2, chains1, Nchain1);
  for(i=0; i<Nchain1; i++){
    j=match1[i];
    if(match2[j]==i){free2[j]=0;} // Freeze reciprocal best matches
    else{match1[i]=-1;}
  }
  Best_match(match1, free1, chains1, Nchain1, chains2, Nchain2);  

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x68(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl -0x14(%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, -0x40(%rbp)
movl -0x24(%rbp), %eax
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x17c8a
movq -0x60(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x4c(%rbp), %rdx
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movslq -0x4c(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x17c59
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x17cc2
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movslq -0x4c(%rbp), %rdx
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movslq -0x4c(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x17c91
movq -0x60(%rbp), %rsi
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0x17d80
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %r8
movl -0x14(%rbp), %r9d
callq 0x17d80
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x17d54
movq -0x68(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x4c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x50(%rbp)
movslq -0x50(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x4c(%rbp), %eax
jne 0x17d38
movq -0x58(%rbp), %rax
movslq -0x50(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x17d47
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x17d49
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x17d01
movq -0x60(%rbp), %rsi
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0x17d80
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/align_tnm.c
// Function: Best_match
void Best_match(int *match1, int *free2,
		struct chain *chains1, int Nchain1,
		struct chain *chains2, int Nchain2)
{
  for(int i=0; i<Nchain1; i++){
    if(match1[i]>=0)continue;
    int imin=-1, d_min=100000, n1=chains1[i].nres;
    if((i<Nchain2)&&(free2[i])){
      d_min=abs(n1-chains2[i].nres); imin=i;
    }
    for(int j=0; j<Nchain2; j++){
      if((j==i)||(free2[j]==0))continue;
      int d=abs(n1-chains2[j].nres);
      if(d<d_min){d_min=d; imin=j;}
    }
    match1[i]=imin;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x17ea2
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x17dc1
jmp 0x17e94
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x186a0, -0x38(%rbp)   # imm = 0x186A0
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x17e1f
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x17e1f
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
subl 0x1c(%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x17e86
movl -0x40(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0x17e44
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x17e46
jmp 0x17e7b
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x40(%rbp), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
subl 0x1c(%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x17e79
movl -0x44(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x17e7b
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x17e26
movl -0x34(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x17da2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/align_tnm.c
// Function: Test_chains
void Test_chains(int *icl, int ncl,struct chain *chains, int Nchain, int n)
{
  int i, j;
  for(j=0; j<ncl; j++){
    i=icl[j];
    if(i<0 || i>=Nchain){
      printf("ERROR, wrong index of chain in PDB%d: %d not in [0,%d]\n",
	     n, i, Nchain); exit(8);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x18663
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x18635
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x18656
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq 0x62fd2(%rip), %rdi     # 0x7b617
movb $0x0, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
jmp 0x18658
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x18611
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/dof_tnm.c
// Function: Count_gaps
int Count_gaps(struct bond *bonds, int natoms){
  int Ngap=0, ichain=-1, ires=-1;
  for(int i=0; i<natoms; i++){
    struct bond *bond=bonds+i;
    if(bond->atom->chain!=ichain){
      ichain=bond->atom->chain; ires=bond->atom->res;
      continue;
    }
    if(bond->atom->res!=ires){
      if((ires>=0)&&(bond->previous!=NULL)){
	if(Distance_square(bond->r, bond->previous->r) > D2_GAP)Ngap++;
      }
      ires=bond->atom->res;
    }
  }
  printf("%d gaps found in protein\n", Ngap);
  return(Ngap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1a3c2
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x6c(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x1a358
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x6c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x1a3b4
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
cmpl -0x18(%rbp), %eax
je 0x1a3b2
cmpl $0x0, -0x18(%rbp)
jl 0x1a3a5
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1a3a5
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0x8, %rsi
callq 0x1ae70
ucomiss 0x71450(%rip), %xmm0    # 0x8b7e8
jbe 0x1a3a3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a3a5
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x1a3b4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a30b
movl -0x10(%rbp), %esi
leaq 0x615fa(%rip), %rdi     # 0x7b9c6
movb $0x0, %al
callq 0x10d0
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/dof_tnm.c
// Function: Set_rigid
void Set_rigid(struct rigid *rigid_tmp, int *nrigid,
	       struct bond *bond, int prev_chain, int N_axes)
{
  rigid_tmp[*nrigid].chain1=prev_chain;
  rigid_tmp[*nrigid].chain2=bond->atom->chain;
  rigid_tmp[*nrigid].iaxe=N_axes;
  (*nrigid)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x6c(%rax), %ecx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/dof_tnm.c
// Function: Axe_prot_main
char Axe_prot_main(struct bond *bond, int r_last)
{
  char *name=bond->atom->name, *previous_name=bond->previous->atom->name;
  if(strncmp(name,"N ", 2)==0){
    if((strncmp(previous_name,"C ", 2)==0)&&
       (bond->atom->res==(bond->previous->atom->res+1))){
      return('o'); // omega 
    }else{return('q');}         // Pseudo-axe after disordered loop
  }else if(strncmp(name,"CA", 2)==0){
    if((strncmp(previous_name,"N ", 2)==0)&&
       (bond->atom->res==bond->previous->atom->res)){
      return('f'); // phi
    }else{return('q');}
  }else if(strncmp(name,"C ", 2)==0){
    if((strncmp(previous_name,"CA", 2)==0)&&
       (bond->atom->res==bond->previous->atom->res)){
      if(bond->atom->res==r_last)return(NONE);
      return('p'); // psi
    }else{return('q');}
  }else{
    return('s');
  }
  return(NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x60931(%rip), %rsi     # 0x7b02d
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1a756
movq -0x28(%rbp), %rdi
leaq 0x6091a(%rip), %rsi     # 0x7b030
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1a74d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
movl 0x64(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1a74d
movb $0x6f, -0x1(%rbp)
jmp 0x1a828
movb $0x71, -0x1(%rbp)
jmp 0x1a828
movq -0x20(%rbp), %rdi
leaq 0x5bba7(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1a7b0
movq -0x28(%rbp), %rdi
leaq 0x608b2(%rip), %rsi     # 0x7b02d
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1a7aa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jne 0x1a7aa
movb $0x66, -0x1(%rbp)
jmp 0x1a828
movb $0x71, -0x1(%rbp)
jmp 0x1a828
movq -0x20(%rbp), %rdi
leaq 0x60875(%rip), %rsi     # 0x7b030
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1a824
movq -0x28(%rbp), %rdi
leaq 0x5bb33(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1a81e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jne 0x1a81e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1a818
movb 0x70fd1(%rip), %al      # 0x8b7e4
movb %al, -0x1(%rbp)
jmp 0x1a828
movb $0x70, -0x1(%rbp)
jmp 0x1a828
movb $0x71, -0x1(%rbp)
jmp 0x1a828
movb $0x73, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/dof_tnm.c
// Function: Count_interactions
int Count_interactions(atom *atoms, int natoms,
		       struct interaction *Int_list, int N_int)
{
  int i;
  for(i=0; i<natoms; i++)atoms[i].N_int=0;
  for(i=0; i<N_int; i++){
    atoms[Int_list[i].i1].N_int++;
    atoms[Int_list[i].i2].N_int++;
  }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1afc2
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x60(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1af99
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1b02f
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
imulq $0xc8, %rdx, %rdx
addq %rdx, %rcx
movslq 0x4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1afc9
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/dof_tnm.c
// Function: Last_axe
int Last_axe(int *aa, struct axe *axes, int ini, int n, int iatom)
{
  int a=*aa; struct axe *axe=axes+(*aa);
  while(a<n){
    if(axe->first_atom>iatom)break;
    a++; axe++;
  }
  if(a==0)return(-1);
  if(a==n){a--; axe--;}
  if(axe->first_atom>iatom && (axe-1)->first_atom<=iatom){a--; axe--;}
  if(a<ini){*aa=a;}else{*aa=ini;}
  if((axe->first_atom<=iatom))return(a); //&&(axe->last_atom>=i)
  printf("WARNING, last_axe<0: atom %d axe %d n= %d first %d last %d\n",
	 iatom, a, n, axe->first_atom, axe->last_atom); //exit(8);
  return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x158, %rcx, %rcx      # imm = 0x158
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1b24b
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x24(%rbp), %eax
jle 0x1b232
jmp 0x1b24b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x30(%rbp)
jmp 0x1b21c
cmpl $0x0, -0x28(%rbp)
jne 0x1b25d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b30c
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x1b27c
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $-0x158, %rax           # imm = 0xFEA8
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x24(%rbp), %eax
jle 0x1b2ae
movq -0x30(%rbp), %rax
movl -0x148(%rax), %eax
cmpl -0x24(%rbp), %eax
jg 0x1b2ae
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $-0x158, %rax           # imm = 0xFEA8
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1b2c1
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1b2ca
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x24(%rbp), %eax
jg 0x1b2de
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b30c
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl 0x10(%rax), %r8d
movq -0x30(%rbp), %rax
movl 0x14(%rax), %r9d
leaq 0x6070e(%rip), %rdi     # 0x7ba0c
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/dof_tnm.c
// Function: Find_ref
int Find_ref(int i_atom, int natoms, int *refatom){
   int i=i_atom, iref=refatom[i]; 
   while(iref<0){
      i++; if(i>=natoms)break; iref=refatom[i]; 
    }
   return(iref);
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1b36b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x1b35b
jmp 0x1b36b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
jmp 0x1b342
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/buildup.c
// Function: Is_atom_main
int Is_atom_main(char *name, int seq_type){
  if((seq_type==1)||(seq_type==-1)){ // Amino-acid
    if((strncmp(name, "N ", 2)==0)||
       (strncmp(name, "CA", 2)==0)||
       (strncmp(name, "C ", 2)==0)){return(1);}
    else{return(0);}
  }else if((seq_type== 2)||(seq_type== 3)||
	   (seq_type==-2)||(seq_type==-3)){ // Nucleic acid
    if((strncmp(name,"P ", 3)==0)||
       (strncmp(name,"O5'", 3)==0)||
       (strncmp(name,"C5'", 3)==0)||
       (strncmp(name,"C4'", 3)==0)||
       (strncmp(name,"C3'", 3)==0)||
       (strncmp(name,"O3'", 3)==0)){return(1);}
    else{return(0);}
  }else{
    return(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x1d06b
cmpl $-0x1, -0x14(%rbp)
jne 0x1d0d1
movq -0x10(%rbp), %rdi
leaq 0x5dfb7(%rip), %rsi     # 0x7b02d
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x1d0b9
movq -0x10(%rbp), %rdi
leaq 0x59278(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x1d0b9
movq -0x10(%rbp), %rdi
leaq 0x5df86(%rip), %rsi     # 0x7b030
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1d0c5
movl $0x1, -0x4(%rbp)
jmp 0x1d1a6
movl $0x0, -0x4(%rbp)
jmp 0x1d1a6
cmpl $0x2, -0x14(%rbp)
je 0x1d0ed
cmpl $0x3, -0x14(%rbp)
je 0x1d0ed
cmpl $-0x2, -0x14(%rbp)
je 0x1d0ed
cmpl $-0x3, -0x14(%rbp)
jne 0x1d19f
movq -0x10(%rbp), %rdi
leaq 0x5e8f7(%rip), %rsi     # 0x7b9ef
movl $0x3, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x1d18d
movq -0x10(%rbp), %rdi
leaq 0x5e8d5(%rip), %rsi     # 0x7b9eb
movl $0x3, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x1d18d
movq -0x10(%rbp), %rdi
leaq 0x5e8c2(%rip), %rsi     # 0x7b9f2
movl $0x3, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x1d18d
movq -0x10(%rbp), %rdi
leaq 0x5e8ac(%rip), %rsi     # 0x7b9f6
movl $0x3, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x1d18d
movq -0x10(%rbp), %rdi
leaq 0x5e896(%rip), %rsi     # 0x7b9fa
movl $0x3, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x1d18d
movq -0x10(%rbp), %rdi
leaq 0x5e880(%rip), %rsi     # 0x7b9fe
movl $0x3, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1d196
movl $0x1, -0x4(%rbp)
jmp 0x1d1a6
movl $0x0, -0x4(%rbp)
jmp 0x1d1a6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Find_atom
int Find_atom(atom *atoms, int *i1, int res, int N_atoms, char *atom_type){
  int i; atom *atom;

  atom=atoms+*i1;
  for(i=*i1; i<N_atoms; i++){
    if(atom->res > res)break;
    if(atom->res < res)goto next1;
    if(strncmp(atom->name, atom_type, 2)==0){*i1=i; return(0);}
  next1: atom++;
  }
  // Not found? Look for CA atom
  atom=atoms+*i1;
  for(i=*i1; i<N_atoms; i++){
    if(atom->res > res)break;
    if(atom->res < res)goto next2;
    if(strncmp(atom->name, "CA", 2)==0){*i1=i; return(0);}
  next2: atom++;
  }
  return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x21546
movq -0x38(%rbp), %rax
movl 0x64(%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x214ef
jmp 0x21546
movq -0x38(%rbp), %rax
movl 0x64(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x214fd
jmp 0x2152f
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x2152d
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x215d9
jmp 0x2152f
movq -0x38(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x214d9
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x215d2
movq -0x38(%rbp), %rax
movl 0x64(%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x2157b
jmp 0x215d2
movq -0x38(%rbp), %rax
movl 0x64(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x21589
jmp 0x215bb
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
leaq 0x54d70(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x215b9
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x215d9
jmp 0x215bb
movq -0x38(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x21565
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Covalent
int Covalent(int res1, int res2, atom *atom1, atom *atom2){
  if(res2!=(res1+1))return(0);
  if((strncmp(atom2->name, "N ", 2)==0)&&
       ((strncmp(atom1->name, "O ", 2)==0)
	||(strncmp(atom1->name, "CA", 2)==0)
	||(strncmp(atom1->name, "C ", 2)==0)
	))return(1);
  if((strncmp(atom2->name, "CA", 2)==0)&&
     (strncmp(atom1->name, "C ", 2)==0)
     //||(strncmp(atom1->name, "O ", 2)==0)
     )return(1);
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x2161f
movl $0x0, -0x4(%rbp)
jmp 0x216ec
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq 0x599ff(%rip), %rsi     # 0x7b02d
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x216a0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x599e7(%rip), %rsi     # 0x7b033
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x21697
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x54c9e(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x21697
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x599a8(%rip), %rsi     # 0x7b030
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x216a0
movl $0x1, -0x4(%rbp)
jmp 0x216ec
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq 0x54c59(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x216e5
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x59963(%rip), %rsi     # 0x7b030
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x216e5
movl $0x1, -0x4(%rbp)
jmp 0x216ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Heavy_atoms_interactors
void Heavy_atoms_interactors(struct interaction *Int_list, int N_int,
			     atom *atoms)
{
  int k, h=0;
  for(k=0; k<N_int; k++){
    h+=Heavy_atom(&(Int_list[k].i1), atoms);
    h+=Heavy_atom(&(Int_list[k].i2), atoms);
    if(1){
      Int_list[k].r0=
	sqrt(Distance_square(atoms[Int_list[k].i1].r,atoms[Int_list[k].i2].r));
    }

  }
  printf("%d hydrogen atoms changed to heavy atoms\n", h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x217e7
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x21800
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
callq 0x21800
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movslq (%rax), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movslq 0x4(%rax), %rax
imulq $0x70, %rax, %rax
addq %rax, %rsi
callq 0x1ae70
cvtss2sd %xmm0, %xmm0
callq 0x1220
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x20(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21721
movl -0x20(%rbp), %esi
leaq 0x5a90b(%rip), %rdi     # 0x7c0fc
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Force_constant
float Force_constant(float r)
{
  if(r <= C1_THR){
    if(POW){return(K0*pow(r, -EXP_HESSIAN));}
    else{return(K0*exp(-r*EXP_HESSIAN));}
  }else if(r < C_THR){
    return(K1*(C_THR-r));
  }else{
    return(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm1
leaq 0x69f17(%rip), %rax     # 0x8c030
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x221d3
leaq 0x6947f(%rip), %rax     # 0x8b5ac
cmpl $0x0, (%rax)
je 0x22186
leaq 0x69f07(%rip), %rax     # 0x8c040
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x69eda(%rip), %rax     # 0x8c02c
movss (%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
cvtss2sd %xmm1, %xmm1
callq 0x1080
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x2221e
leaq 0x69eb3(%rip), %rax     # 0x8c040
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movss -0x8(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
leaq 0x69e7d(%rip), %rax     # 0x8c02c
mulss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1230
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x2221e
movss -0x8(%rbp), %xmm1
leaq 0x69e49(%rip), %rax     # 0x8c028
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x22216
leaq 0x69e59(%rip), %rax     # 0x8c048
movsd (%rax), %xmm0
leaq 0x69e2e(%rip), %rax     # 0x8c028
movss (%rax), %xmm1
subss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x2221e
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Bond_angle
float Bond_angle(double *r1, double *r2, double *r3)
{
  if((r1==NULL)||(r2==NULL)||(r3==NULL))return(0);
  double ux=(r1[0]-r2[0]), vx=(r3[0]-r2[0]);
  double uy=(r1[1]-r2[1]), vy=(r3[1]-r2[1]);
  double uz=(r1[2]-r2[2]), vz=(r3[2]-r2[2]);
  double scal_prod=ux*vx+uy*vy+uz*vz;
  scal_prod/=sqrt((ux*ux+uy*uy+uz*uz)*(vx*vx+vy*vy+vz*vz));
  return(scal_prod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x222b9
cmpq $0x0, -0x18(%rbp)
je 0x222b9
cmpq $0x0, -0x20(%rbp)
jne 0x222c6
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x22403
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x30(%rbp), %xmm3
movsd -0x40(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd -0x50(%rbp), %xmm1
movsd -0x50(%rbp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x1220
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Purge_interactions_res_pair_new
void Purge_interactions_res_pair_new(int *N_int, struct interaction *Int_list,
				     int nres)
{
  // Maximum one interaction per residue pair
  int Nnew=0, res1, res2, k; 
  struct interaction *ini=Int_list, *end=Int_list+*N_int;
  struct interaction *tmp=malloc(*N_int*sizeof(struct interaction));

  for(res1=0; res1<nres; res1++){
    for(res2=res1+1; res2<nres; res2++){
      // Find strongest res1-res2 contact
      // Find the next value of res2
      int new1;
      struct interaction *res12=
	Check_pair(&new1, res1, &res2, nres, &ini, end);

      if(res12){tmp[Nnew]=*res12; Nnew++;} // store
      if(new1)break;

    } // end res2
  } // end res1

  for(k=0; k<Nnew; k++)Int_list[k]=tmp[k];
  *N_int=Nnew;
  free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rax
imulq $0xc8, %rax, %rdi
callq 0x1180
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x22d6a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x22d5a
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %r9
leaq -0x44(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %r8
callq 0x22dd0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x22d45
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rdi
movq -0x50(%rbp), %rsi
movl $0xc8, %edx
callq 0x1160
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x22d4d
jmp 0x22d5a
jmp 0x22d4f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x22cee
jmp 0x22d5c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22cd9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x22db2
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rdi
movq -0x40(%rbp), %rsi
movslq -0x24(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rsi
movl $0xc8, %edx
callq 0x1160
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x22d71
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rdi
callq 0x1040
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Check_pair
struct interaction *Check_pair(int *new1, int res1, int *res2, int nres,
			       struct interaction **ini,
			       struct interaction *end)
{
  struct interaction *res12=NULL, *ptr;
  int res2min=nres; *new1=0;
  for(ptr=*ini; ptr<end; ptr++){
    if(ptr->res1 > res1)break;
    if(ptr->res1 == res1){
      if(ptr->res2 == *res2){
	if((res12==NULL)||(ptr->sec_der>res12->sec_der)||
	   ((ptr->sec_der==res12->sec_der)&&(ptr->r0 < res12->r0))){
	  res12=ptr;
	}
      }else if((ptr->res2 < res2min)&&(ptr->res2 > *res2)){
	res2min=ptr->res2;
      }
    }
  } // End pair
  // Prepare next value
  if(res2min==nres){*ini=ptr; *new1=1;} // end res2
  else{*res2=res2min-1;}
  return(res12);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x22edc
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x22e2c
jmp 0x22edc
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x22ec7
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x22e9e
cmpq $0x0, -0x38(%rbp)
je 0x22e94
movq -0x40(%rbp), %rax
movsd 0x28(%rax), %xmm0
movq -0x38(%rbp), %rax
ucomisd 0x28(%rax), %xmm0
ja 0x22e94
movq -0x40(%rbp), %rax
movsd 0x28(%rax), %xmm0
movq -0x38(%rbp), %rax
ucomisd 0x28(%rax), %xmm0
jne 0x22e9c
jp 0x22e9c
movq -0x40(%rbp), %rax
movsd 0x20(%rax), %xmm1
movq -0x38(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x22e9c
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x22ec5
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x44(%rbp), %eax
jge 0x22ec3
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x22ec3
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x22ec5
jmp 0x22ec7
jmp 0x22ec9
movq -0x40(%rbp), %rax
addq $0xc8, %rax
movq %rax, -0x40(%rbp)
jmp 0x22e0d
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x22efb
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
jmp 0x22f07
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Backbone
int Backbone(char *name){
  if((strncmp(name, "N ", 2)==0)||
     (strncmp(name, "CA", 2)==0)||
     (strncmp(name, "C ", 2)==0))//||
     //(strncmp(name, "O ", 2)==0)||
     //(strncmp(name, "H ", 2)==0)||
     //(strncmp(name, "HN", 2)==0))
    return(1);
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x58106(%rip), %rsi     # 0x7b02d
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x22f6a
movq -0x10(%rbp), %rdi
leaq 0x533c7(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x22f6a
movq -0x10(%rbp), %rdi
leaq 0x580d5(%rip), %rsi     # 0x7b030
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x22f73
movl $0x1, -0x4(%rbp)
jmp 0x22f7a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/interactions_tnm.c
// Function: Compute_sec_der_old
void Compute_sec_der_old(struct interaction *Int_list, int N_int, float expo)
{
  double t=0; int n;
    for(n=0; n<N_int; n++){
      if(Int_list[n].r0<=0){
	printf("ERROR, d2= %.2f\n", Int_list[n].r0); exit(8);
      }
      if(expo)Int_list[n].sec_der*=pow(Int_list[n].r0, -expo);
      t+=Int_list[n].sec_der;
    }
    t/=N_int;
    for(n=0; n<N_int; n++)Int_list[n].sec_der/=t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x23098
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
ucomisd 0x20(%rax), %xmm0
jb 0x2300a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movsd 0x20(%rax), %xmm0
leaq 0x59329(%rip), %rdi     # 0x7c322
movb $0x1, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
movss -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2301b
jp 0x2301b
jmp 0x23069
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movsd 0x20(%rax), %xmm0
movss -0x10(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
cvtss2sd %xmm1, %xmm1
callq 0x1080
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
mulsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movsd 0x28(%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22fb3
cvtsi2sdl -0xc(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x230ea
movsd -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movsd 0x28(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x230b2
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Compute_pow_ia
double **Compute_pow_ia(int npara, int nsam){
  double **pow_ia=Allocate_mat2_d(nsam, npara);
  for(int a=0; a<npara; a++){
    for(int i=1; i<nsam; i++)pow_ia[i][a]=pow(i,a);
  }
  return(pow_ia);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl -0x4(%rbp), %esi
callq 0x694a0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x26097
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2608a
cvtsi2sdl -0x18(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
callq 0x1080
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26053
jmp 0x2608c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26044
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Get_fit_para
void Get_fit_para(double *para, double *y, double **Corr_inv,
		  int npara, int nsam, float scale)
{
  // p_a*d^a = sum_b C^(-1)_ab sum_i i^b*y_i = C^(-1) Y
  double YX[npara]; int a, b, i;
  for(a=0; a<npara; a++){
    YX[a]=0; for(i=1; i<nsam; i++)YX[a]+=pow_ia[i][a]*y[i]; //pow(i,a)
  }
  for(a=0; a<npara; a++){
    para[a]=0;
    for(b=0; b<npara; b++)para[a]+=Corr_inv[a][b]*YX[b];
    para[a]*=pow(scale, -a);
  }
  if(0){
    printf("Y for fit: "); for(a=1; a<npara; a++)printf(" %.2g",y[a]);
    printf("\n");
    printf("YX for fit: "); for(a=0; a<npara; a++)printf(" %.2g",YX[a]);
    printf("\n");
    for(a=0; a<npara; a++){if(isnan(YX[a]))exit(8);}
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x26f8c
movq -0x50(%rbp), %rax
movslq -0x3c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x26f7f
movq -0x50(%rbp), %rax
movq 0x75330(%rip), %rcx     # 0x9c270
movslq -0x44(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x3c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x10(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x26f2d
jmp 0x26f81
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x26f0e
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2703c
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x27005
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x40(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movslq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x26fb6
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorl %eax, %eax
subl -0x3c(%rbp), %eax
cvtsi2sd %eax, %xmm1
callq 0x1080
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x26f93
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Polynomial
float Polynomial(float x, double *para, int n){
  // E_i~E(x0)+sum_a=1^4 (p_a*d^a)*i^a i=1...4
  double y=0;
  for(int a=1; a<n; a++)y+=para[a]*pow(x,a);
  return(y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x270c5
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
callq 0x1080
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x27073
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Native_interactions
int **Native_interactions(struct interaction *Int_list, int N_int,
			  atom *atoms, int nres)
{
  int **matrix=malloc(nres*sizeof (int *)); int i1, i2;
  for(i1=0; i1<nres; i1++){
    matrix[i1]=malloc(nres*sizeof(int));
    for(i2=0; i2<nres; i2++)matrix[i1][i2]=-1;
  }
  struct interaction *Int=Int_list;
  for(int n=0; n<N_int; n++){
    i1=atoms[Int->i1].res;
    i2=atoms[Int->i2].res;
    if((i1<0)||(i1>=nres)||(i2<0)||(i2>=nres)){
      printf("ERROR in Native_interactions i1=%d i2= %d nres=%d n= %d\n",
	     i1, i2, nres, n); exit(8);
    }
    matrix[i1][i2]=n;
    matrix[i2][i1]=n;
    Int++;
  }
  printf("\n%d native interactions stored\n", N_int);
  return(matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1180
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x27170
movslq -0x1c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x27163
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x27139
jmp 0x27165
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2710e
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x27245
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x64(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x64(%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x271d8
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x271d8
cmpl $0x0, -0x30(%rbp)
jl 0x271d8
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x271fd
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x3c(%rbp), %r8d
leaq 0x557c5(%rip), %rdi     # 0x7c9b1
movb $0x0, %al
callq 0x10d0
movl $0x8, %edi
callq 0x1210
movl -0x3c(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x38(%rbp), %rax
addq $0xc8, %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2717f
movl -0xc(%rbp), %esi
leaq 0x5579b(%rip), %rdi     # 0x7c9ea
movb $0x0, %al
callq 0x10d0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/anharmonic_tnm.c
// Function: Find_CA
int Find_CA(atom *atoms, int *i1, int res, int natoms){
  atom *atom=atoms+*i1; int i=*i1;
  while(atom->res <= res){
    if((atom->res == res)&&(strncmp(atom->name, "CA", 2)==0)){
      *i1=i; return(0);
    }
    atom++; i++; if(i>=natoms)break;
  }
  if(*i1)(*i1)--;
  if(atoms[*i1].res==res)return(0);
  return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x64(%rax), %eax
cmpl -0x1c(%rbp), %eax
jg 0x272fe
movq -0x28(%rbp), %rax
movl 0x64(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x272dd
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
leaq 0x4f04c(%rip), %rsi     # 0x76308
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x272dd
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2733c
movq -0x28(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x272fc
jmp 0x272fe
jmp 0x27295
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x27312
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x64(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x27335
movl $0x0, -0x4(%rbp)
jmp 0x2733c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)