LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/initchn.c
// Function: InitChain
void InitChain(CHAIN **Chain)
{
  
  *Chain = (CHAIN *)ckalloc(sizeof(CHAIN));

  (*Chain)->NRes                = 0;
  (*Chain)->NHetRes             = 0;
  (*Chain)->NonStandRes         = 0;
  (*Chain)->NHet                = 0;
  (*Chain)->NonStandAtom        = 0;
  (*Chain)->NHelix              = 0;
  (*Chain)->NSheet              = -1;
  (*Chain)->NTurn               = 0;
  (*Chain)->NAssignedTurn       = 0;
  (*Chain)->NBond               = 0;
  (*Chain)->NHydrBond           = 0;
  (*Chain)->NHydrBondTotal      = 0;
  (*Chain)->NHydrBondInterchain = 0;
  (*Chain)->Method              = XRay;
  (*Chain)->Ter                 = 0;
  (*Chain)->Resolution          = 0.0;

  (*Chain)->File                = (char           *)ckalloc(BUFSZ*sizeof(char));
  (*Chain)->Rsd                 = (RESIDUE       **)ckalloc(MAX_RES*sizeof(RESIDUE *));
  (*Chain)->HetRsd              = (HETERORESIDUE **)ckalloc(MAX_HETRES*sizeof(HETERORESIDUE *));
  (*Chain)->Het                 = (HET           **)ckalloc(MAX_HET*sizeof(HET *));
  (*Chain)->Helix               = (HELIX         **)ckalloc(MAX_HELIX*sizeof(HELIX *));
  (*Chain)->Sheet               = (SHEET         **)ckalloc(MAX_SHEET*sizeof(SHEET *));
  (*Chain)->Turn                = (TURN          **)ckalloc(MAX_TURN*sizeof(TURN *));
  (*Chain)->AssignedTurn        = (TURN          **)ckalloc(MAX_TURN*sizeof(TURN *));
  (*Chain)->SSbond              = (SSBOND        **)ckalloc(MAX_BOND*sizeof(SSBOND *));
  (*Chain)->Info                = (char          **)ckalloc(MAX_INFO*sizeof(char *));

  (*Chain)->Valid               = YES;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xb8, %edi
callq 0x50f4
movq %rax, (%rbx)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
orl $-0x1, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x50(%rax)
movups %xmm0, 0x24(%rax)
andq $0x0, 0x34(%rax)
movl $0x400, %edi            # imm = 0x400
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x48(%rcx)
movl $0x27100, %edi          # imm = 0x27100
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x68(%rcx)
movl $0x27100, %edi          # imm = 0x27100
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x70(%rcx)
movl $0x640, %edi            # imm = 0x640
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x78(%rcx)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x80(%rcx)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x88(%rcx)
movl $0x960, %edi            # imm = 0x960
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x90(%rcx)
movl $0x960, %edi            # imm = 0x960
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0x98(%rcx)
movl $0x320, %edi            # imm = 0x320
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0xa0(%rcx)
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x50f4
movq (%rbx), %rcx
movq %rax, 0xa8(%rcx)
movq (%rbx), %rax
movl $0x1, 0x58(%rax)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/geometry.c
// Function: Dist
float Dist(float *Coord1, float *Coord2)
{
  register int i;
  float Dist=0;

  for( i=0; i<3; i++ ) 
    Dist += (Coord1[i]-Coord2[i])*(Coord1[i]-Coord2[i]);

  return( sqrt(Dist) );
}

// Assembly:
xorps %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x3, %rax
je 0x3ade
movss (%rdi,%rax,4), %xmm1
subss (%rsi,%rax,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rax
jmp 0x3ac1
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2170
sqrtss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/geometry.c
// Function: Ang
float Ang(float *Coord1, float *Coord2, float *Coord3)
{
  float Vector1[3], Vector2[3];
  double A, B, C, D;

  Vector1[0] = Coord1[0] - Coord2[0];
  Vector1[1] = Coord1[1] - Coord2[1];
  Vector1[2] = Coord1[2] - Coord2[2];

  Vector2[0] = Coord3[0] - Coord2[0];
  Vector2[1] = Coord3[1] - Coord2[1];
  Vector2[2] = Coord3[2] - Coord2[2];

  A = Vector1[0]*Vector2[0]+Vector1[1]*Vector2[1]+Vector1[2]*Vector2[2];
  B = sqrt( Vector1[0]*Vector1[0]+Vector1[1]*Vector1[1]+Vector1[2]*Vector1[2]);
  C = sqrt( Vector2[0]*Vector2[0]+Vector2[1]*Vector2[1]+Vector2[2]*Vector2[2]);

  D = A/(B*C);
  if( D > 0.0 && fabs(D - 1.0) < Eps ) 
    D -= Eps;
  else
  if( D < 0.0 && fabs(D + 1.0) < Eps ) 
    D += Eps;
  
  return((float)(RADDEG*acos(D)));
}

// Assembly:
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm2
movss 0x8(%rdx), %xmm4
movss (%rdi), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movss 0x4(%rdi), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movss 0x8(%rdi), %xmm2
unpcklps %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm4
movss 0x8(%rsi), %xmm5
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
subps %xmm0, %xmm1
shufps $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
subps %xmm4, %xmm3
shufps $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
subps %xmm5, %xmm2
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
mulss %xmm3, %xmm0
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
mulss %xmm1, %xmm4
addss %xmm0, %xmm4
movaps %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm0     # xmm0 = xmm0[1,1],xmm2[1,1]
mulss %xmm2, %xmm0
addss %xmm4, %xmm0
cvtss2sd %xmm0, %xmm0
mulps %xmm3, %xmm3
mulps %xmm1, %xmm1
addps %xmm3, %xmm1
mulps %xmm2, %xmm2
addps %xmm1, %xmm2
cvtps2pd %xmm2, %xmm1
sqrtpd %xmm1, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3bc0
movsd 0x14cbc(%rip), %xmm2    # 0x18858
addsd %xmm0, %xmm2
andpd 0x14d18(%rip), %xmm2    # 0x188c0
movsd 0x14cb0(%rip), %xmm3    # 0x18860
ucomisd %xmm2, %xmm3
jbe 0x3bc0
addsd 0x14cb2(%rip), %xmm0    # 0x18870
jmp 0x3bf0
ucomisd %xmm0, %xmm1
jbe 0x3bf0
movsd 0x14c9a(%rip), %xmm1    # 0x18868
addsd %xmm0, %xmm1
andpd 0x14ce6(%rip), %xmm1    # 0x188c0
movsd 0x14c7e(%rip), %xmm2    # 0x18860
ucomisd %xmm1, %xmm2
jbe 0x3bf0
addsd 0x14c70(%rip), %xmm0    # 0x18860
pushq %rax
callq 0x2120
mulsd 0x14c7a(%rip), %xmm0    # 0x18878
cvtsd2ss %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/geometry.c
// Function: PHI
void PHI(CHAIN *Chain, int Res)
{

  int C_Prev, N_Curr, CA_Curr, C_Curr;
  RESIDUE *r, *rr;

  r = Chain->Rsd[Res];
  r->Prop->Phi = 360.0;

  if( Res == 0 )
    return;

  rr = Chain->Rsd[Res-1];

  if( FindAtom(Chain,Res-1,"C",&C_Prev) && FindAtom(Chain,Res,"N",&N_Curr)   &&
      FindAtom(Chain,Res,"CA",&CA_Curr) && FindAtom(Chain,Res,"C",&C_Curr)   &&
      Dist(rr->Coord[C_Prev],r->Coord[N_Curr]) < BREAKDIST ) {
    r->Prop->Phi = Torsion(rr->Coord[C_Prev],r->Coord[N_Curr],
			   r->Coord[CA_Curr],r->Coord[C_Curr]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r15
movq 0x768(%r15), %rdx
movl $0x43b40000, (%rdx)     # imm = 0x43B40000
testl %ecx, %ecx
je 0x3d34
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rcx), %esi
movq -0x8(%rax,%rcx,8), %r12
leaq 0x15971(%rip), %rdx     # 0x195b4
leaq 0xc(%rsp), %rcx
callq 0x4777
testl %eax, %eax
je 0x3d34
leaq 0x14cc2(%rip), %rdx     # 0x1891e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3d34
leaq 0x1616e(%rip), %rdx     # 0x19de8
leaq 0x14(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3d34
leaq 0x1591c(%rip), %rdx     # 0x195b4
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3d34
movslq 0xc(%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r12,%rax), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x8(%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r15,%rax), %rsi
addq $0x188, %rsi            # imm = 0x188
callq 0x3abc
movss 0x14c1c(%rip), %xmm1    # 0x18900
ucomiss %xmm0, %xmm1
jbe 0x3d34
movl $0x188, %eax            # imm = 0x188
addq %rax, %r12
addq %r15, %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rdi
addq %r12, %rdi
movslq 0x8(%rsp), %rcx
imulq $0xc, %rcx, %rsi
addq %rax, %rsi
movslq 0x14(%rsp), %rcx
imulq $0xc, %rcx, %rdx
addq %rax, %rdx
movslq 0x10(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rax, %rcx
callq 0x3894
movq 0x768(%r15), %rax
movss %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/geometry.c
// Function: PSI
void PSI(CHAIN *Chain, int Res)
{

  int N_Curr, CA_Curr, C_Curr, N_Next;
  RESIDUE *r, *rr;

  r = Chain->Rsd[Res];
  r->Prop->Psi = 360.0;

  if( Res == Chain->NRes-1 )
    return;

  rr = Chain->Rsd[Res+1];

  if( FindAtom(Chain,Res,"N",&N_Curr) && FindAtom(Chain,Res,"CA",&CA_Curr) &&
      FindAtom(Chain,Res,"C",&C_Curr) && FindAtom(Chain,Res+1,"N",&N_Next) &&
      Dist(r->Coord[C_Curr],rr->Coord[N_Next]) < BREAKDIST ){

    r->Prop->Psi = Torsion(r->Coord[N_Curr],r->Coord[CA_Curr],
			   r->Coord[C_Curr],rr->Coord[N_Next]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r15
movq 0x768(%r15), %rdx
movl $0x43b40000, 0x4(%rdx)  # imm = 0x43B40000
movl (%rdi), %edx
decl %edx
cmpl %ecx, %edx
je 0x3e76
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rax,%rcx,8), %r12
leaq 0x14b9d(%rip), %rdx     # 0x1891e
leaq 0x14(%rsp), %rcx
callq 0x4777
testl %eax, %eax
je 0x3e76
leaq 0x1604e(%rip), %rdx     # 0x19de8
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3e76
leaq 0x157fc(%rip), %rdx     # 0x195b4
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3e76
incl %ebx
leaq 0x14b46(%rip), %rdx     # 0x1891e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3e76
movslq 0xc(%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r15,%rax), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x8(%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r12,%rax), %rsi
addq $0x188, %rsi            # imm = 0x188
callq 0x3abc
movss 0x14adc(%rip), %xmm1    # 0x18900
ucomiss %xmm0, %xmm1
jbe 0x3e76
movl $0x188, %eax            # imm = 0x188
leaq (%r15,%rax), %rcx
addq %rax, %r12
movslq 0x14(%rsp), %rax
imulq $0xc, %rax, %rdi
addq %rcx, %rdi
movslq 0x10(%rsp), %rax
imulq $0xc, %rax, %rsi
addq %rcx, %rsi
movslq 0xc(%rsp), %rax
imulq $0xc, %rax, %rdx
addq %rcx, %rdx
movslq 0x8(%rsp), %rax
imulq $0xc, %rax, %rcx
addq %r12, %rcx
callq 0x3894
movq 0x768(%r15), %rax
movss %xmm0, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/geometry.c
// Function: OMEGA
void OMEGA(CHAIN *Chain, int Res)
{

  int CA_Prev, C_Prev, N_Curr, CA_Curr;
  RESIDUE *r, *rr;

  
  r = Chain->Rsd[Res];
  r->Prop->Omega = 360.0;

  if( Res == 0 )
    return;

  rr = Chain->Rsd[Res-1];

  if( FindAtom(Chain,Res-1,"CA",&CA_Prev) && FindAtom(Chain,Res-1,"C",&C_Prev)   &&
      FindAtom(Chain,Res,"N",&N_Curr)     && FindAtom(Chain,Res,"CA",&CA_Curr) ) {

    r->Prop->Omega = Torsion(rr->Coord[CA_Prev],rr->Coord[C_Prev],
			     r->Coord[N_Curr],r->Coord[CA_Curr]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r15
movq 0x768(%r15), %rdx
movl $0x43b40000, 0x8(%rdx)  # imm = 0x43B40000
testl %ecx, %ecx
je 0x3f87
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rcx), %ebp
movq -0x8(%rax,%rcx,8), %r12
leaq 0x15f25(%rip), %rdx     # 0x19de8
leaq 0xc(%rsp), %rcx
movl %ebp, %esi
callq 0x4777
testl %eax, %eax
je 0x3f87
leaq 0x156d6(%rip), %rdx     # 0x195b4
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x4777
testl %eax, %eax
je 0x3f87
leaq 0x14a22(%rip), %rdx     # 0x1891e
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3f87
leaq 0x15ed2(%rip), %rdx     # 0x19de8
movq %rsp, %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4777
testl %eax, %eax
je 0x3f87
movslq 0xc(%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r12,%rax), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x8(%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r12,%rax), %rsi
addq $0x188, %rsi            # imm = 0x188
movslq 0x4(%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r15,%rax), %rdx
addq $0x188, %rdx            # imm = 0x188
movslq (%rsp), %rax
imulq $0xc, %rax, %rax
leaq (%r15,%rax), %rcx
addq $0x188, %rcx            # imm = 0x188
callq 0x3894
movq 0x768(%r15), %rax
movss %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/geometry.c
// Function: Place123_X
void Place123_X(float *Coord1, float *Coord2, float *Coord3, float Dist3X, float Ang23X, 
	       float *CoordX)
{

/*

   Atom1
     \                     AtomX
      \ ^UnVect2            /
       \|                  /
       Atom2----------Atom3->UnVect1

*/

  float Length_23, Length_12;
  float Proj3X_1, Proj3X_2, Proj12_1, Proj12_2, Rad1, Rad2;
  float UnVect1[3], UnVect2[3];
  int i;

  Length_23 = Dist(Coord3,Coord2);
  Length_12 = Dist(Coord2,Coord1);
  Rad1 = RAD(180.0-Ang23X);
  Rad2 = RAD(Ang(Coord1,Coord2,Coord3)-90.0); 
  Proj3X_1 = Dist3X*cos(Rad1);
  Proj3X_2 = Dist3X*sin(Rad1);
  Proj12_2 = cos(Rad2)*Length_12;
  Proj12_1 = sin(Rad2)*Length_12;

  for( i=0; i<3; i++ ) {
    UnVect1[i] = (Coord3[i]-Coord2[i])/Length_23;
    UnVect2[i] = ((Coord1[i]-Coord2[i]) - ( -UnVect1[i]*Proj12_1))/Proj12_2;
  }

  for( i=0; i<3; i++ ) 
    CoordX[i] = Proj3X_1*UnVect1[i]+Proj3X_2*UnVect2[i]+Coord3[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movss %xmm1, 0x8(%rsp)
movss %xmm0, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x3abc
movss %xmm0, 0x2c(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3abc
movss %xmm0, 0x20(%rsp)
cvtss2sd 0x8(%rsp), %xmm0
movsd 0x1489d(%rip), %xmm2    # 0x18880
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
mulsd 0x14895(%rip), %xmm1    # 0x18888
divsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3aef
cvtss2sd %xmm0, %xmm0
addsd 0x14875(%rip), %xmm0    # 0x18890
mulsd 0x14865(%rip), %xmm0    # 0x18888
divsd 0x14855(%rip), %xmm0    # 0x18880
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
cvtss2sd (%rsp), %xmm0
movsd %xmm0, (%rsp)
cvtss2sd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x2100
mulsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x21e0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
cvtss2sd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x2100
cvtss2sd 0x20(%rsp), %xmm1
movsd %xmm1, 0x20(%rsp)
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x21e0
movss 0x10(%rsp), %xmm5
movss 0x2c(%rsp), %xmm4
mulsd 0x20(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x3, %rax
je 0x40ff
movss (%r14,%rax,4), %xmm1
movss (%r15,%rax,4), %xmm2
subss %xmm2, %xmm1
divss %xmm4, %xmm1
movss %xmm1, 0x3c(%rsp,%rax,4)
movss (%r12,%rax,4), %xmm3
subss %xmm2, %xmm3
mulss %xmm0, %xmm1
addss %xmm3, %xmm1
divss %xmm5, %xmm1
movss %xmm1, 0x30(%rsp,%rax,4)
incq %rax
jmp 0x40be
cvtsd2ss 0x8(%rsp), %xmm0
cvtsd2ss (%rsp), %xmm1
xorl %eax, %eax
cmpq $0x3, %rax
je 0x413a
movss 0x30(%rsp,%rax,4), %xmm2
mulss %xmm1, %xmm2
movss 0x3c(%rsp,%rax,4), %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
addss (%r14,%rax,4), %xmm3
movss %xmm3, (%rbx,%rax,4)
incq %rax
jmp 0x410c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/geometry.c
// Function: VectorProduct
float VectorProduct(float *Vector1, float *Vector2, float *Product)
{

  int i, j, k;
  float ProductLength;

  ProductLength = 0.0; 

  for( i=0; i<3; i++ ) {
    j = (i+1)%3;
    k = (j+1)%3;
    Product[i] = Vector1[j]*Vector2[k] - Vector1[k]*Vector2[j];
    ProductLength += Product[i]*Product[i];
  }

  return(sqrt(ProductLength));
}

// Assembly:
xorps %xmm0, %xmm0
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x41a3
leaq 0x1(%rcx), %r8
cmpq $0x2, %rcx
movl %r8d, %r9d
cmovel %eax, %r9d
leal 0x1(%r9), %r10d
leal -0x2(%r9), %r11d
cmpl $0x3, %r10d
cmovbl %r10d, %r11d
movl %r9d, %r9d
movss (%rsi,%r9,4), %xmm1
mulss (%rdi,%r11,4), %xmm1
movss (%rdi,%r9,4), %xmm2
mulss (%rsi,%r11,4), %xmm2
subss %xmm1, %xmm2
movss %xmm2, (%rdx,%rcx,4)
mulss %xmm2, %xmm2
addss %xmm2, %xmm0
movq %r8, %rcx
jmp 0x414d
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2170
sqrtss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/filename.c
// Function: StripPathFromLastExtention
void StripPathFromLastExtention(char *Path, char *StrippedPath)
{
  int i;

  strcpy(StrippedPath,Path);

  for( i = (int)strlen(StrippedPath); i>=0; i-- )
    if( StrippedPath[i] == '.' ) {
      StrippedPath[i] = '\0';
      break;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
js 0x46c3
movl %eax, %ecx
decl %eax
cmpb $0x2e, (%rbx,%rcx)
jne 0x46b1
movb $0x0, (%rbx,%rcx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/tolostr.c
// Function: tolostr
char *tolostr(char *InputString)
{
  register int i;
  int Length;
  static char OutputString[BUFSZ];

  strcpy(OutputString,InputString);

  Length = (int)strlen(OutputString);

  for( i=0; i<Length; i++ )
    OutputString[i] = tolower(OutputString[i]);
  return(OutputString);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
leaq 0x1c8e9(%rip), %rbx     # 0x20fc0
movq %rbx, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x20b0
movq %rax, %r14
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x4712
callq 0x2290
movq (%rax), %rax
movsbq (%r15,%rbx), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%r15,%rbx)
incq %r15
jmp 0x46f4
leaq 0x1c8a7(%rip), %rax     # 0x20fc0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/strutil.c
// Function: PdbN2SeqN
int PdbN2SeqN(CHAIN *Chain, char *PdbN, int *SeqN)
{

  for( (*SeqN)=0; (*SeqN)<Chain->NRes; (*SeqN)++ )
    if( !strcmp(Chain->Rsd[(*SeqN)]->PDB_ResNumb,PdbN) ) 
      return(SUCCESS);

  return(FAILURE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
pushq $0x1
popq %rbp
xorl %r13d, %r13d
movl %r13d, (%r14)
movslq (%r12), %rax
cmpq %rax, %r13
jge 0x4766
movq 0x68(%r12), %rax
movq (%rax,%r13,8), %rdi
addq $0x4, %rdi
movq %r15, %rsi
callq 0x2150
incq %r13
testl %eax, %eax
jne 0x473c
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/strutil.c
// Function: FindAtom
int FindAtom(CHAIN *Chain, int ResNumb, char *Atom, int *AtNumb)
{

  for( (*AtNumb)=0; (*AtNumb)<Chain->Rsd[ResNumb]->NAtom; (*AtNumb)++ )
    if( !strcmp(Atom,Chain->Rsd[ResNumb]->AtomType[(*AtNumb)]) )
       return(SUCCESS);

  *AtNumb = ERR;
  return(FAILURE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r12
leaq 0x10(%r12), %r15
xorl %r13d, %r13d
pushq $0x1
popq %rbp
movl %r13d, (%rbx)
movslq (%r12), %rax
cmpq %rax, %r13
jge 0x47c2
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
incq %r13
addq $0x5, %r15
testl %eax, %eax
jne 0x479e
jmp 0x47c7
orl $-0x1, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/strutil.c
// Function: Boundaries
int Boundaries(char *Asn, int L, char SecondStr, int (*Bound)[2])
{
  register int Res;
  int NStr = 0, Flag = 0;
  
  for( Res=0; Res<L; Res++ ) {
    if( Asn[Res] == SecondStr && Flag == 0 ) {
      Flag = 1; 
      Bound[NStr][0] = Res;
    }
    else
    if( Asn[Res] != SecondStr && Flag == 1 ) {
      Flag = 0; 
      Bound[NStr++][1] = Res-1;
    }
  }
  return(NStr);
}

// Assembly:
pushq %rbp
pushq %rbx
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
movl $0x1, %r9d
xorl %eax, %eax
xorl %r10d, %r10d
cmpq %r8, %rsi
je 0x4844
movb (%rdi,%r8), %bl
cmpb %dl, %bl
sete %r11b
testl %r10d, %r10d
sete %bpl
andb %r11b, %bpl
movslq %eax, %r11
cmpb $0x1, %bpl
jne 0x4819
movl %r8d, (%rcx,%r11,8)
movl %r9d, %r10d
jmp 0x483f
cmpb %dl, %bl
setne %bl
cmpl $0x1, %r10d
sete %bpl
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x483f
leal 0x1(%r11), %eax
leal -0x1(%r8), %r10d
movl %r10d, 0x4(%rcx,%r11,8)
xorl %r10d, %r10d
incq %r8
jmp 0x47ee
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/strutil.c
// Function: FindChain
int FindChain(CHAIN **Chain, int NChain, char ChainId)
{
  register int i;

  for( i=0; i<NChain; i++ )
    if( Chain[i]->Id == ChainId )
      return(i);

  return(ERR);
}

// Assembly:
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
pushq $-0x1
popq %rax
cmpq %rcx, %rsi
je 0x4867
movq (%rdi,%rcx,8), %r8
cmpb %dl, 0x40(%r8)
je 0x4865
incq %rcx
jmp 0x4851
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/strutil.c
// Function: ChInStr
BOOLEAN ChInStr(char *String, char Char)
{

  if( strchr(String,toupper(Char)) || 
      strchr(String,Char) ||
      strchr(String,tolower(Char)) )
    return(YES);
  
  return(NO);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x2030
movq (%rax), %rax
movslq %r14d, %r15
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x20c0
pushq $0x1
popq %rbp
testq %rax, %rax
jne 0x49ce
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0x20c0
testq %rax, %rax
jne 0x49ce
callq 0x2290
movq (%rax), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x20c0
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/strutil.c
// Function: ExistsSecStr
BOOLEAN ExistsSecStr(CHAIN **Chain, int NChain)
{
  register int i, Cn;
  
  for( Cn=0; Cn<NChain; Cn++ )
    for( i=0; i<Chain[Cn]->NRes; i++ )
      if( Chain[Cn]->Rsd[i]->Prop->Asn != 'C' )
	return(YES);

  return(NO);
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
pushq $0x1
popq %rcx
xorl %edx, %edx
cmpq %rsi, %rdx
je 0x4aae
movq (%rdi,%rdx,8), %r8
movl (%r8), %r9d
testl %r9d, %r9d
cmovlel %eax, %r9d
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x4aa7
movq 0x68(%r8), %r11
movq (%r11,%r10,8), %r11
movq 0x768(%r11), %r11
incq %r10
cmpb $0x43, 0x1c(%r11)
je 0x4a87
jmp 0x4aac
incq %rdx
jmp 0x4a71
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/strutil.c
// Function: SecStrContent
float SecStrContent(CHAIN *Chain, int *HelAlp, int *HelPI, int *Hel310, int *Sheet, int *Turn)
{

  int Res;
  float Content = 0.0;

  *HelAlp = 0; *HelPI = 0; *Hel310 = 0; *Sheet = 0; *Turn = 0;
  
  for( Res=0; Res<Chain->NRes; Res++ ) {
    switch( Chain->Rsd[Res]->Prop->PdbAsn ) {
    case 'H' : (*HelAlp)++;
               break;
    case 'G' : (*Hel310)++;
               break;
    case 'I' : (*HelPI)++;
               break;
    case 'E' : (*Sheet)++;
               break;
    case 'T' : (*Turn)++;
               break;
    }
  }

  Content = ( (float)( (*HelAlp)+(*HelPI)+(*Hel310)+(*Sheet)+(*Turn) ) )/(float)Chain->NRes;

  return(Content);
}

// Assembly:
pushq %rbx
andl $0x0, (%rsi)
andl $0x0, (%rdx)
andl $0x0, (%rcx)
andl $0x0, (%r8)
andl $0x0, (%r9)
xorl %eax, %eax
leaq 0x13f92(%rip), %r10     # 0x18a5c
movslq (%rdi), %r11
cmpq %r11, %rax
jge 0x4b1b
movq 0x68(%rdi), %r11
movq (%r11,%rax,8), %r11
movq 0x768(%r11), %r11
movzbl 0x1d(%r11), %r11d
leal -0x45(%r11), %ebx
cmpl $0x4, %ebx
ja 0x4b00
movslq (%r10,%rbx,4), %rbx
addq %r10, %rbx
movq %rsi, %r11
jmpq *%rbx
movq %r8, %r11
jmp 0x4b13
cmpl $0x54, %r11d
jne 0x4b16
movq %r9, %r11
jmp 0x4b13
movq %rcx, %r11
jmp 0x4b13
movq %rdx, %r11
incl (%r11)
incq %rax
jmp 0x4aca
movl (%rdx), %eax
addl (%rsi), %eax
addl (%rcx), %eax
addl (%r8), %eax
addl (%r9), %eax
cvtsi2ss %eax, %xmm0
cvtsi2ss %r11d, %xmm1
divss %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/memory.c
// Function: FloatCube
float ***FloatCube(int M, int N, int K)
{
  int m, n, k;
  float ***Cube;

  Cube = (float ***)ckalloc(M*sizeof(float **));

  for( m=0; m<M; m++ ) {
    Cube[m] = (float **)ckalloc(N*sizeof(float *));
    for( n=0; n<N; n++ )
      Cube[m][n] = (float *)ckalloc(K*sizeof(float));
  }

  for( m=0; m<M; m++ )
    for( n=0; n<N; n++ )
      for( k=0; k<K; k++ )
	Cube[m][n][k] = 0.0;

  return(Cube);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %r14d
movslq %edi, %r13
leaq (,%r13,8), %rdi
callq 0x50f4
movslq %r14d, %r15
leaq (,%r15,8), %rcx
movq %rcx, (%rsp)
movslq %ebx, %r12
shlq $0x2, %r12
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
movq %rax, %r14
testl %r13d, %r13d
cmovlel %ebp, %r13d
movq %r13, 0x8(%rsp)
cmpq %r13, %rbp
je 0x51f8
movq (%rsp), %rdi
callq 0x50f4
movq %rax, %r13
movq %rbp, 0x10(%rsp)
movq %rax, (%r14,%rbp,8)
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x51e9
movq %r12, %rdi
callq 0x50f4
movq %rax, (%r13,%rbp,8)
incq %rbp
jmp 0x51d2
movq 0x10(%rsp), %rbp
incq %rbp
movq 0x8(%rsp), %r13
jmp 0x51b6
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %r13, %rax
je 0x522d
xorl %ecx, %ecx
cmpq %r15, %rcx
je 0x5228
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x5223
movq (%r14,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
andl $0x0, (%rsi,%rdx,4)
incq %rdx
jmp 0x520d
incq %rcx
jmp 0x5206
incq %rax
jmp 0x51ff
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/memory.c
// Function: Float4Dim
float ****Float4Dim(int M, int N, int K, int L)
{
  int m, n, k, l;
  float ****FourDim;

  FourDim = (float ****)ckalloc(M*sizeof(float ***));


  for( m=0; m<M; m++ ) {
    FourDim[m] = (float ***)ckalloc(N*sizeof(float **));
    for( n=0; n<N; n++ ) {
      FourDim[m][n] = (float **)ckalloc(K*sizeof(float*));
      for( k=0; k<K; k++ )
	FourDim[m][n][k] = (float *)ckalloc(L*sizeof(float));
    }
  }

  for( m=0; m<M; m++ )
    for( n=0; n<N; n++ )
      for( k=0; k<K; k++ )
	for( l=0; l<L; l++ )
	  FourDim[m][n][k][l] = 0.0;

  return(FourDim);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movslq %edi, %r12
leaq (,%r12,8), %rdi
callq 0x50f4
movslq %r14d, %r8
movslq %ebp, %r15
leaq (,%r15,8), %rcx
movq %rcx, 0x20(%rsp)
movslq %ebx, %rcx
shlq $0x2, %rcx
movq %rcx, 0x30(%rsp)
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
leaq (,%r8,8), %rcx
movq %rcx, 0x8(%rsp)
testl %r8d, %r8d
cmovlel %r13d, %r8d
movq %rax, %r14
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %r12, 0x10(%rsp)
movq %r8, 0x28(%rsp)
cmpq %r12, %r13
je 0x5320
movq 0x8(%rsp), %rdi
callq 0x50f4
movq %rax, %rbp
movq %r13, 0x18(%rsp)
movq %rax, (%r14,%r13,8)
xorl %r13d, %r13d
movq 0x28(%rsp), %r8
cmpq %r8, %r13
je 0x5311
movq 0x20(%rsp), %rdi
callq 0x50f4
movq %rax, (%rbp,%r13,8)
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x530c
movq 0x30(%rsp), %rdi
callq 0x50f4
movq (%rbp,%r13,8), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x52ef
incq %r13
jmp 0x52d3
movq 0x18(%rsp), %r13
incq %r13
movq 0x10(%rsp), %r12
jmp 0x52b5
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %r12, %rax
je 0x5365
xorl %ecx, %ecx
cmpq %r8, %rcx
je 0x5360
xorl %edx, %edx
cmpq %r15, %rdx
je 0x535b
xorl %esi, %esi
cmpq %rsi, %rbx
je 0x5356
movq (%r14,%rax,8), %rdi
movq (%rdi,%rcx,8), %rdi
movq (%rdi,%rdx,8), %rdi
andl $0x0, (%rdi,%rsi,4)
incq %rsi
jmp 0x533c
incq %rdx
jmp 0x5335
incq %rcx
jmp 0x532e
incq %rax
jmp 0x5327
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/memory.c
// Function: IntCube
int ***IntCube(int M, int N, int K)
{
  int m, n, k;
  int ***Cube;

  Cube = (int ***)ckalloc(M*sizeof(int **));

  for( m=0; m<M; m++ ) {
    Cube[m] = (int **)ckalloc(N*sizeof(int *));
    for( n=0; n<N; n++ ) Cube[m][n] = (int *)ckalloc(K*sizeof(int));
  }
  
  for( m=0; m<M; m++ )
    for( n=0; n<N; n++ )
      for( k=0; k<K; k++ )
	Cube[m][n][k] = 0;

  return(Cube);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %r14d
movslq %edi, %r13
leaq (,%r13,8), %rdi
callq 0x50f4
movslq %r14d, %r15
leaq (,%r15,8), %rcx
movq %rcx, (%rsp)
movslq %ebx, %r12
shlq $0x2, %r12
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
movq %rax, %r14
testl %r13d, %r13d
cmovlel %ebp, %r13d
movq %r13, 0x8(%rsp)
cmpq %r13, %rbp
je 0x543e
movq (%rsp), %rdi
callq 0x50f4
movq %rax, %r13
movq %rbp, 0x10(%rsp)
movq %rax, (%r14,%rbp,8)
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x542f
movq %r12, %rdi
callq 0x50f4
movq %rax, (%r13,%rbp,8)
incq %rbp
jmp 0x5418
movq 0x10(%rsp), %rbp
incq %rbp
movq 0x8(%rsp), %r13
jmp 0x53fc
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %r13, %rax
je 0x5473
xorl %ecx, %ecx
cmpq %r15, %rcx
je 0x546e
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x5469
movq (%r14,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
andl $0x0, (%rsi,%rdx,4)
incq %rdx
jmp 0x5453
incq %rcx
jmp 0x544c
incq %rax
jmp 0x5445
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/memory.c
// Function: Int4Dim
int ****Int4Dim(int M, int N, int K, int L)
{
  int m, n, k, l;
  int ****FourDim;

  FourDim = (int ****)ckalloc(M*sizeof(int ***));


  for( m=0; m<M; m++ ) {
    FourDim[m] = (int ***)ckalloc(N*sizeof(int **));
    for( n=0; n<N; n++ ) {
      FourDim[m][n] = (int **)ckalloc(K*sizeof(int*));
      for( k=0; k<K; k++ )
	FourDim[m][n][k] = (int *)ckalloc(L*sizeof(int));
    }
  }

  for( m=0; m<M; m++ )
    for( n=0; n<N; n++ )
      for( k=0; k<K; k++ )
	for( l=0; l<L; l++ )
	  FourDim[m][n][k][l] = 0;

  return(FourDim);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movslq %edi, %r12
leaq (,%r12,8), %rdi
callq 0x50f4
movslq %r14d, %r8
movslq %ebp, %r15
leaq (,%r15,8), %rcx
movq %rcx, 0x20(%rsp)
movslq %ebx, %rcx
shlq $0x2, %rcx
movq %rcx, 0x30(%rsp)
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
leaq (,%r8,8), %rcx
movq %rcx, 0x8(%rsp)
testl %r8d, %r8d
cmovlel %r13d, %r8d
movq %rax, %r14
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %r12, 0x10(%rsp)
movq %r8, 0x28(%rsp)
cmpq %r12, %r13
je 0x55b6
movq 0x8(%rsp), %rdi
callq 0x50f4
movq %rax, %rbp
movq %r13, 0x18(%rsp)
movq %rax, (%r14,%r13,8)
xorl %r13d, %r13d
movq 0x28(%rsp), %r8
cmpq %r8, %r13
je 0x55a7
movq 0x20(%rsp), %rdi
callq 0x50f4
movq %rax, (%rbp,%r13,8)
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x55a2
movq 0x30(%rsp), %rdi
callq 0x50f4
movq (%rbp,%r13,8), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x5585
incq %r13
jmp 0x5569
movq 0x18(%rsp), %r13
incq %r13
movq 0x10(%rsp), %r12
jmp 0x554b
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %r12, %rax
je 0x55fb
xorl %ecx, %ecx
cmpq %r8, %rcx
je 0x55f6
xorl %edx, %edx
cmpq %r15, %rdx
je 0x55f1
xorl %esi, %esi
cmpq %rsi, %rbx
je 0x55ec
movq (%r14,%rax,8), %rdi
movq (%rdi,%rcx,8), %rdi
movq (%rdi,%rdx,8), %rdi
andl $0x0, (%rdi,%rsi,4)
incq %rsi
jmp 0x55d2
incq %rdx
jmp 0x55cb
incq %rcx
jmp 0x55c4
incq %rax
jmp 0x55bd
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/memory.c
// Function: FreeIntCube
void FreeIntCube(int ***Cube, int M, int N)
{
  int m, n;

  for( m=0; m<M; m++ ) {
    for( n=0; n<N; n++ )
      free(Cube[m][n]);
    free(Cube[m]);
  }

  free(Cube);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
movq %rdi, %r15
testl %esi, %esi
cmovlel %r12d, %r14d
cmpq %r14, %r12
je 0x570a
xorl %r13d, %r13d
movq (%r15,%r12,8), %rdi
cmpq %r13, %rbx
je 0x5700
movq (%rdi,%r13,8), %rdi
callq 0x2040
incq %r13
jmp 0x56e9
callq 0x2040
incq %r12
jmp 0x56e1
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/memory.c
// Function: FreeFloatCube
void FreeFloatCube(float ***Cube, int M, int N)
{
  int m, n;

  for( m=0; m<M; m++ ) {
    for( n=0; n<N; n++ )
      free(Cube[m][n]);
    free(Cube[m]);
  }

  free(Cube);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
movq %rdi, %r15
testl %esi, %esi
cmovlel %r12d, %r14d
cmpq %r14, %r12
je 0x5764
xorl %r13d, %r13d
movq (%r15,%r12,8), %rdi
cmpq %r13, %rbx
je 0x575a
movq (%rdi,%r13,8), %rdi
callq 0x2040
incq %r13
jmp 0x5743
callq 0x2040
incq %r12
jmp 0x573b
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2040
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/phipsi.c
// Function: BackboneAngles
void BackboneAngles(CHAIN **Chain, int NChain)
{

  register int Res, Cn;

  for( Cn=0; Cn<NChain; Cn++ ) {

    for( Res=0; Res<Chain[Cn]->NRes; Res++ ) {
      PHI(Chain[Cn],Res);
      PSI(Chain[Cn],Res);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
cmpq %rbx, %r15
je 0x75c3
xorl %ebp, %ebp
movq (%r14,%r15,8), %rdi
cmpl (%rdi), %ebp
jge 0x75be
movl %ebp, %esi
callq 0x3c04
movq (%r14,%r15,8), %rdi
movl %ebp, %esi
callq 0x3d40
incl %ebp
jmp 0x75a0
incq %r15
jmp 0x7599
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/phipsi.c
// Function: DiscrPhiPsi
void DiscrPhiPsi(CHAIN **Chain, int NChain, COMMAND *Cmd)
{

  register int i, Res, Cn;
  RESIDUE *r;

  for( Cn=0; Cn<NChain; Cn++ ) {
    
    for( Res=0; Res<Chain[Cn]->NRes; Res++ ) {
      
      r = Chain[Cn]->Rsd[Res];
      
      r->Prop->PhiZn = ERR;
      r->Prop->PsiZn = ERR;
      
      if( Res != 0 ) {
	for( i=0; i<Cmd->NPixel; i++ )
	  if( r->Prop->Phi  >  MINPHIPSI+(float)(i)*Cmd->PhiPsiStep && 
	      r->Prop->Phi <=  MINPHIPSI+(float)(i+1)*Cmd->PhiPsiStep ) {
	    r->Prop->PhiZn = i;
	    break;
	  }
      }
      
      if( Res != Chain[Cn]->NRes-1 ) {
	for( i=0; i<Cmd->NPixel; i++ )
	  if( r->Prop->Psi  >  MINPHIPSI+(float)(i)*Cmd->PhiPsiStep && 
	      r->Prop->Psi <=  MINPHIPSI+(float)(i+1)*Cmd->PhiPsiStep ) {
	    r->Prop->PsiZn = i;
	    break;
	  }
      }
      
    }
    
    for(Res=0; Res<Chain[Cn]->NRes; Res++ )  {
      r = Chain[Cn]->Rsd[Res];
      if( Res != 0 && r->Prop->PsiZn == ERR )
	r->Prop->PsiZn = Chain[Cn]->Rsd[Res-1]->Prop->PsiZn;
      if( Res != Chain[Cn]->NRes-1 && r->Prop->PhiZn == ERR )
	r->Prop->PhiZn = Chain[Cn]->Rsd[Res+1]->Prop->PhiZn;
    }

  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movsd 0x11773(%rip), %xmm0    # 0x18d58
xorl %ecx, %ecx
cmpq %rsi, %rcx
je 0x7757
movq (%rdi,%rcx,8), %r8
movl (%r8), %r9d
leal -0x1(%r9), %r10d
testl %r9d, %r9d
cmovlel %eax, %r9d
xorl %r11d, %r11d
cmpq %r9, %r11
je 0x76eb
movq 0x68(%r8), %rbx
movq (%rbx,%r11,8), %rbx
movq 0x768(%rbx), %rbx
orq $-0x1, 0xc(%rbx)
testq %r11, %r11
je 0x7682
movl 0x1cf4(%rdx), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
cmpl %r14d, %ebp
je 0x7682
cvtss2sd (%rbx), %xmm1
cvtsi2ss %r14d, %xmm3
movss 0x1d08(%rdx), %xmm2
mulss %xmm2, %xmm3
cvtss2sd %xmm3, %xmm3
addsd %xmm0, %xmm3
leal 0x1(%r14), %r15d
ucomisd %xmm3, %xmm1
jbe 0x7679
cvtsi2ss %r15d, %xmm3
mulss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
jae 0x767e
movl %r15d, %r14d
jmp 0x7636
movl %r14d, 0xc(%rbx)
cmpq %r10, %r11
je 0x76e3
movl 0x1cf4(%rdx), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
cmpl %r14d, %ebp
je 0x76e3
cvtss2sd 0x4(%rbx), %xmm1
cvtsi2ss %r14d, %xmm3
movss 0x1d08(%rdx), %xmm2
mulss %xmm2, %xmm3
cvtss2sd %xmm3, %xmm3
addsd %xmm0, %xmm3
leal 0x1(%r14), %r15d
ucomisd %xmm3, %xmm1
jbe 0x76da
cvtsi2ss %r15d, %xmm3
mulss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
jae 0x76df
movl %r15d, %r14d
jmp 0x7696
movl %r14d, 0x10(%rbx)
incq %r11
jmp 0x7605
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x774f
movq 0x68(%r8), %rbx
movq (%rbx,%r11,8), %r14
testq %r11, %r11
je 0x7724
movq 0x768(%r14), %r15
cmpl $-0x1, 0x10(%r15)
jne 0x7724
movq -0x8(%rbx,%r11,8), %r12
movq 0x768(%r12), %r12
movl 0x10(%r12), %ebp
movl %ebp, 0x10(%r15)
cmpq %r11, %r10
je 0x774a
movq 0x768(%r14), %r14
cmpl $-0x1, 0xc(%r14)
jne 0x774a
movq 0x8(%rbx,%r11,8), %rbx
movq 0x768(%rbx), %rbx
movl 0xc(%rbx), %ebx
movl %ebx, 0xc(%r14)
incq %r11
jmp 0x76ee
incq %rcx
jmp 0x75e7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/command.c
// Function: Uniq
int Uniq(char **List, int ListLength)
{
    int i, j;

    for( i=1; i<ListLength-1; i++ ) {
      if( *List[i] != '-' ) continue;
      for( j=i+1; j<ListLength; j++ ) {
	if( *List[j] != '-' ) continue;
	if( !strcmp(List[i],List[j] ) ) return(0);
      }
    }
    
    return(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq %esi, %r12
decl %esi
movslq %esi, %rax
movq %rax, (%rsp)
pushq $0x1
popq %rbp
pushq $0x2
popq %r13
cmpq (%rsp), %rbp
jge 0x7810
movq (%r14,%rbp,8), %r15
cmpb $0x2d, (%r15)
jne 0x77f7
movq %r13, %rbx
cmpq %r12, %rbx
jge 0x77f7
movq (%r14,%rbx,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x77f2
movq %r15, %rdi
callq 0x2150
testl %eax, %eax
je 0x77ff
incq %rbx
jmp 0x77d8
incq %rbp
incq %r13
jmp 0x77c5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x7801
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/command.c
// Function: Specified
BOOLEAN Specified(char **List, int ListLength, char Option)
{
    int i;

    for( i=1; i<ListLength; i++ )
      if( *List[i] == '-' && *(List[i]+1) == Option ) 
	return(YES);

    return(NO);
}

// Assembly:
movslq %esi, %rcx
pushq $0x1
popq %rsi
pushq $0x1
popq %rax
cmpq %rcx, %rsi
jge 0x7838
movq (%rdi,%rsi,8), %r8
cmpb $0x2d, (%r8)
jne 0x7833
cmpb %dl, 0x1(%r8)
je 0x783a
incq %rsi
jmp 0x781e
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/command.c
// Function: Parse
int Parse(char **List, int ListLength, char *Option)
{
    int i;

    for( i=1; i<ListLength; i++ ) {
      if( *List[i] != '-' ) continue;
      if( !strcmp(List[i],Option) ) return(i);
    }
    
    return(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r15
movslq %esi, %r12
pushq $0x1
popq %rbx
cmpq %r12, %rbx
jge 0x786e
movq (%r15,%rbx,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x7869
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0x7870
incq %rbx
jmp 0x784f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/command.c
// Function: CollectOptions
int CollectOptions(char **List, int ListLength, int Stream, int *Options)
{
    int OptCnt, i;

    OptCnt = 0;

    for( i=1; i<ListLength; i++ )
	if( *List[i] == '-' && !isdigit( *(List[i]+1) ) && atoi( List[i]+2 ) == Stream )
	    Options[OptCnt++] = i;

    return(OptCnt);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rdi, %r14
movslq %esi, %r13
xorl %r15d, %r15d
pushq $0x1
popq %rbx
cmpq %r13, %rbx
jge 0x78e2
movq (%r14,%rbx,8), %r12
cmpb $0x2d, (%r12)
jne 0x78dd
callq 0x22a0
movq (%rax), %rax
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x78dd
addq $0x2, %r12
movq %r12, %rdi
callq 0x2200
cmpl %ebp, %eax
jne 0x78dd
movslq %r15d, %rax
incl %r15d
movq (%rsp), %rcx
movl %ebx, (%rcx,%rax,4)
incq %rbx
jmp 0x789b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/die.c
// Function: die
void die(char *format, ... ) {
void exit(int return_code);
va_list ptr;
va_start(ptr,format);
vfprintf(stderr,format,ptr);
exit(1);
va_end(ptr);
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x7caa
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x1831f(%rip), %rax     # 0x1fff0
movq (%rax), %rdi
movq %r10, %rsi
callq 0x21d0
pushq $0x1
popq %rdi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/hydrbond.c
// Function: PrintHydrBond
void PrintHydrBond(char *Text, HBOND *HBond)
{

  fprintf(stdout,"HB %s %20s %3s %4s %4d %c <> %3s %4s %4d %c ",Text,
	  HBond->Dnr->Chain->File,
	  HBond->Dnr->Chain->Rsd[HBond->Dnr->D_Res]->ResType,
	  HBond->Dnr->Chain->Rsd[HBond->Dnr->D_Res]->PDB_ResNumb,
	  HBond->Dnr->D_Res,HBond->Dnr->Chain->Id,
	  HBond->Acc->Chain->Rsd[HBond->Acc->A_Res]->ResType,
	  HBond->Acc->Chain->Rsd[HBond->Acc->A_Res]->PDB_ResNumb,
	  HBond->Acc->A_Res,HBond->Acc->Chain->Id);

  fprintf(stdout," %7.1f ",HBond->AccDonDist);
  if( HBond->ExistPolarInter ) 
    fprintf(stdout,"%7.1f ",HBond->Energy);
  else
    fprintf(stdout,"XXXXXXX ");

  if( HBond->ExistHydrBondRose ) 
    fprintf(stdout,"YES ");
  else
    fprintf(stdout,"NO ");

  if( HBond->ExistHydrBondBaker ) 
    fprintf(stdout,"YES\n");
  else
    fprintf(stdout,"NO\n");

  

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rdx
movq 0x168c2(%rip), %r14     # 0x1ffd0
movq (%r14), %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
movq (%rax), %r11
movq 0x48(%r11), %rcx
movq 0x68(%r11), %r8
movslq 0x8(%rax), %r10
movq (%r8,%r10,8), %r9
leaq 0xa(%r9), %r8
addq $0x4, %r9
movsbl 0x40(%r11), %r11d
movq (%rsi), %rax
movq 0x68(%rax), %r15
movslq 0x8(%rsi), %r12
movq (%r15,%r12,8), %r15
leaq 0xa(%r15), %r13
addq $0x4, %r15
movsbl 0x40(%rax), %ebp
leaq 0xf8a5(%rip), %rsi      # 0x18fff
xorl %eax, %eax
pushq %rbp
pushq %r12
pushq %r15
pushq %r13
pushq %r11
pushq %r10
callq 0x2160
addq $0x30, %rsp
movq (%r14), %rdi
cvtss2sd 0x38(%rbx), %xmm0
leaq 0xf8ad(%rip), %rsi      # 0x1902c
movb $0x1, %al
callq 0x2160
cmpl $0x0, 0x10(%rbx)
movq (%r14), %rcx
je 0x97a7
cvtss2sd 0x1c(%rbx), %xmm0
leaq 0xf892(%rip), %rsi      # 0x1902d
movq %rcx, %rdi
movb $0x1, %al
callq 0x2160
jmp 0x97b9
leaq 0xf886(%rip), %rdi      # 0x19034
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
cmpl $0x0, 0x14(%rbx)
movq (%r14), %rcx
je 0x97cd
leaq 0xf874(%rip), %rdi      # 0x1903d
pushq $0x4
jmp 0x97d6
leaq 0xf86e(%rip), %rdi      # 0x19042
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
cmpl $0x0, 0x18(%rbx)
movq (%r14), %rcx
je 0x97f3
leaq 0xf857(%rip), %rdi      # 0x19046
pushq $0x4
jmp 0x97fc
leaq 0xf851(%rip), %rdi      # 0x1904b
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/hydrbond.c
// Function: FindPolInt
int FindPolInt(HBOND **HBond, RESIDUE *Res1, RESIDUE *Res2)
{

  register int i, j, hb;
  INVOLVED *p1, *p2;

  p1 = Res1->Inv;
  p2 = Res2->Inv;

  if( p1->NBondDnr && p2->NBondAcc ) {
    for( i=0; i<p1->NBondDnr; i++ ) {
      hb = p1->HBondDnr[i];
      for( j=0; j<p2->NBondAcc; j++ )
	if( hb == p2->HBondAcc[j] && HBond[hb]->ExistPolarInter ) 
	  return(hb);
    }
  }

  return(ERR);
}

// Assembly:
pushq %r14
pushq %rbx
movq 0x770(%rsi), %rcx
movl 0x30(%rcx), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
je 0x987b
movq 0x770(%rdx), %rdx
movl 0x34(%rdx), %r8d
testl %r8d, %r8d
je 0x987b
xorl %r9d, %r9d
testl %r8d, %r8d
cmovlel %r9d, %r8d
testl %esi, %esi
cmovlel %r9d, %esi
cmpq %rsi, %r9
je 0x987b
movl (%rcx,%r9,4), %r10d
movslq %r10d, %r11
xorl %ebx, %ebx
cmpq %rbx, %r8
je 0x9873
cmpl 0x18(%rdx,%rbx,4), %r10d
jne 0x986e
movq (%rdi,%r11,8), %r14
cmpl $0x0, 0x10(%r14)
jne 0x9878
incq %rbx
jmp 0x9857
incq %r9
jmp 0x9849
movl %r10d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/hydrbond.c
// Function: FindBnd
int FindBnd(HBOND **HBond, RESIDUE *Res1, RESIDUE *Res2)
{

  register int i, j, hb;
  INVOLVED *p1, *p2;

  p1 = Res1->Inv;
  p2 = Res2->Inv;

  if( p1->NBondDnr && p2->NBondAcc ) {
    for( i=0; i<p1->NBondDnr; i++ ) {
      hb = p1->HBondDnr[i];
      for( j=0; j<p2->NBondAcc; j++ )
	if( hb == p2->HBondAcc[j] && HBond[hb]->ExistHydrBondRose ) 
	  return(hb);
    }
  }

  return(ERR);
}

// Assembly:
pushq %r14
pushq %rbx
movq 0x770(%rsi), %rcx
movl 0x30(%rcx), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
je 0x98e7
movq 0x770(%rdx), %rdx
movl 0x34(%rdx), %r8d
testl %r8d, %r8d
je 0x98e7
xorl %r9d, %r9d
testl %r8d, %r8d
cmovlel %r9d, %r8d
testl %esi, %esi
cmovlel %r9d, %esi
cmpq %rsi, %r9
je 0x98e7
movl (%rcx,%r9,4), %r10d
movslq %r10d, %r11
xorl %ebx, %ebx
cmpq %rbx, %r8
je 0x98df
cmpl 0x18(%rdx,%rbx,4), %r10d
jne 0x98da
movq (%rdi,%r11,8), %r14
cmpl $0x0, 0x14(%r14)
jne 0x98e4
incq %rbx
jmp 0x98c3
incq %r9
jmp 0x98b5
movl %r10d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/hydrbond.c
// Function: NoDoubleHBond
int NoDoubleHBond(HBOND **HBond, int NHBond)
{

  int i, j, NExcl=0;

  for( i=0; i<NHBond-1; i++ )
    for( j=i+1; j<NHBond; j++ ) 
      if( HBond[i]->Dnr->D_Res == HBond[j]->Dnr->D_Res &&
	  HBond[i]->Dnr->Chain->Id == HBond[j]->Dnr->Chain->Id &&
	  HBond[i]->ExistPolarInter && HBond[j]->ExistPolarInter ) {
	if( HBond[i]->Energy < 5.0*HBond[j]->Energy ) {
	  HBond[j]->ExistPolarInter = NO;
	  NExcl++;
	}
	else 
	if( HBond[j]->Energy < 5.0*HBond[i]->Energy ) {
	  HBond[i]->ExistPolarInter = NO;
	  NExcl++;
	}
      }
  
  return(NExcl);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x2, %esi
movl $0x1, %ecx
cmovgel %esi, %ecx
decl %ecx
movl %esi, %edx
xorl %esi, %esi
movabsq $0x1, %r8
movsd 0xf604(%rip), %xmm0     # 0x18f18
movq %rdi, %r9
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x99a7
movq %r8, %r10
cmpq %r10, %rdx
je 0x9998
movq (%rdi,%rsi,8), %r11
movq (%r11), %r14
movl 0x8(%r14), %ebp
movq (%r9,%r10,8), %rbx
movq (%rbx), %r15
cmpl 0x8(%r15), %ebp
jne 0x9993
movq (%r14), %r14
movb 0x40(%r14), %bpl
movq (%r15), %r14
cmpb 0x40(%r14), %bpl
jne 0x9993
cmpl $0x0, 0x10(%r11)
je 0x9993
cmpl $0x0, 0x10(%rbx)
je 0x9993
cvtss2sd 0x1c(%r11), %xmm1
cvtss2sd 0x1c(%rbx), %xmm2
movaps %xmm2, %xmm3
mulsd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x997d
addq $0x10, %rbx
jmp 0x998e
mulsd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
jbe 0x9993
addq $0x10, %r11
movq %r11, %rbx
andl $0x0, (%rbx)
incl %eax
incq %r10
jmp 0x9925
incq %rsi
decq %rdx
addq $0x8, %r9
jmp 0x9919
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop