LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x18fcd
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %r13d
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x18fed
movl %eax, %ebp
leaq 0x4(%r15), %rdi
movq %r14, %rsi
callq 0x18fed
movl %eax, %r12d
movslq (%r15), %rax
imulq $0x70, %rax, %rdi
addq %r14, %rdi
movslq 0x4(%r15), %rax
imulq $0x70, %rax, %rsi
addq %r14, %rsi
callq 0x144c2
cvtss2sd %xmm0, %xmm0
ucomisd 0x380b9(%rip), %xmm0    # 0x51060
jb 0x18faf
sqrtsd %xmm0, %xmm0
jmp 0x18fb4
callq 0x2290
addl %ebp, %ebx
addl %r12d, %ebx
movsd %xmm0, 0x20(%r15)
addq $0xc8, %r15
decq %r13
jne 0x18f65
jmp 0x18fcf
xorl %ebx, %ebx
leaq 0x3e00e(%rip), %rdi     # 0x56fe4
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/interactions_tnm.c
// Function: Heavy_atom
int Heavy_atom(int *iatom, atom *atoms)
{
  if(atoms[*iatom].name[0]!='H')return(0); // Not hydrogen atoms
  atom *atom1=atoms+*iatom;
  int i, imin=*iatom, res=atom1->res;
  double dmin=100, *r=atom1->r;
  char branch=atom1->name[1];
  if((branch=='N')||(branch=='1')||(branch=='2')||(branch=='3'))branch=' ';
  for(i=*iatom-1; i>=0; i--){
    atom1--; if(atom1->res!=res)break;
    if((atom1->name[0]!='H')&&(atom1->name[1]==branch)){
      double x=r[0]-atom1->r[0], d=x*x;
      x=r[1]-atom1->r[1]; d+=x*x;
      x=r[2]-atom1->r[2]; d+=x*x;
      if(d<dmin){dmin=d; imin=i;}
    }
  }

  if(*iatom==imin){
    printf("WARNING, atom %s %d, no heavy atom found\n",
	   atoms[*iatom].name, *iatom); return(0);
  }else if(dmin > 4){
    printf("WARNING, atom %s %d, heavy atom %s %d has d=%.3f\n",
	   atoms[*iatom].name, *iatom, atoms[imin].name, imin, dmin);
  }
  *iatom=imin; return(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl (%rdi), %edx
movslq %edx, %rax
imulq $0x70, %rax, %rax
xorl %ebp, %ebp
cmpb $0x48, 0x18(%rsi,%rax)
jne 0x1911f
movq %rdi, %rbx
testl %edx, %edx
jle 0x190be
leaq (%rsi,%rax), %rcx
movsbl 0x19(%rcx), %r9d
leal -0x31(%r9), %edi
cmpb $0x3, %dil
movl $0x20, %r10d
movl %r9d, %edi
cmovbl %r10d, %edi
movl 0x64(%rcx), %r8d
cmpl $0x4e, %r9d
cmovel %r10d, %edi
leal 0x1(%rdx), %r9d
leaq (%rax,%rsi), %r10
addq $-0x70, %r10
movsd 0x3ded1(%rip), %xmm0    # 0x56f20
movl %edx, %ebp
cmpl %r8d, 0x64(%r10)
jne 0x190c8
cmpb $0x48, 0x18(%r10)
je 0x190af
movsbl 0x19(%r10), %r11d
cmpl %r11d, %edi
jne 0x190af
movsd (%rcx), %xmm1
movsd 0x8(%rcx), %xmm2
subsd (%r10), %xmm1
mulsd %xmm1, %xmm1
subsd 0x8(%r10), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rcx), %xmm1
subsd 0x10(%r10), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
leal -0x2(%r9), %r11d
cmoval %r11d, %ebp
minsd %xmm0, %xmm1
movapd %xmm1, %xmm0
decl %r9d
addq $-0x70, %r10
cmpl $0x1, %r9d
jg 0x19051
jmp 0x190c8
movsd 0x3de5a(%rip), %xmm0    # 0x56f20
movl %edx, %ebp
cmpl %ebp, %edx
jne 0x190e5
addq %rax, %rsi
addq $0x18, %rsi
leaq 0x3df34(%rip), %rdi     # 0x5700e
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x20f0
jmp 0x1911f
ucomisd 0x3de3b(%rip), %xmm0    # 0x56f28
jbe 0x19118
addq %rsi, %rax
addq $0x18, %rax
movslq %ebp, %rcx
imulq $0x70, %rcx, %rcx
addq %rsi, %rcx
addq $0x18, %rcx
leaq 0x3df2d(%rip), %rdi     # 0x57038
movq %rax, %rsi
movl %ebp, %r8d
movb $0x1, %al
callq 0x20f0
movl %ebp, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
leaq 0x4f992(%rip), %rax     # 0x69070
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
jae 0x1971d
leaq 0x4f97a(%rip), %rax     # 0x69068
movss (%rax), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm2
jbe 0x1977e
leaq 0x4f983(%rip), %rax     # 0x69088
subss %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
mulsd (%rax), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
jmp 0x1977e
leaq 0x4eec8(%rip), %rax     # 0x685ec
cmpl $0x0, (%rax)
leaq 0x4f952(%rip), %rax     # 0x69080
movsd (%rax), %xmm1
movsd %xmm1, (%rsp)
leaq 0x4f92e(%rip), %rax     # 0x6906c
movss (%rax), %xmm1
je 0x1975a
cvtss2sd %xmm0, %xmm0
xorps 0x3d1e1(%rip), %xmm1    # 0x56930
cvtss2sd %xmm1, %xmm1
callq 0x20a0
jmp 0x19771
xorps 0x3d1cf(%rip), %xmm0    # 0x56930
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x22a0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movaps %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/interactions_tnm.c
// Function: Select_pairs
void Select_pairs(int *selected, struct interaction **res12, int n12)
{
  int k, kopt=0, nsel=0; float w=0;
  //selected: 0=not yet -1=discarded 1=selected
  for(k=0; k<n12; k++)selected[k]=0;
  while(kopt>=0){
    kopt=-1;
    for(k=0; k<n12; k++){
      if(selected[k])continue;
      if(res12[k]->sec_der==1){
	if((kopt<0)||(res12[k]->r0 < w)){
	  kopt=k; w=res12[k]->r0; 
	}
      }else{
	if((kopt<0)||(res12[k]->sec_der > w)){
	  kopt=k; w=res12[k]->sec_der;
	}
      } 
    }
    if(kopt<0)return;
    selected[kopt]=1; nsel++;
    int i1=res12[kopt]->i1, i2=res12[kopt]->i2;
    for(k=0; k<n12; k++){
      if(selected[k])continue;
      if((res12[k]->i1==i1)||(res12[k]->i2==i2))selected[k]=-1;
    }
  }
  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
testl %edx, %edx
jle 0x19c13
leaq (,%r12,4), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2110
xorps %xmm1, %xmm1
movsd 0x37422(%rip), %xmm0    # 0x51040
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ebx, %ebx
jle 0x19c7f
xorl %ecx, %ecx
cmpl $0x0, (%r15,%rcx,4)
jne 0x19c77
movq (%r14,%rcx,8), %rdx
movsd 0x28(%rdx), %xmm2
ucomisd %xmm0, %xmm2
jne 0x19c5d
jp 0x19c5d
testl %eax, %eax
js 0x19c53
xorps %xmm2, %xmm2
cvtss2sd %xmm1, %xmm2
ucomisd 0x20(%rdx), %xmm2
jbe 0x19c77
xorps %xmm1, %xmm1
cvtsd2ss 0x20(%rdx), %xmm1
jmp 0x19c75
testl %eax, %eax
js 0x19c6e
xorps %xmm3, %xmm3
cvtss2sd %xmm1, %xmm3
ucomisd %xmm3, %xmm2
jbe 0x19c77
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movl %ecx, %eax
incq %rcx
cmpq %rcx, %r12
jne 0x19c29
testl %eax, %eax
js 0x19cc5
movl %eax, %eax
movl $0x1, (%r15,%rax,4)
testl %ebx, %ebx
jle 0x19c1e
movq (%r14,%rax,8), %rcx
movl (%rcx), %eax
movl 0x4(%rcx), %ecx
xorl %edx, %edx
cmpl $0x0, (%r15,%rdx,4)
jne 0x19cb8
movq (%r14,%rdx,8), %rsi
cmpl %eax, (%rsi)
je 0x19cb0
cmpl %ecx, 0x4(%rsi)
jne 0x19cb8
movl $0xffffffff, (%r15,%rdx,4) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %r12
jne 0x19c9c
jmp 0x19c1e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movslq (%rdi), %rax
imulq $0xc8, %rax, %r12
movq %r12, %rdi
callq 0x21d0
movq %rax, %r14
testl %ebp, %ebp
movq %rbx, 0x10(%rsp)
jle 0x19d7c
addq %rbx, %r12
xorl %r13d, %r13d
xorl %ebx, %ebx
movl %ebx, %r15d
leal 0x1(%r15), %ebx
movl %ebx, 0x8(%rsp)
cmpl %ebp, %ebx
jge 0x19d76
leaq 0xc(%rsp), %rdi
movl %r15d, %esi
leaq 0x8(%rsp), %rdx
movl %ebp, %ecx
leaq 0x20(%rsp), %r8
movq %r12, %r9
callq 0x19db9
testq %rax, %rax
je 0x19d61
movslq %r13d, %r13
imulq $0xc8, %r13, %rdi
addq %r14, %rdi
movl $0xc8, %edx
movq %rax, %rsi
callq 0x21a0
incl %r13d
cmpl $0x0, 0xc(%rsp)
jne 0x19d76
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl %ebp, %eax
jl 0x19d23
cmpl %ebp, %ebx
jne 0x19d14
jmp 0x19d7f
xorl %r13d, %r13d
testl %r13d, %r13d
jle 0x19d9b
movl %r13d, %eax
imulq $0xc8, %rax, %rdx
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x21a0
movq 0x18(%rsp), %rax
movl %r13d, (%rax)
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl $0x0, (%rdi)
movq (%r8), %r10
xorl %eax, %eax
movl %ecx, %r11d
cmpq %r9, %r10
jae 0x19e23
cmpl %esi, 0x8(%r10)
jg 0x19e23
jne 0x19e1a
movl 0xc(%r10), %ebx
movl (%rdx), %ebp
cmpl %ebp, %ebx
jne 0x19e0a
testq %rax, %rax
je 0x19e05
movsd 0x28(%r10), %xmm0
ucomisd 0x28(%rax), %xmm0
ja 0x19e05
jne 0x19e1a
jp 0x19e1a
movsd 0x20(%rax), %xmm0
ucomisd 0x20(%r10), %xmm0
jbe 0x19e1a
movq %r10, %rax
jmp 0x19e1a
cmpl %r11d, %ebx
movl %r11d, %r14d
cmovll %ebx, %r14d
cmpl %ebp, %ebx
cmovgl %r14d, %r11d
addq $0xc8, %r10
jmp 0x19dcb
cmpl %ecx, %r11d
jne 0x19e33
movq %r10, (%r8)
movl $0x1, (%rdi)
jmp 0x19e39
decl %r11d
movl %r11d, (%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3c0d8(%rip), %rsi     # 0x55f23
movl $0x2, %edx
callq 0x2070
movl $0x1, %ebp
testl %eax, %eax
je 0x19e92
leaq 0x3b305(%rip), %rsi     # 0x5516a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
je 0x19e92
leaq 0x3c0a9(%rip), %rsi     # 0x55f26
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2070
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
testl %esi, %esi
jle 0x19f3e
movaps %xmm0, %xmm2
movaps 0x3ca6f(%rip), %xmm0    # 0x56930
xorps %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
imulq $0xc8, %r14, %r15
xorl %r12d, %r12d
xorpd %xmm1, %xmm1
movaps %xmm2, 0x10(%rsp)
movsd 0x20(%rbx,%r12), %xmm0
xorpd %xmm3, %xmm3
ucomisd %xmm0, %xmm3
jae 0x19f83
ucomiss 0x37110(%rip), %xmm2    # 0x5100c
jne 0x19f00
jnp 0x19f29
movsd %xmm1, 0x8(%rsp)
movsd (%rsp), %xmm1
callq 0x20a0
movaps 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x28(%rbx,%r12), %xmm0
movsd %xmm0, 0x28(%rbx,%r12)
addsd 0x28(%rbx,%r12), %xmm1
addq $0xc8, %r12
cmpq %r12, %r15
jne 0x19ee0
jmp 0x19f42
xorpd %xmm1, %xmm1
testl %ebp, %ebp
jle 0x19f76
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
imulq $0xc8, %r14, %rax
xorl %ecx, %ecx
movsd 0x28(%rbx,%rcx), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rbx,%rcx)
addq $0xc8, %rcx
cmpq %rcx, %rax
jne 0x19f5a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d266(%rip), %rdi     # 0x571f0
movb $0x1, %al
callq 0x20f0
movl $0x8, %edi
callq 0x2270
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl %esi, %edi
movl %ebp, %esi
callq 0x49798
movq %rax, %r14
testl %ebp, %ebp
jle 0x1bbc3
movl %ebp, %r15d
movl %ebx, %r12d
xorl %r13d, %r13d
cmpl $0x2, %ebx
jl 0x1bbbb
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd %xmm0, (%rsp)
movl $0x1, %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
callq 0x20a0
movq (%r14,%rbp,8), %rax
movsd %xmm0, (%rax,%r13,8)
incq %rbp
cmpq %rbp, %r12
jne 0x1bb98
incq %r13
cmpq %r15, %r13
jne 0x1bb81
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %ecx, %r15d
movq %rsp, %r12
leaq 0xf(,%r15,8), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
testl %ecx, %ecx
jle 0x1c6ec
movq 0x5cc0d(%rip), %rax     # 0x792b0
movl %r8d, %edx
xorl %edi, %edi
movq $0x0, (%r12,%rdi,8)
cmpl $0x2, %r8d
jl 0x1c6e4
movsd (%r12,%rdi,8), %xmm1
movl $0x1, %r9d
movq (%rax,%r9,8), %r10
movsd (%r10,%rdi,8), %xmm2
mulsd (%rsi,%r9,8), %xmm2
addsd %xmm2, %xmm1
incq %r9
cmpq %r9, %rdx
jne 0x1c6c2
movsd %xmm1, (%r12,%rdi,8)
incq %rdi
cmpq %r15, %rdi
jne 0x1c6a8
testl %ecx, %ecx
jle 0x1c754
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorl %r13d, %r13d
movq $0x0, (%r14,%r13,8)
movq (%rbx,%r13,8), %rax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
mulsd (%r12,%rcx,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r14,%r13,8)
incq %rcx
cmpq %rcx, %r15
jne 0x1c70d
movl %r13d, %eax
negl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd -0x30(%rbp), %xmm0
callq 0x20a0
mulsd (%r14,%r13,8), %xmm0
movsd %xmm0, (%r14,%r13,8)
incq %r13
cmpq %r15, %r13
jne 0x1c6fc
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
cmpl $0x2, %esi
jl 0x1c7e9
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl %esi, %r14d
xorps %xmm0, %xmm0
movl $0x1, %r15d
movsd %xmm0, 0x8(%rsp)
movsd (%rbx,%r15,8), %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x20a0
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
cmpq %r15, %r14
jne 0x1c793
cvtsd2ss %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, 0x8(%rsp)
movq %rdi, %r12
movl %ecx, 0xc(%rsp)
movslq %ecx, %rbx
leaq (,%rbx,8), %rdi
callq 0x21d0
movq %rax, %r14
testl %ebx, %ebx
jle 0x1c858
leaq (,%rbx,4), %r13
movl %ebx, %ebx
leaq (,%rbx,4), %rbp
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r14,%r15,8)
movq %rax, %rdi
movl $0xff, %esi
movq %rbp, %rdx
callq 0x2110
incq %r15
cmpq %r15, %rbx
jne 0x1c834
movl 0x8(%rsp), %r9d
testl %r9d, %r9d
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rdi
jle 0x1c8b8
xorl %r8d, %r8d
movslq (%r12), %rax
imulq $0x70, %rax, %rax
movslq 0x64(%rdi,%rax), %rsi
movslq 0x4(%r12), %rax
imulq $0x70, %rax, %rax
movl 0x64(%rdi,%rax), %edx
testq %rsi, %rsi
js 0x1c8db
cmpl %ecx, %esi
jge 0x1c8db
testl %edx, %edx
js 0x1c8db
cmpl %ecx, %edx
jge 0x1c8db
movq (%r14,%rsi,8), %rax
movl %r8d, (%rax,%rdx,4)
movq (%r14,%rdx,8), %rax
movl %r8d, (%rax,%rsi,4)
addq $0xc8, %r12
incl %r8d
cmpl %r8d, %r9d
jne 0x1c86e
leaq 0x3b052(%rip), %rdi     # 0x57911
movl %r9d, %esi
xorl %eax, %eax
callq 0x20f0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3aff6(%rip), %rdi     # 0x578d8
xorl %eax, %eax
callq 0x20f0
movl $0x8, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, 0x8(%rsp)
movslq (%rsi), %r13
imulq $0x70, %r13, %rax
movq %rdi, 0x10(%rsp)
leaq (%rax,%rdi), %r14
addq $0x64, %r14
leaq 0x38845(%rip), %r12     # 0x5516a
movl %r13d, %r15d
cmpl %ebx, (%r14)
jg 0x1c950
jne 0x1c944
leaq -0x4c(%r14), %rdi
movl $0x2, %edx
movq %r12, %rsi
callq 0x2070
testl %eax, %eax
je 0x1c986
incl %r15d
addq $0x70, %r14
cmpl %ebp, %r15d
jl 0x1c928
testl %r13d, %r13d
movq 0x8(%rsp), %rcx
je 0x1c960
leal -0x1(%r13), %eax
movl %eax, (%rcx)
movslq (%rcx), %rax
imulq $0x70, %rax, %rcx
xorl %eax, %eax
movq 0x10(%rsp), %rdx
cmpl %ebx, 0x64(%rdx,%rcx)
setne %al
negl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movl %r15d, (%rax)
xorl %eax, %eax
jmp 0x1c977
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/anharmonic_tnm.c
// Function: Initialize_energy
void Initialize_energy(struct interaction *Int_list, int N_int,
		       float *r, atom *atoms, int natoms, int nres)
{
  INI_ENERGY=1;

  E_repulsion=Int_list[0].A4;
  C22=C_THR*C_THR;
  lambda_2=2*lambda;
  lambda_4=4*lambda;
  
  // Auxiliary matrices for energy computation: interaction list
  nat_res1_res2=Native_interactions(Int_list, N_int, atoms, nres);
  // YY matrix with the index of the interaction data (in Int_list)
  INT_MAX=150*nres;
  Int_list_all=malloc(INT_MAX*sizeof(struct interaction));
  N_int_all=
    Interactions_CA(Int_list_all, d_CA_high, atoms, natoms, nres, r);
  N_int_ini=N_int_all;
  Int_list_ini=malloc(N_int_ini*sizeof(struct interaction));
  for(int i=0; i<N_int_ini; i++)Int_list_ini[i]=Int_list_all[i];
  // YY List of interactions with d(CA-CA)<22
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movl $0x1, 0x5c6a9(%rip)     # 0x7928c
cvtsd2ss 0x48(%rdi), %xmm0
leaq 0x4c4e9(%rip), %rax     # 0x690d8
movss %xmm0, (%rax)
leaq 0x4c46e(%rip), %rax     # 0x69068
movss (%rax), %xmm0
mulss %xmm0, %xmm0
movss %xmm0, 0x5c6d2(%rip)    # 0x792dc
leaq 0x4c4c3(%rip), %rax     # 0x690d4
movss (%rax), %xmm0
movaps %xmm0, %xmm1
addss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, 0x5c6b8(%rip)    # 0x792e0
mulss 0x3a2b8(%rip), %xmm0    # 0x56ee8
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x5c6ac(%rip)    # 0x792e8
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x1c7ea
movq %rax, 0x5c682(%rip)     # 0x792d0
imull $0x96, %ebx, %eax
movl %eax, 0x5c67e(%rip)     # 0x792d8
cltq
imulq $0xc8, %rax, %rdi
callq 0x21d0
movq %rax, 0x5c651(%rip)     # 0x792c0
movss 0x4c219(%rip), %xmm0    # 0x68e90
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
movq %r14, %r8
callq 0x1bbd5
movl %eax, %ebp
movl %eax, 0x5c62b(%rip)     # 0x792bc
movl %eax, 0x5c621(%rip)     # 0x792b8
movslq %eax, %r14
imulq $0xc8, %r14, %rdi
callq 0x21d0
movq %rax, 0x5c61b(%rip)     # 0x792c8
testl %r14d, %r14d
jle 0x1cce6
movq %rax, %rbx
movq 0x5c604(%rip), %r14     # 0x792c0
movl %ebp, %eax
imulq $0xc8, %rax, %r15
xorl %r12d, %r12d
leaq (%rbx,%r12), %rdi
leaq (%r14,%r12), %rsi
movl $0xc8, %edx
callq 0x21a0
addq $0xc8, %r12
cmpq %r12, %r15
jne 0x1ccc8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/anharmonic_tnm.c
// Function: Dist_thr
int Dist_thr(struct interaction *Int_cov, atom *atoms){
  if(Int_cov->i1>=0 && Int_cov->i2>=0){   
    double *r1=atoms[Int_cov->i1].r, *r2=atoms[Int_cov->i2].r;
    double d2=0, d; for(int j=0; j<3; j++){d=r1[j]-r2[j]; d*=d; d2+=d;}
    Int_cov->r0=sqrt(d2);
    if(Int_cov->r0 < C_THR){return(1);}
    else{return(0);}
  }
  return(0);
}

// Assembly:
movslq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
js 0x1dcc1
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rdi), %rdx
testq %rdx, %rdx
js 0x1dcc0
imulq $0x70, %rcx, %rax
addq %rsi, %rax
imulq $0x70, %rdx, %rcx
addq %rsi, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm1
subsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq $0x3, %rdx
jne 0x1dc74
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1dc9f
sqrtsd %xmm0, %xmm0
jmp 0x1dca4
callq 0x2290
movsd %xmm0, 0x20(%rbx)
leaq 0x4b3b8(%rip), %rax     # 0x69068
xorps %xmm1, %xmm1
cvtss2sd (%rax), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/anharmonic_tnm.c
// Function: Print_interactions
void Print_interactions(struct interaction *Int_list, int N_int,
			struct interaction **Int_KB,
			int *aa_seq, char *AA_code, int NA, char *name)
{
  // Prepare for printing
  char nameout[100];
  sprintf(nameout,"%s.Inter_SB_KB.dat",name);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  int printed[4]; for(int i=0; i<4; i++)printed[i]=0;
  fprintf(file_out, "# NPAR= %d\n#r V(r)\n", NPAR);

  int n, nprint=0; struct interaction *Int=Int_list;
  for(n=0; n<N_int; n++){
    int a=aa_seq[Int->res1], b=aa_seq[Int->res1];
    struct interaction *I_KB=Int_KB[a]+b;
    int type;
    if(Int->r0>I_KB->r0){type=0;}else{type=2;}
    if(I_KB->E_min>0)type++;
    if(printed[type]==0){
      Print_potential(file_out, Int, a, b, "Structure-based", AA_code);
      Print_potential(file_out, I_KB, a,b, "Knowledge-based", AA_code);
      printed[type]=1; nprint++;
      if(nprint==4)break;
    }
    Int++;
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movq 0xe0(%rsp), %rdx
leaq 0x390e1(%rip), %rsi     # 0x5804f
movl $0x0, 0x4(%rsp)
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2260
leaq 0x382b4(%rip), %rsi     # 0x57240
movq %rbx, %rdi
callq 0x2210
movq %rax, %r13
leaq 0x32d3d(%rip), %rdi     # 0x51cdb
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20f0
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movl 0x49ec8(%rip), %edx     # 0x68e80
leaq 0x390a3(%rip), %rsi     # 0x58062
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %eax, %eax
callq 0x2190
testl %ebp, %ebp
jle 0x1f0c2
movq %r12, %rsi
movq %r15, %r8
decl %ebp
xorpd %xmm1, %xmm1
movq %r14, 0x18(%rsp)
movq %r15, 0x10(%rsp)
movq 0x8(%rsp), %r12
movslq 0x8(%rsi), %rax
movslq (%r14,%rax,4), %rbx
movq (%r8,%rbx,8), %r13
imulq $0xc8, %rbx, %rax
movsd 0x20(%rsi), %xmm0
xorl %ecx, %ecx
ucomisd 0x20(%r13,%rax), %xmm0
setbe %cl
movsd 0xb8(%r13,%rax), %xmm0
xorl %edx, %edx
ucomisd %xmm1, %xmm0
seta %dl
leaq (%rdx,%rcx,2), %r15
cmpl $0x0, 0x30(%rsp,%r15,4)
jne 0x1f0a7
addq %rax, %r13
movq %r12, %rdi
movl %ebx, %edx
movl %ebx, %ecx
movq %rsi, 0x28(%rsp)
leaq 0x3902c(%rip), %r8      # 0x58076
movq 0x20(%rsp), %r14
movq %r14, %r9
callq 0x1f0de
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
movl %ebx, %ecx
leaq 0x3901e(%rip), %r8      # 0x58086
movq %r14, %r9
movq 0x18(%rsp), %r14
callq 0x1f0de
xorpd %xmm1, %xmm1
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %r8
movl $0x1, 0x30(%rsp,%r15,4)
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl $0x4, %eax
jne 0x1f0a7
movb $0x1, %al
movl $0x4, 0x4(%rsp)
jmp 0x1f0b0
addq $0xc8, %rsi
xorl %eax, %eax
subl $0x1, %ebp
setb %cl
testb %al, %al
jne 0x1f0c2
testb %cl, %cl
je 0x1eff1
movq 0x8(%rsp), %rdi
callq 0x20c0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/anharmonic_tnm.c
// Function: Print_potential
void Print_potential(FILE *file_out, struct interaction *Int,
		     int a, int b, char *what, char *AA_code)
{
  fprintf(file_out, "# %s potential %c-%c, r0= %.2f Vmin= %.3f V''= %.3f\n",
	  what, AA_code[a], AA_code[b], Int->r0, Int->E_min, Int->sec_der);
  fprintf(file_out, "# A4= %.3g A2= %.3g A1= %.3g A0= %.3g\n",
	  Int->A4, Int->A2, Int->A1, Int->A0);
  fprintf(file_out, "# r1= %.2f r2= %.2f r3= %.2f\n", Int->r1, Int->r2, Int->r3);
  int n=100; float r=1.5, dr=(5.0-r)/n;
  for(int k=0; k<n; k++){
    fprintf(file_out, "%.2f %.4g\n", r, Compute_V(Int, r)); r+=dr;
  }
  fprintf(file_out, "&\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r10
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %rax
movsbl (%r9,%rax), %eax
movslq %ecx, %rcx
movsbl (%r9,%rcx), %r8d
movsd 0xb8(%rsi), %xmm1
movsd 0x20(%rsi), %xmm0
movsd 0x28(%rsi), %xmm2
leaq 0x38f8c(%rip), %rsi     # 0x580a6
movq %r10, %rdx
movl %eax, %ecx
movb $0x3, %al
callq 0x2190
movsd 0x48(%r14), %xmm0
movsd 0x40(%r14), %xmm1
movsd 0x30(%r14), %xmm3
movsd 0x38(%r14), %xmm2
leaq 0x38f96(%rip), %rsi     # 0x580db
movq %rbx, %rdi
movb $0x4, %al
callq 0x2190
xorps %xmm0, %xmm0
cvtss2sd 0x10(%r14), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x14(%r14), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x18(%r14), %xmm2
leaq 0x38f91(%rip), %rsi     # 0x58102
movq %rbx, %rdi
movb $0x3, %al
callq 0x2190
movss 0x38189(%rip), %xmm0    # 0x5730c
movl $0x64, %ebp
leaq 0x38f91(%rip), %r15     # 0x58120
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
callq 0x1ccef
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movsd 0x10(%rsp), %xmm0
movb $0x2, %al
callq 0x2190
movss 0xc(%rsp), %xmm0
addss 0x3813b(%rip), %xmm0    # 0x57310
decl %ebp
jne 0x1f18f
leaq 0x38f4b(%rip), %rdi     # 0x5812b
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2280
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/anharmonic_tnm.c
// Function: Print_interactions_KB
void Print_interactions_KB(struct interaction **Int_KB,
			   char *AA_code, int NA, char *name)
{
  // Prepare for printing
  char nameout[100];
  sprintf(nameout,"%s.Inter_KB.dat",name);
  FILE *file_out=fopen(nameout, "w");
  printf("Writing %s\n", nameout);
  fprintf(file_out, "# NPAR= %d\n#r V(r)\n", NPAR);
  for(int a=0; a<NA; a++){
    for(int b=0; a<NA; a++){
      struct interaction *I_KB=Int_KB[a]+b;
      Print_potential(file_out, I_KB, a,b, "Knowledge-based", AA_code);
    }
  }
  fclose(file_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x38e7d(%rip), %rsi     # 0x58096
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2260
leaq 0x3800b(%rip), %rsi     # 0x57240
movq %rbp, %rdi
callq 0x2210
movq %rax, %r13
leaq 0x32a94(%rip), %rdi     # 0x51cdb
movq %rbp, %rsi
xorl %eax, %eax
callq 0x20f0
movl 0x49c29(%rip), %edx     # 0x68e80
leaq 0x38e04(%rip), %rsi     # 0x58062
movq %r13, %rdi
xorl %eax, %eax
callq 0x2190
movl %ebx, 0xc(%rsp)
testl %ebx, %ebx
jle 0x1f2a7
movl 0xc(%rsp), %ebx
leaq 0x38e0b(%rip), %rbp     # 0x58086
movslq %r12d, %r12
movq (%r15,%r12,8), %rsi
movq %r13, %rdi
movl %r12d, %edx
xorl %ecx, %ecx
movq %rbp, %r8
movq %r14, %r9
callq 0x1f0de
incq %r12
cmpq %rbx, %r12
jl 0x1f27e
incl %r12d
cmpl 0xc(%rsp), %r12d
jl 0x1f27b
movq %r13, %rdi
callq 0x20c0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/contacts.c
// Function: Write_contact_list
void Write_contact_list(short **cont_i, short **cont_j,
			struct interaction *Int_list, int *N_int)
{
  int k, nc=0, res1=-1, res2=-1;
  for(k=0; k<*N_int; k++){
    if((Int_list[k].res1!=res1)||(Int_list[k].res2!=res2)){
      res1=Int_list[k].res1; res2=Int_list[k].res2; nc++;
    } 
  }

  *cont_i=malloc(nc*sizeof(int));
  *cont_j=malloc(nc*sizeof(int));
  nc=0; res1=-1; res2=-1;
  for(k=0; k<*N_int; k++){
    if((Int_list[k].res1!=res1)||(Int_list[k].res2!=res2)){
      res1=Int_list[k].res1; res2=Int_list[k].res2;
      (*cont_i)[nc]=res1;
      (*cont_j)[nc]=res2;
      nc++;
    } 
  }
  *N_int=nc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rcx, (%rsp)
movslq (%rcx), %rbx
xorl %ebp, %ebp
testq %rbx, %rbx
jle 0x1fa50
imulq $0xc8, %rbx, %rax
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl 0x8(%r14,%rcx), %r8d
cmpl %edi, %r8d
jne 0x1fa31
cmpl %edx, 0xc(%r14,%rcx)
je 0x1fa3b
movl 0xc(%r14,%rcx), %edx
incl %esi
movl %r8d, %edi
addq $0xc8, %rcx
cmpq %rcx, %rax
jne 0x1fa20
movslq %esi, %r13
shlq $0x2, %r13
jmp 0x1fa53
xorl %r13d, %r13d
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r15)
movq %r13, %rdi
callq 0x21d0
movq %rax, (%r12)
testl %ebx, %ebx
jle 0x1fab9
imulq $0xc8, %rbx, %rcx
xorl %edx, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movl 0x8(%r14,%rdx), %r8d
cmpl %edi, %r8d
jne 0x1fa94
cmpl %esi, 0xc(%r14,%rdx)
je 0x1faad
movl 0xc(%r14,%rdx), %esi
movq (%r15), %rdi
movslq %ebp, %rbp
movw %r8w, (%rdi,%rbp,2)
movw %si, (%rax,%rbp,2)
incl %ebp
movl %r8d, %edi
addq $0xc8, %rdx
cmpq %rdx, %rcx
jne 0x1fa83
movq (%rsp), %rax
movl %ebp, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/contacts.c
// Function: Contact_energy
float Contact_energy(struct interaction *Int_list, int N_int,
		     struct residue *seq){
  double E=0; int i, ai, aj, res=-1;
  for(i=0; i<N_int; i++){
    ai=Code_AA(seq[Int_list[i].res1].amm);
    if(ai<0){
      if(res!=Int_list[i].res1){
        res=Int_list[i].res1;
	printf("WARNING, unknown a.a. %c residue %d\n",seq[res].amm, res);
      }
      continue;
    }
    aj=Code_AA(seq[Int_list[i].res2].amm);
    if(aj<0){
      if(res!=Int_list[i].res2){
        res=Int_list[i].res2;
	printf("WARNING, unknown a.a. %c residue %d\n",seq[res].amm, res);
      }
      continue;
    }
    E+=Econt[ai][aj];
  }
  return(E);
}

// Assembly:
testl %esi, %esi
jle 0x1fbd4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl %esi, %eax
imulq $0xc8, %rax, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movslq 0x8(%r14,%r15), %r12
movq %r12, %rax
shlq $0x5, %rax
movsbl 0x13(%rdx,%rax), %r13d
movl %r13d, %edi
callq 0x1fbd8
testl %eax, %eax
js 0x1fb7f
movl %eax, %ebp
movslq 0xc(%r14,%r15), %r12
movq %r12, %rax
shlq $0x5, %rax
movq 0x8(%rsp), %rcx
movsbl 0x13(%rcx,%rax), %r13d
movl %r13d, %edi
callq 0x1fbd8
testl %eax, %eax
js 0x1fb7f
leaq 0x49626(%rip), %rcx     # 0x69180
movq (%rcx), %rcx
movl %ebp, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
jmp 0x1fb84
cmpl %r12d, %ebx
jne 0x1fb89
movl %ebx, %r12d
jmp 0x1fb9d
leaq 0x388d9(%rip), %rdi     # 0x58469
movl %r13d, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x20f0
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r14
addq $0xc8, %r15
movl %r12d, %ebx
cmpq %r15, 0x20(%rsp)
jne 0x1fb10
xorps %xmm0, %xmm0
cvtsd2ss 0x18(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/contacts.c
// Function: Code_AA
int Code_AA(char res){
  int i; for(i=0; i<20; i++)if(res==AA_code[i])return(i);
  if(res=='-')return(20); // gap
  i=(int)res; char r; if(i>96){r=(char)(i-32);}else{r=res;}
  for(i=0; i<20; i++)if(r==AA_code[i])return(i);
  //printf("WARNING, wrong aa type %c\n", res);
  return(-1);
}

// Assembly:
leaq 0x49599(%rip), %rcx     # 0x69178
movq (%rcx), %rdx
xorl %eax, %eax
cmpb %dil, (%rdx,%rax)
je 0x1fc27
incq %rax
cmpq $0x14, %rax
jne 0x1fbe4
movl $0x14, %eax
cmpb $0x2d, %dil
je 0x1fc27
leal -0x20(%rdi), %eax
cmpb $0x61, %dil
movzbl %dil, %esi
movzbl %al, %edx
cmovll %esi, %edx
movq (%rcx), %rcx
xorl %eax, %eax
cmpb (%rcx,%rax), %dl
je 0x1fc27
incq %rax
cmpq $0x14, %rax
jne 0x1fc14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/screened_interactions.c
// Function: Rank
void Rank(struct ranked *rank,  int i, float x, int Rmax)
{
  // Rank in decreasing order (lowest = 0)
  if((rank->num >= Rmax)&&(x >= rank->last->x))return;

  struct store *store;
  if(rank->num==0){
    store=rank->store;
    store->i=i; store->x=x;
    store->next=NULL;
    rank->num=1;
    rank->first=store;
    rank->last= store;
    return;
  }

  // Find position in the list
  struct store *k=rank->first, *k1=k->next;
  while(k1!=NULL){
    if(k1->x >= x)break;
    k=k1; k1=k1->next;
  }

  if(rank->num < Rmax){
    store=rank->store+rank->num;
    (rank->num)++;
    if(x > rank->last->x)rank->last=store;
  }else if(k1==NULL){
    store=k; rank->last=k;
  }else{
    store=rank->last;
    if(k1==rank->last){
      k1=NULL;
    }else{
      struct store *k2=k1, *k3=k1->next->next;
      while(k3!=NULL){k2=k2->next; k3=k3->next;}
      rank->last=k2; k2->next=NULL;
    }
  }
  if(x < rank->first->x){
    rank->first=store; k1=k;
  }else{
    k->next=store;
  }
  store->i=i; store->x=x; store->next=k1;

  /*printf("%d: ", rank->num);
  struct store *k2=rank->first; float y=0;
  while(k2!=NULL){
    printf("%.2f ", k2->x); 
    if(k2->x < y){
      printf("\nERROR bad ordered list\n");
      exit(8);
    }
    y=k2->x; k2=k2->next;
  }
  printf("\n");*/

  return;
}

// Assembly:
pushq %rbx
movslq (%rdi), %r11
cmpq $0x7d0, %r11            # imm = 0x7D0
jl 0x2035b
movq 0x18(%rdi), %rax
ucomiss 0x4(%rax), %xmm0
jae 0x2043d
testl %r11d, %r11d
je 0x203b0
leaq 0x10(%rdi), %rax
movq 0x10(%rdi), %r8
movq %r8, %rcx
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x20381
movss 0x4(%rcx), %xmm1
ucomiss %xmm0, %xmm1
jb 0x2036b
leaq 0x8(%rdx), %r9
cmpl $0x7cf, %r11d           # imm = 0x7CF
jg 0x203d3
movq %r11, %r10
shlq $0x4, %r10
incl %r11d
addq 0x8(%rdi), %r10
movl %r11d, (%rdi)
movq 0x18(%rdi), %r11
ucomiss 0x4(%r11), %xmm0
jbe 0x2041c
movq %r10, 0x18(%rdi)
jmp 0x2041c
movq 0x8(%rdi), %rax
movl %esi, (%rax)
movss %xmm0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movl $0x1, (%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
jmp 0x2043d
testq %rcx, %rcx
je 0x2040f
movq 0x18(%rdi), %r10
cmpq %r10, %rcx
je 0x2041a
movq 0x8(%rcx), %r11
movq 0x8(%r11), %r11
movq %rcx, %rbx
testq %r11, %r11
je 0x20401
movq %rcx, %rbx
movq 0x8(%rbx), %rbx
movq 0x8(%r11), %r11
testq %r11, %r11
jne 0x203f4
movq %rbx, 0x18(%rdi)
movq $0x0, 0x8(%rbx)
jmp 0x2041c
movq %rdx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rdx, %r10
jmp 0x2041c
xorl %ecx, %ecx
movss 0x4(%r8), %xmm1
ucomiss %xmm0, %xmm1
cmovaq %rax, %r9
cmovaq %rdx, %rcx
movq %r10, (%r9)
movl %esi, (%r10)
movss %xmm0, 0x4(%r10)
movq %rcx, 0x8(%r10)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/screened_interactions.c
// Function: Screening_distance
int Screening_distance(float *d2_nb, float *d2_bo, float D2_NB, float D2_BO,
		       struct store *store1, float d2_ij,
		       atom *atom_i, atom *atom_j, atom *atoms)
{
  int resi=atom_i->res, resj=atom_j->res;
  while(store1 != NULL){
    if(store1->x > d2_ij)break; // store1->x= d2_ik
    atom *atom_k=atoms+store1->i;
    if(atom_k!=atom_j){
      float d2, d2_jk=Dist2(atom_j->r, atom_k->r);
      if(d2_jk >= d2_ij)goto next3;
      if(d2_jk > store1->x){
	d2=d2_jk;
      }else{
	d2=store1->x;
      }
      if(d2 < D2_NB){
	int bond=Bond(atom_k->res, resi, store1->x, resj, d2_jk);
	if(bond){
	  if(d2 < D2_BO){*d2_bo=d2; return(1);}
	}else{
	  if(d2 < D2_NB){*d2_nb=d2; return(1);}
	}
      }
    }
  next3:
    store1=store1->next;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r15
movss %xmm1, 0x8(%rsp)
movaps %xmm0, %xmm4
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %ebp
movl 0x64(%r8), %r12d
movss %xmm2, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
xorl %eax, %eax
testq %r15, %r15
je 0x2081a
movss 0x4(%r15), %xmm0
ucomiss %xmm2, %xmm0
ja 0x2081a
movslq (%r15), %rax
imulq $0x70, %rax, %rax
addq %rbx, %rax
cmpq %r14, %rax
je 0x20805
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm3
subsd (%rax), %xmm1
mulsd %xmm1, %xmm1
subsd 0x8(%rax), %xmm3
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd 0x10(%r14), %xmm1
subsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
movl $0x4, %r13d
ucomiss %xmm2, %xmm1
jae 0x207ff
movaps %xmm1, %xmm3
maxss %xmm0, %xmm3
xorl %r13d, %r13d
ucomiss %xmm3, %xmm4
jbe 0x207ff
movl 0x64(%rax), %edi
movl %ebp, %esi
movl %r12d, %edx
movss %xmm3, 0x14(%rsp)
callq 0x19128
movss 0x14(%rsp), %xmm1
movss 0xc(%rsp), %xmm4
movss 0x10(%rsp), %xmm2
movq 0x20(%rsp), %rcx
testl %eax, %eax
je 0x207f5
movss 0x8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
movq 0x18(%rsp), %rcx
jbe 0x207ff
movss %xmm1, (%rcx)
movl $0x1, %r13d
testb $0x3, %r13b
jne 0x2080c
movq 0x8(%r15), %r15
xorl %r13d, %r13d
testl %r13d, %r13d
je 0x20739
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/screened_interactions.c
// Function: Shadow_cosine
int Shadow_cosine(float *c_nb, float *c_bo, float S2_NB, float S2_BO,
		   struct store *store1, float d2_ij,
		   atom *atom_i, atom *atom_j, atom *atoms)
{
  int resi=atom_i->res, resj=atom_j->res;
  float cos2_a, d2_jk;
  while(store1 != NULL){
    if(store1->x > d2_ij)break; // store1->x= d2_ik
    atom *atom_k=atoms+store1->i;
    if(atom_k!=atom_j){
      d2_jk=Dist2(atom_j->r, atom_k->r);
      if(d2_jk >= d2_ij)goto next;
      if(d2_jk > store1->x){
	cos2_a=Scalar(atom_j->r, atom_i->r, atom_k->r);
	cos2_a=(cos2_a*cos2_a)/(d2_ij*d2_jk); 
      }else{
	cos2_a=Scalar(atom_i->r, atom_j->r, atom_k->r);
	cos2_a=(cos2_a*cos2_a)/(d2_ij*store1->x);
      }
      if(cos2_a > S2_NB){
	int bond=Bond(atom_k->res, resi, store1->x, resj, d2_jk);
	if(bond){
	  if(cos2_a > S2_BO){*c_bo=cos2_a; return(1);}
	}else{
	  if(cos2_a > S2_NB){*c_nb=cos2_a; return(1);}
	}
      }
    }
  next:
    store1=store1->next;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movss %xmm1, 0x14(%rsp)
movaps %xmm0, %xmm6
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %ebp
movl 0x64(%r8), %r15d
movss %xmm2, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
testq %r13, %r13
je 0x209b8
movss 0x4(%r13), %xmm0
ucomiss %xmm2, %xmm0
ja 0x209b8
movslq (%r13), %rax
imulq $0x70, %rax, %rax
addq %rbx, %rax
cmpq %r14, %rax
je 0x20989
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm3
subsd (%rax), %xmm1
subsd 0x8(%rax), %xmm3
mulsd %xmm1, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd 0x10(%r14), %xmm1
subsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
ucomiss %xmm2, %xmm1
jae 0x20989
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
jbe 0x2090b
movsd (%r14,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r12,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x208e0
movaps %xmm1, %xmm3
jmp 0x20934
movsd (%r12,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r14,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x2090b
movaps %xmm0, %xmm3
xorps %xmm4, %xmm4
cvtsd2ss %xmm5, %xmm4
mulss %xmm4, %xmm4
mulss %xmm2, %xmm3
divss %xmm3, %xmm4
ucomiss %xmm6, %xmm4
jbe 0x20989
movss %xmm4, 0x10(%rsp)
movl 0x64(%rax), %edi
movl %ebp, %esi
movl %r15d, %edx
callq 0x19128
testl %eax, %eax
je 0x20999
movss 0x10(%rsp), %xmm0
ucomiss 0x14(%rsp), %xmm0
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm6
jbe 0x20989
movq 0x18(%rsp), %rax
movss %xmm0, (%rax)
xorl %eax, %eax
jmp 0x2098f
movq 0x8(%r13), %r13
movb $0x1, %al
testb %al, %al
jne 0x20869
jmp 0x209bc
movq 0x20(%rsp), %rax
movss 0x10(%rsp), %xmm0
movss %xmm0, (%rax)
xorl %eax, %eax
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm6
jmp 0x2098f
xorl %eax, %eax
jmp 0x209c1
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/screened_interactions.c
// Function: Axis_distance
int Axis_distance(float *d2_nb, float *d2_bo, float S2_NB, float S2_BO,
		  struct store *store1, float d2_ij,
		  atom *atom_i, atom *atom_j, atom *atoms)
{
  int resi=atom_i->res, resj=atom_j->res;
  float d2, d2_jk, d2_c;
  while(store1 != NULL){
    if(store1->x > d2_ij)break;
    atom *atom_k=atoms+store1->i;
    if(atom_k!=atom_j){
      d2_jk=Dist2(atom_j->r, atom_k->r);
      if(d2_jk >= d2_ij)goto next1;
      if(d2_jk > store1->x){
	d2_c=Scalar(atom_j->r, atom_i->r, atom_k->r);
	d2=d2_jk-d2_c*d2_c/d2_ij; 
      }else{
	d2_c=Scalar(atom_i->r, atom_j->r, atom_k->r);
	d2=store1->x-d2_c*d2_c/d2_ij;
      }
      if(d2 < S2_NB){
	int bond=Bond(atom_k->res, resi, store1->x, resj, d2_jk);
	if(bond){
	  if(d2 < S2_BO){*d2_bo=d2; return(1);}
	}else{
	  if(d2 < S2_NB){*d2_nb=d2; return(1);}
	}
      }
    }
  next1:
    store1=store1->next;
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movss %xmm1, 0x14(%rsp)
movaps %xmm0, %xmm6
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x64(%rcx), %ebp
movl 0x64(%r8), %r15d
movss %xmm2, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
testq %r13, %r13
je 0x20b63
movss 0x4(%r13), %xmm0
ucomiss %xmm2, %xmm0
ja 0x20b63
movslq (%r13), %rax
imulq $0x70, %rax, %rax
addq %rbx, %rax
cmpq %r14, %rax
je 0x20b34
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm3
subsd (%rax), %xmm1
subsd 0x8(%rax), %xmm3
mulsd %xmm1, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd 0x10(%r14), %xmm1
subsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
ucomiss %xmm2, %xmm1
jae 0x20b34
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
jbe 0x20ab2
movsd (%r14,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r12,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x20a87
movaps %xmm1, %xmm4
jmp 0x20adb
movsd (%r12,%rcx,8), %xmm3
movapd %xmm3, %xmm4
subsd (%r14,%rcx,8), %xmm4
subsd (%rax,%rcx,8), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm5
incq %rcx
cmpq $0x3, %rcx
jne 0x20ab2
movaps %xmm0, %xmm4
xorps %xmm3, %xmm3
cvtsd2ss %xmm5, %xmm3
mulss %xmm3, %xmm3
divss %xmm2, %xmm3
subss %xmm3, %xmm4
ucomiss %xmm4, %xmm6
jbe 0x20b34
movss %xmm4, 0x10(%rsp)
movl 0x64(%rax), %edi
movl %ebp, %esi
movl %r15d, %edx
callq 0x19128
testl %eax, %eax
je 0x20b44
movss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
ucomiss %xmm1, %xmm0
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm6
jbe 0x20b34
movq 0x18(%rsp), %rax
movss %xmm1, (%rax)
xorl %eax, %eax
jmp 0x20b3a
movq 0x8(%r13), %r13
movb $0x1, %al
testb %al, %al
jne 0x20a10
jmp 0x20b67
movq 0x20(%rsp), %rax
movss 0x10(%rsp), %xmm0
movss %xmm0, (%rax)
xorl %eax, %eax
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm6
jmp 0x20b3a
xorl %eax, %eax
jmp 0x20b6c
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq