LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/mergepat.c
// Function: Near
int Near(int Res1, int Res2, int Res3, int Res4, int Res5, int Res6, int Res7, int Res8,
	 char Cn1, char Cn2, char Cn3, char Cn4, int *DistBest, int *DistWorst)
{

/*
   Res5 Res2 Res1
   Res6 Res3 Res4
*/

  int a, b, c1, d1, c, d, Nei1, Nei2;


  if( Cn1 != Cn2 || Cn3 != Cn4 ) return(FAILURE);


  if( Res1 >= Res2 && Res2 >= Res5 && Res7 >= Res1 && 
      Res4 <= Res3 && Res4 <= Res6 && Res8 <= Res4 ) {

    if( Res5 == Res2 ) 
      Nei1 = Res2;
    else
      Nei1 = Res2-1;
    
    if( Res1 == Res7 ) 
      Nei2 = Res1;
    else
      Nei2 = Res1+1;
    
    a = Nei2-Nei1;
    c1 = Nei2-Res5;
    
    if( Res3 == Res6 ) 
      Nei1 = Res3;
    else
      Nei1 = Res3+1;
    
    if( Res4 == Res8 ) 
      Nei2 = Res4;
    else
      Nei2 = Res4-1;
    
    b = Nei1-Nei2;
    d1 = Res6-Nei2;
  }
  else
    return(FAILURE);
  
  c = Maximum(c1,a);
  d = Maximum(d1,b);
  
  if( a >= 0 && b >= 0 && c >= 0 && d >= 0 && 
      ( (a <= 2 && b <= 5) || (a <= 5 && b <= 2) ) ) {
    *DistBest  = Minimum(a,b);
    *DistWorst = Maximum(c,d);
    if( *DistBest <= *DistWorst ) 
      return(SUCCESS);
    else
      return(FAILURE);
  }
  
  return(FAILURE);
}

// Assembly:
pushq %rbp
pushq %rbx
movb 0x38(%rsp), %r10b
movb 0x28(%rsp), %r11b
xorb 0x30(%rsp), %r11b
xorb 0x40(%rsp), %r10b
xorl %eax, %eax
orb %r11b, %r10b
jne 0xaa0a
movl 0x20(%rsp), %ebx
cmpl %ecx, %ebx
jg 0xaa0a
cmpl %r9d, %ecx
jg 0xaa0a
cmpl %edx, %ecx
jg 0xaa0a
cmpl %esi, %edi
jl 0xaa0a
cmpl %r8d, %esi
jl 0xaa0a
movl 0x18(%rsp), %ebp
cmpl %edi, %ebp
jl 0xaa0a
xorl %r10d, %r10d
cmpl %esi, %r8d
setne %r10b
xorl %r11d, %r11d
cmpl %ebp, %edi
setne %r11b
addl %edi, %r11d
subl %esi, %r10d
addl %r11d, %r10d
subl %r8d, %r11d
xorl %esi, %esi
cmpl %r9d, %edx
setne %sil
addl %edx, %esi
xorl %edx, %edx
cmpl %ebx, %ecx
setne %dl
subl %edx, %ecx
subl %ecx, %esi
subl %ecx, %r9d
cmpl %r10d, %r11d
cmovlel %r10d, %r11d
cmpl %esi, %r9d
cmovlel %esi, %r9d
testl %r10d, %r10d
js 0xaa0a
testl %esi, %esi
js 0xaa0a
testl %r11d, %r11d
js 0xaa0a
testl %r9d, %r9d
js 0xaa0a
cmpl $0x3, %r10d
setb %cl
cmpl $0x6, %esi
setb %dl
testb %dl, %cl
jne 0xa9e5
cmpl $0x6, %r10d
setb %cl
cmpl $0x3, %esi
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xaa0a
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpl %esi, %r10d
cmovbl %r10d, %esi
movl %esi, (%rcx)
cmpl %r9d, %r11d
cmoval %r11d, %r9d
movl %r9d, (%rax)
xorl %eax, %eax
cmpl %r9d, (%rcx)
setle %al
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/mergepat.c
// Function: RightSide
int RightSide(int LnkA, int LnkD, int I1A, int I1D, int I2A, int I2D )
{

  if( ( I1A == I2D && I1D == I2A ) ||
      ( I1A < I2D && LnkA <= I2D && LnkA <= I1A ) || 
      ( I1A > I2D && LnkA >= I2D && LnkA >= I1A ) ||
      ( I1D < I2A && LnkD <= I2A && LnkD <= I1D ) ||
      ( I1D > I2A && LnkD >= I2A && LnkD >= I1D ) )
    return(SUCCESS);
  
  return(FAILURE);
}

// Assembly:
movl %edx, %r10d
xorl %r9d, %r10d
movl %ecx, %r11d
xorl %r8d, %r11d
pushq $0x1
popq %rax
orl %r10d, %r11d
je 0xaa2f
cmpl %edx, %edi
jg 0xaa30
cmpl %r9d, %edx
jge 0xaa30
cmpl %r9d, %edi
jg 0xaa30
retq
cmpl %edx, %edi
jl 0xaa3e
cmpl %r9d, %edx
jle 0xaa3e
cmpl %r9d, %edi
jge 0xaa2f
cmpl %ecx, %esi
jg 0xaa4c
cmpl %r8d, %ecx
jge 0xaa4c
cmpl %r8d, %esi
jle 0xaa2f
cmpl %r8d, %ecx
setg %al
cmpl %r8d, %esi
setge %dl
cmpl %ecx, %esi
setge %cl
andb %dl, %cl
andb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/mergepat.c
// Function: RightSide2
int RightSide2(int L_A1, int L_D1, int LnkD, int LnkA, int I1A, int I1D, int I2A, int I2D)
{

  if( ( I2A < I1D && LnkA <= I1D && LnkA <= I2A ) || 
      ( I2A > I1D && LnkA >= I1D && LnkA >= I2A ) ||
      ( I2D < I1A && LnkD <= I1A && LnkA <= I2D ) || 
      ( I2D > I1A && LnkD >= I1A && LnkD >= I2D )  )
    return(SUCCESS);
  else
    if( I2A == I1D && I2D == I1A ) {
      if( L_A1 != ERR && 
	 ( ( LnkD <= I2D && L_A1 <= I2D && LnkA >= I2A && L_D1 >= I2A ) || 
	   ( LnkD >= I2D && L_A1 >= I2D && LnkA <= I2A && L_D1 <= I2A ) ) )
	return(FAILURE);
      else
	return(SUCCESS);
    }

  return(FAILURE);
}

// Assembly:
pushq %rbx
movl 0x10(%rsp), %r11d
movl $0x1, %r10d
cmpl %r11d, %ecx
jg 0xaab5
cmpl %r9d, %ecx
jg 0xaab5
cmpl %r9d, %r11d
jl 0xaae4
cmpl %r11d, %ecx
jl 0xaac4
cmpl %r9d, %ecx
jl 0xaac4
cmpl %r9d, %r11d
jg 0xaae4
movl 0x18(%rsp), %ebx
cmpl %ebx, %ecx
jg 0xaad6
cmpl %r8d, %edx
jg 0xaad6
cmpl %r8d, %ebx
jl 0xaae4
cmpl %ebx, %edx
jl 0xaae9
cmpl %r8d, %edx
jl 0xaae9
cmpl %r8d, %ebx
jle 0xaae9
movl %r10d, %eax
popq %rbx
retq
xorl %r11d, %r9d
xorl %ebx, %r8d
xorl %eax, %eax
orl %r9d, %r8d
jne 0xaae7
cmpl $-0x1, %edi
je 0xaae4
cmpl %r11d, %ecx
jl 0xab0d
cmpl %r11d, %esi
jl 0xab0d
cmpl %ebx, %edx
jg 0xab0d
cmpl %ebx, %edi
jle 0xaae7
cmpl %r11d, %ecx
jg 0xaae4
cmpl %ebx, %edx
jl 0xaae4
cmpl %r11d, %esi
jg 0xaae4
cmpl %ebx, %edi
jge 0xaae7
jmp 0xaae4
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/mergepat.c
// Function: RightSidePar
int RightSidePar(int LnkA, int LnkD, int I1A, int I1D, int I2A, int I2D )
{

  if( ( I1A == I2D && I1D == I2A ) ||
      ( I1A < I2D && LnkA < I2D && LnkA <= I1A && I1D <= I2A && LnkD <= I2A && LnkD <= I1D ) || 
      ( I1A > I2D && LnkA > I2D && LnkA >= I1A && I1D >= I2A && LnkD >= I2A && LnkD >= I1D ) ||
      ( I1D < I2A && LnkD < I2A && LnkD <= I1D && I1A <= I2D && LnkA <= I2D && LnkA <= I1A ) ||
      ( I1D > I2A && LnkD > I2A && LnkD >= I1D && I1A >= I2D && LnkA >= I2D && LnkA >= I1A) )
    return(SUCCESS);
  
  return(FAILURE);
}

// Assembly:
movl %edx, %r10d
xorl %r9d, %r10d
movl %ecx, %r11d
xorl %r8d, %r11d
pushq $0x1
popq %rax
orl %r10d, %r11d
je 0xbc02
cmpl %ecx, %esi
jg 0xbc03
cmpl %r8d, %esi
jg 0xbc03
cmpl %r8d, %ecx
jg 0xbc03
cmpl %edx, %edi
jg 0xbc03
cmpl %r9d, %edx
jge 0xbc03
cmpl %r9d, %edi
jge 0xbc03
retq
cmpl %ecx, %esi
jl 0xbc1f
cmpl %r8d, %esi
jl 0xbc1f
cmpl %r8d, %ecx
jl 0xbc1f
cmpl %edx, %edi
jl 0xbc1f
cmpl %r9d, %edx
jle 0xbc1f
cmpl %r9d, %edi
jg 0xbc02
cmpl %edx, %edi
jg 0xbc3b
cmpl %r9d, %edi
jg 0xbc3b
cmpl %r9d, %edx
jg 0xbc3b
cmpl %ecx, %esi
jg 0xbc3b
cmpl %r8d, %ecx
jge 0xbc3b
cmpl %r8d, %esi
jl 0xbc02
cmpl %ecx, %esi
setge %al
cmpl %edx, %edi
setge %r10b
cmpl %r8d, %esi
setg %sil
cmpl %r8d, %ecx
setg %cl
cmpl %r9d, %edi
setge %dil
cmpl %r9d, %edx
setge %dl
andb %sil, %cl
andb %al, %dl
andb %cl, %dl
andb %r10b, %dil
andb %dl, %dil
movzbl %dil, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/escape.c
// Function: escape
int escape(int RetVal, char *format, ... ) {
va_list ptr;

va_start(ptr,format);
vfprintf(stderr,format,ptr);
va_end(ptr);
return(RetVal);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xed3e
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 $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x1128b(%rip), %rax     # 0x1fff0
movq (%rax), %rdi
callq 0x21d0
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/p_jrnl.c
// Function: Process_JRNL
int Process_JRNL(BUFFER Buffer, BOOLEAN *Published)
{
  char *Field[MAX_FIELD];

  SplitString(Buffer,Field,10);
  
  if( !strncmp(Field[1],"REF",3) && !strncmp(Field[2],"TO",2) && 
      !strncmp(Field[3],"BE",2)  && !strncmp(Field[4],"PUBLISHED",9) )
    *Published = NO;

  return(SUCCESS);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq %rsp, %r14
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x311c
movq 0x8(%r14), %rax
cmpb $0x52, (%rax)
jne 0xede3
cmpb $0x45, 0x1(%rax)
jne 0xede3
cmpb $0x46, 0x2(%rax)
jne 0xede3
movq 0x10(%rsp), %rax
cmpb $0x54, (%rax)
jne 0xede3
cmpb $0x4f, 0x1(%rax)
jne 0xede3
movq 0x18(%rsp), %rax
cmpb $0x42, (%rax)
jne 0xede3
cmpb $0x45, 0x1(%rax)
jne 0xede3
movq 0x20(%rsp), %rdi
leaq 0xa2ca(%rip), %rsi      # 0x1909e
pushq $0x9
popq %rdx
callq 0x2060
testl %eax, %eax
jne 0xede3
andl $0x0, (%rbx)
pushq $0x1
popq %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/p_ssbond.c
// Function: Process_SSBOND
int Process_SSBOND(BUFFER Buffer, CHAIN **Chain, int *ChainNumber, COMMAND *Cmd)
{
  int CC, BC;
  char *Field[MAX_FIELD];
  BUFFER Tmp;

  if( Cmd->NActive && !ChInStr(Cmd->Active,SpaceToDash(Buffer[15])) )
     return(SUCCESS);

  CC = 0;

  if( *ChainNumber == 0 ) {
    InitChain(&Chain[CC]); 
    Chain[CC]->Id = Buffer[15];
    (*ChainNumber)++;
  }

  BC = Chain[CC]->NBond;
  Chain[CC]->SSbond[BC] =  (SSBOND *)ckalloc(sizeof(SSBOND));

  strcpy(Tmp,Buffer);
  Tmp[21] = ' ';
  Tmp[35] = ' ';
  SplitString(Tmp+17,Field,1);
  strcpy(Chain[CC]->SSbond[BC]->PDB_ResNumb1,Field[0]);
  SplitString(Tmp+31,Field,1);
  strcpy(Chain[CC]->SSbond[BC]->PDB_ResNumb2,Field[0]);

  Chain[CC]->SSbond[BC]->ChainId1 = Buffer[15];
  Chain[CC]->SSbond[BC]->ChainId2 = Buffer[29];

  Chain[CC]->SSbond[BC]->InsCode1 = Buffer[21];
  Chain[CC]->SSbond[BC]->InsCode2 = Buffer[35];

  Chain[CC]->SSbond[BC]->AsnSource = Pdb;

  Chain[CC]->NBond++;

  return(SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5a0, %rsp            # imm = 0x5A0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x1cf8(%rcx)
je 0xfd9f
movq %rcx, %r12
addq $0x1c08, %r12           # imm = 0x1C08
movsbl 0xf(%rbx), %edi
callq 0x4969
movsbl %al, %esi
movq %r12, %rdi
callq 0x4974
testl %eax, %eax
je 0xfe79
cmpl $0x0, (%r15)
je 0xfdaa
movq (%r14), %rax
jmp 0xfdbe
movq %r14, %rdi
callq 0x3798
movb 0xf(%rbx), %cl
movq (%r14), %rax
movb %cl, 0x40(%rax)
incl (%r15)
movslq 0x2c(%rax), %r12
pushq $0x14
popq %rdi
callq 0x50f4
movq (%r14), %rcx
movq 0xa0(%rcx), %rcx
movq %rax, (%rcx,%r12,8)
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2070
movb $0x20, %al
movb %al, 0x15(%r15)
movb %al, 0x23(%r15)
leaq 0x11(%rsp), %rdi
leaq 0x410(%rsp), %r15
pushq $0x1
popq %rbp
movq %r15, %rsi
movl %ebp, %edx
callq 0x311c
movq (%r14), %rax
movq 0xa0(%rax), %rax
movq (%rax,%r12,8), %rdi
movq (%r15), %rsi
callq 0x2070
leaq 0x1f(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x311c
movq (%r14), %rax
movq 0xa0(%rax), %rax
movq (%rax,%r12,8), %rdi
addq $0x6, %rdi
movq (%r15), %rsi
callq 0x2070
movb 0xf(%rbx), %al
movq (%r14), %rcx
movq 0xa0(%rcx), %rdx
movq (%rdx,%r12,8), %rdx
movb %al, 0xe(%rdx)
movb 0x1d(%rbx), %al
movb %al, 0xf(%rdx)
movb 0x15(%rbx), %al
movb %al, 0xc(%rdx)
movb 0x23(%rbx), %al
movb %al, 0xd(%rdx)
movl $0x1, 0x10(%rdx)
incl 0x2c(%rcx)
pushq $0x1
popq %rax
addq $0x5a0, %rsp            # imm = 0x5A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/p_expdta.c
// Function: Process_EXPDTA
int Process_EXPDTA(BUFFER Buffer, enum METHOD *Method)
{
  char *Field[MAX_FIELD];
  int i, NFields;

  NFields = SplitString(Buffer,Field,10);
  
  for( i=0; i<NFields; i++ ) {
    if( !strcmp(Field[i],"MODEL") ) 
      *Method = Model;
    else 
    if( !strcmp(Field[i],"NMR") || !strcmp(Field[i],"/NMR$")  ) 
      *Method = NMR;
  }
  return(SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq %rsp, %rsi
pushq $0xa
popq %rdx
callq 0x311c
movl %eax, %r14d
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %r14d
pushq $0x2
popq %r12
pushq $0x1
popq %r15
cmpq %r13, %r14
je 0xff11
movq (%rsp,%r13,8), %rbp
movq %rbp, %rdi
leaq 0x8965(%rip), %rsi      # 0x18837
callq 0x2150
movl %r12d, %ecx
testl %eax, %eax
je 0xff0a
movq %rbp, %rdi
leaq 0x91fb(%rip), %rsi      # 0x190e3
callq 0x2150
movl %r15d, %ecx
testl %eax, %eax
je 0xff0a
movq %rbp, %rdi
leaq 0x91e9(%rip), %rsi      # 0x190e7
callq 0x2150
movl %r15d, %ecx
testl %eax, %eax
jne 0xff0c
movl %ecx, (%rbx)
incq %r13
jmp 0xfebf
pushq $0x1
popq %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/p_compnd.c
// Function: Process_COMPND
int Process_COMPND(BUFFER Buffer, enum METHOD *Method)
{
  if( strstr(Buffer,"NMR") ) 
    *Method = NMR;

  if( strstr(Buffer,"MODEL") ) 
    if( *Method == XRay ) 
      *Method = Model;
  
  return(SUCCESS);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x919a(%rip), %rsi      # 0x190e3
callq 0x2280
testq %rax, %rax
je 0xff59
movl $0x1, (%rbx)
leaq 0x88d7(%rip), %rsi      # 0x18837
movq %r14, %rdi
callq 0x2280
testq %rax, %rax
je 0xff78
cmpl $0x0, (%rbx)
jne 0xff78
movl $0x2, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/report.c
// Function: Report
void Report(CHAIN **Chain, int NChain, HBOND **HBond, COMMAND *Cmd) 
{

  FILE *Out;

  if( !strlen(Cmd->OutFile) )
    Out = stdout;
  else 
  if( !(Out = fopen(Cmd->OutFile,"w")) )
    die("Can not open output file %s\n",Cmd->OutFile);
  
  if( !Cmd->ReportSummaryOnly )
    ReportGeneral(Chain,Out);

  ReportSummary(Chain,NChain,Out,Cmd);
  ReportShort(Chain,NChain,Out,Cmd);
  ReportTurnTypes(Chain,NChain,Out,Cmd);
  ReportSSBonds(Chain,Out);

  if( !Cmd->ReportSummaryOnly )
    ReportDetailed(Chain,NChain,Out,Cmd);

  if( Cmd->ReportBonds )
    ReportHydrBonds(Chain,NChain,HBond,Out,Cmd);


  if( Cmd->Measure ) {
    Measure(Chain,NChain,0,Cmd,Out);
    Measure(Chain,NChain,1,Cmd,Out);
  }

  if( Out != stdout )
    fclose(Out);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x0, 0x401(%rcx)
je 0xffd7
leaq 0x401(%rbx), %r13
leaq 0x8dcf(%rip), %rsi      # 0x18d80
movq %r13, %rdi
callq 0x21c0
movq %rax, %r15
testq %rax, %rax
jne 0xffe1
leaq 0x91e8(%rip), %rdi      # 0x191b0
xorl %r15d, %r15d
movq %r13, %rsi
xorl %eax, %eax
callq 0x7c4c
jmp 0xffe1
movq 0xfff2(%rip), %rax      # 0x1ffd0
movq (%rax), %r15
cmpl $0x0, 0x1d6c(%rbx)
jne 0xfff5
movq %r14, %rdi
movq %r15, %rsi
callq 0x100b8
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x10285
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1065e
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x10876
movq %r14, %rdi
movq %r15, %rsi
callq 0x109cf
cmpl $0x0, 0x1d6c(%rbx)
jne 0x10040
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x10ac1
cmpl $0x0, 0x1d70(%rbx)
je 0x10059
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x10d1e
cmpl $0x0, 0x1d88(%rbx)
je 0x10087
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x1664c
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
movq %r15, %r8
callq 0x1664c
movq 0xff42(%rip), %rax      # 0x1ffd0
cmpq (%rax), %r15
je 0x100a9
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
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/report.c
// Function: ReportTurnTypes
void ReportTurnTypes(CHAIN **Chain, int NChain, FILE *Out, COMMAND *Cmd)
{

  register int Cn, Tn;
  BUFFER Bf, Tmp;
  TURN *t;

  Tn = 0;
  for( Cn=0; Cn<NChain; Cn++ )
    if( Chain[Cn]->Valid )
       Tn += Chain[Cn]->NAssignedTurn;

  if( !Tn ) return;

  PrepareBuffer(Bf,Chain);

  for( Cn=0; Cn<NChain; Cn++ ) {
    if( !Chain[Cn]->Valid )
      continue;
    for( Tn=0; Tn<Chain[Cn]->NAssignedTurn; Tn++ ) {
      t = Chain[Cn]->AssignedTurn[Tn];
      sprintf(Tmp,"LOC  %-11s  %3s  %4s %c      %3s   %4s %c",
	      Translate(t->TurnType),t->Res1,t->PDB_ResNumb1,
	      SpaceToDash(Chain[Cn]->Id),t->Res2,
	      t->PDB_ResNumb2,SpaceToDash(Chain[Cn]->Id));

      Glue(Bf,Tmp,Out);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x848, %rsp            # imm = 0x848
movq %rdx, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, (%rsp)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebx
xorl %ecx, %ecx
cmpq %rax, %rbx
je 0x108b6
movq (%rsp), %rdx
movq (%rdx,%rax,8), %rdx
cmpl $0x0, 0x58(%rdx)
je 0x108b1
addl 0x28(%rdx), %ecx
incq %rax
jmp 0x1089b
testl %ecx, %ecx
je 0x109bd
leaq 0x440(%rsp), %rdi
movq (%rsp), %rsi
callq 0x111b7
xorl %r13d, %r13d
movq %rbx, 0x8(%rsp)
movq (%rsp), %rbp
cmpq %rbx, %r13
je 0x109bd
movq (%rsp), %rax
movq (%rax,%r13,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x109b0
xorl %r15d, %r15d
movslq 0x28(%rax), %rcx
cmpq %rcx, %r15
jge 0x109b0
movq 0x98(%rax), %rax
movq (%rax,%r15,8), %r14
movsbl 0x1a(%r14), %edi
callq 0x48b3
movq %rax, 0x20(%rsp)
leaq 0xc(%r14), %rax
movq %rax, 0x28(%rsp)
movq (%rbp,%r13,8), %rax
movsbl 0x40(%rax), %edi
callq 0x4969
movsbl %al, %ebx
leaq 0x6(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0x12(%r14), %r12
movq (%rbp,%r13,8), %rax
movsbl 0x40(%rax), %edi
callq 0x4969
movsbl %al, %r10d
subq $0x8, %rsp
leaq 0x38(%rsp), %rdi
leaq 0x8da3(%rip), %rsi      # 0x1970c
movq 0x28(%rsp), %rdx
movq %r14, %rcx
movq 0x30(%rsp), %r8
movl %ebx, %r9d
xorl %eax, %eax
pushq %r10
pushq %r12
pushq 0x30(%rsp)
callq 0x2230
addq $0x20, %rsp
leaq 0x440(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x111f1
incq %r15
movq (%rbp,%r13,8), %rax
jmp 0x108f9
incq %r13
movq 0x8(%rsp), %rbx
jmp 0x108db
addq $0x848, %rsp            # imm = 0x848
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/report.c
// Function: ReportSSBonds
void ReportSSBonds(CHAIN **Chain, FILE *Out)
{
  register int i;
  BUFFER Bf, Tmp;
  SSBOND *s;

  if( !Chain[0]->NBond ) return;

  PrepareBuffer(Bf,Chain);

  for( i=0; i<Chain[0]->NBond; i++ ) {
    s = Chain[0]->SSbond[i];
    sprintf(Tmp,"LOC  Disulfide    CYS  %4s %c      CYS   %4s %c         ",
	    s->PDB_ResNumb1,SpaceToDash(s->ChainId1),
	    s->PDB_ResNumb2,SpaceToDash(s->ChainId2));

    if( s->AsnSource == Pdb )
      strcat(Tmp,"   PDB");
    else
      strcat(Tmp,"STRIDE\n");
    Glue(Bf,Tmp,Out);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %rsi, 0x8(%rsp)
movq (%rdi), %rax
cmpl $0x0, 0x2c(%rax)
je 0x10aaf
movq %rdi, %r14
leaq 0x420(%rsp), %rdi
movq %r14, %rsi
callq 0x111b7
leaq 0x10(%rsp), %r13
xorl %ebx, %ebx
movq (%r14), %rax
movslq 0x2c(%rax), %rcx
cmpq %rcx, %rbx
jge 0x10aaf
movq 0xa0(%rax), %rax
movq (%rax,%rbx,8), %rbp
movsbl 0xe(%rbp), %edi
callq 0x4969
movsbl %al, %r15d
leaq 0x6(%rbp), %r12
movsbl 0xf(%rbp), %edi
callq 0x4969
movsbl %al, %r9d
movq %r13, %rdi
leaq 0x8c7d(%rip), %rsi      # 0x196cc
movq %rbp, %rdx
movl %r15d, %ecx
movq %r12, %r8
xorl %eax, %eax
callq 0x2230
movl 0x10(%rbp), %ebp
movq %r13, %rdi
callq 0x20b0
addq %rsp, %rax
addq $0x10, %rax
cmpl $0x1, %ebp
jne 0x10a85
movl $0x424450, 0x3(%rax)    # imm = 0x424450
movl $0x50202020, (%rax)     # imm = 0x50202020
jmp 0x10a92
movabsq $0xa454449525453, %rcx  # imm = 0xA454449525453
movq %rcx, (%rax)
leaq 0x420(%rsp), %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0x111f1
incq %rbx
jmp 0x10a0c
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/nsc.c
// Function: error
void error(const char *fmt, ...) {
  va_list args;
  fprintf(stderr,
    "\n---> ERROR when executing line %i in file %s !\n",
    __line__,__file__);
  va_start(args,fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n---> Execution stopped !\n\n");
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x112a3
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 0xed46(%rip), %r15      # 0x1fff0
movq (%r15), %rdi
movl 0x10395(%rip), %edx     # 0x21648
movq 0x10396(%rip), %rcx     # 0x21650
leaq 0x85bf(%rip), %rsi      # 0x19880
xorl %eax, %eax
callq 0x2160
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x21d0
movq (%r15), %rcx
leaq 0x85b4(%rip), %rdi      # 0x198b1
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/nsc.c
// Function: warning
void warning(const char *fmt, ...) {
  va_list args;
  fprintf(stderr,
    "\n---> WARNING : line %i in file %s\n",
    __line__,__file__);
  va_start(args,fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, " ...!\n\n");
  fflush(stderr);
  fflush(stdout);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x11378
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 0xec71(%rip), %r14      # 0x1fff0
movq (%r14), %rdi
movl 0x102c0(%rip), %edx     # 0x21648
movq 0x102c1(%rip), %rcx     # 0x21650
leaq 0x8537(%rip), %rsi      # 0x198cd
xorl %eax, %eax
callq 0x2160
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21d0
movq (%r14), %rcx
leaq 0x851f(%rip), %rdi      # 0x198f1
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
movq (%r14), %rdi
callq 0x2190
movq 0xebe4(%rip), %rax      # 0x1ffd0
movq (%rax), %rdi
callq 0x2190
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/nsc.c
// Function: safe_asin
double safe_asin(double f) {
  if ( (fabs(f) < 1.00) ) return( asin(f) );
  if ( (fabs(f) - 1.00)  < DP_TOL ) return(HALFPI);
  else ERROR("ASIN : invalid argument %f", f);
  return(0.0);
  }

// Assembly:
movapd 0x74b7(%rip), %xmm1     # 0x188c0
andpd %xmm0, %xmm1
movsd 0x7453(%rip), %xmm2     # 0x18868
ucomisd %xmm1, %xmm2
ja 0x2220
addsd 0x7431(%rip), %xmm1     # 0x18858
movsd 0x83e9(%rip), %xmm2     # 0x19818
ucomisd %xmm1, %xmm2
jbe 0x1143e
movsd 0x83d3(%rip), %xmm0     # 0x19810
retq
pushq %rax
leaq 0x84b3(%rip), %rax      # 0x198f9
movq %rax, 0x10203(%rip)     # 0x21650
movl $0x61, 0x101f1(%rip)    # 0x21648
leaq 0x84a1(%rip), %rdi      # 0x198ff
movb $0x1, %al
callq 0x11240
xorpd %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/nsc.c
// Function: mycalloc
void * mycalloc(const char * filename, const int linenr,
                size_t nelem, size_t elsize) {
  int * ip;
  ip = (int *) calloc(nelem, elsize);
  if(ip) return(ip);
  else ERROR("CALLOC : failed in file %s at line %d", filename, linenr);
  return(void *)ip;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x2140
movq %rax, %r14
testq %rax, %rax
jne 0x114b6
leaq 0x8467(%rip), %rax      # 0x198f9
movq %rax, 0x101b7(%rip)     # 0x21650
movl $0x6b, 0x101a5(%rip)    # 0x21648
leaq 0x8470(%rip), %rdi      # 0x1991a
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x11240
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/nsc.c
// Function: myrealloc
void * myrealloc(const char * filename, const int linenr,
                 void * ptr, size_t size) {
  int * ip;
  ip = (int *) realloc(ptr, size);
  if(ip) return(ip);
  else ERROR("REALLOC : failed in file %s at line %d", filename, linenr);
  return(void*)ip;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x21b0
movq %rax, %r14
testq %rax, %rax
jne 0x11507
leaq 0x8416(%rip), %rax      # 0x198f9
movq %rax, 0x10166(%rip)     # 0x21650
movl $0x75, 0x10154(%rip)    # 0x21648
leaq 0x8445(%rip), %rdi      # 0x19940
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x11240
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/nsc.c
// Function: icosaeder_vertices
void icosaeder_vertices(double *xus) {
  rh = sqrt(1.-2.*cos(TORAD(72.)))/(1.-cos(TORAD(72.)));
  rg = cos(TORAD(72.))/(1.-cos(TORAD(72.)));
/* icosaeder vertices */
  xus[ 0] = 0.;                  xus[ 1] = 0.;                  xus[ 2] = 1.;
  xus[ 3] = rh*cos(TORAD(72.));  xus[ 4] = rh*sin(TORAD(72.));  xus[ 5] = rg;
  xus[ 6] = rh*cos(TORAD(144.)); xus[ 7] = rh*sin(TORAD(144.)); xus[ 8] = rg;
  xus[ 9] = rh*cos(TORAD(216.)); xus[10] = rh*sin(TORAD(216.)); xus[11] = rg;
  xus[12] = rh*cos(TORAD(288.)); xus[13] = rh*sin(TORAD(288.)); xus[14] = rg;
  xus[15] = rh;                  xus[16] = 0;                   xus[17] = rg;
  xus[18] = rh*cos(TORAD(36.));  xus[19] = rh*sin(TORAD(36.));  xus[20] = -rg;
  xus[21] = rh*cos(TORAD(108.)); xus[22] = rh*sin(TORAD(108.)); xus[23] = -rg;
  xus[24] = -rh;                 xus[25] = 0;                   xus[26] = -rg;
  xus[27] = rh*cos(TORAD(252.)); xus[28] = rh*sin(TORAD(252.)); xus[29] = -rg;
  xus[30] = rh*cos(TORAD(324.)); xus[31] = rh*sin(TORAD(324.)); xus[32] = -rg;
  xus[33] = 0.;                  xus[34] = 0.;                  xus[35] = -1.;
  }

// Assembly:
movabsq $0x3fec9f25d83b2f4b, %rax # imm = 0x3FEC9F25D83B2F4B
movq %rax, 0x10137(%rip)     # 0x21658
movabsq $0x3fdc9f257bd2e79a, %rax # imm = 0x3FDC9F257BD2E79A
movq %rax, 0x1012e(%rip)     # 0x21660
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movaps 0x8231(%rip), %xmm1     # 0x19770
movups %xmm1, 0x10(%rdi)
movabsq $0x3feb388821fab2fd, %rcx # imm = 0x3FEB388821FAB2FD
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movaps 0x8224(%rip), %xmm1     # 0x19780
movups %xmm1, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movaps 0x8225(%rip), %xmm1     # 0x19790
movups %xmm1, 0x48(%rdi)
movq %rax, 0x58(%rdi)
movaps 0x8226(%rip), %xmm1     # 0x197a0
movups %xmm1, 0x60(%rdi)
movq %rax, 0x70(%rdi)
movsd 0x8296(%rip), %xmm1     # 0x19820
movups %xmm1, 0x78(%rdi)
movq %rax, 0x88(%rdi)
movaps 0x8214(%rip), %xmm1     # 0x197b0
movups %xmm1, 0x90(%rdi)
movabsq $-0x402360da842d1866, %rax # imm = 0xBFDC9F257BD2E79A
movq %rax, 0xa0(%rdi)
movaps 0x8205(%rip), %xmm1     # 0x197c0
movups %xmm1, 0xa8(%rdi)
movq %rax, 0xb8(%rdi)
movsd 0x8257(%rip), %xmm1     # 0x19828
movups %xmm1, 0xc0(%rdi)
movq %rax, 0xd0(%rdi)
movaps 0x81ea(%rip), %xmm1     # 0x197d0
movups %xmm1, 0xd8(%rdi)
movq %rax, 0xe8(%rdi)
movaps 0x81e5(%rip), %xmm1     # 0x197e0
movups %xmm1, 0xf0(%rdi)
movq %rax, 0x100(%rdi)
movups %xmm0, 0x108(%rdi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x118(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/nsc.c
// Function: unsp_type
int unsp_type(int densit) {
  int i1, i2;
  i1 = 1;
  while (10*i1*i1+2 < densit) i1++;
  i2 = 1;
  while (30*i2*i2+2 < densit) i2++;
  if (10*i1*i1-2 < 30*i2*i2-2) return UNSP_ICO_ARC;
  else return UNSP_ICO_DOD;
  }

// Assembly:
pushq $0x1
popq %rax
pushq $0xa
popq %rdx
movl %edx, %ecx
imull %eax, %ecx
leal 0x2(%rcx), %esi
incl %eax
addl $0xa, %edx
cmpl %edi, %esi
jl 0x1301c
pushq $0x1
popq %rax
pushq $0x1e
popq %rdx
movl %edx, %esi
imull %eax, %esi
leal 0x2(%rsi), %r8d
incl %eax
addl $0x1e, %edx
cmpl %edi, %r8d
jl 0x13033
xorl %eax, %eax
cmpl %esi, %ecx
adcl $0x9, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/ssbond.c
// Function: ExistSSBond
BOOLEAN ExistSSBond(CHAIN **Chain,int NChain, int Cn1,int Cn2,char *Res1,char *Res2)
{

  register int i;
  SSBOND *ptr;

  for( i=0; i<Chain[0]->NBond; i++ ) {
    ptr = Chain[0]->SSbond[i];
    if( ( !strcmp(Res1,ptr->PDB_ResNumb1) && 
	  !strcmp(Res2,ptr->PDB_ResNumb2) &&
	  FindChain(Chain,NChain,ptr->ChainId1) == Cn1 &&
	  FindChain(Chain,NChain,ptr->ChainId2) == Cn2 ) ||
        ( !strcmp(Res2,ptr->PDB_ResNumb1) && 
          !strcmp(Res1,ptr->PDB_ResNumb2) &&
	  FindChain(Chain,NChain,ptr->ChainId1) == Cn2 &&
	  FindChain(Chain,NChain,ptr->ChainId2) == Cn1 ) )
      return(SUCCESS);
  }

  return(FAILURE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movl %ecx, (%rsp)
movl %edx, 0x4(%rsp)
movl %esi, %r13d
movq %rdi, %rbx
xorl %r12d, %r12d
movq (%rbx), %rax
movslq 0x2c(%rax), %rcx
cmpq %rcx, %r12
jge 0x14821
movq 0xa0(%rax), %rax
movq (%rax,%r12,8), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2150
testl %eax, %eax
jne 0x147d1
leaq 0x6(%rbp), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
jne 0x147d1
movsbl 0xe(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4847
cmpl 0x4(%rsp), %eax
jne 0x147d1
movsbl 0xf(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4847
cmpl (%rsp), %eax
je 0x14832
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2150
testl %eax, %eax
jne 0x14819
leaq 0x6(%rbp), %rsi
movq %r15, %rdi
callq 0x2150
testl %eax, %eax
jne 0x14819
movsbl 0xe(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4847
cmpl (%rsp), %eax
jne 0x14819
movsbl 0xf(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4847
cmpl 0x4(%rsp), %eax
je 0x14832
incq %r12
jmp 0x1476e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x14823
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/turn.c
// Function: TurnCondition
int TurnCondition(float Phi2,float Phi2S,float Psi2,float Psi2S,
		  float Phi3,float Phi3S,float Psi3,float Psi3S,
		  float Range1,float Range2)
{
  if((IN(Phi2,Phi2S,Range2)==YES && IN(Psi2,Psi2S,Range1)==YES && 
      IN(Phi3,Phi3S,Range1)==YES && IN(Psi3,Psi3S,Range1)==YES)
     ||
     (IN(Phi2,Phi2S,Range1)==YES && IN(Psi2,Psi2S,Range2)==YES && 
      IN(Phi3,Phi3S,Range1)==YES && IN(Psi3,Psi3S,Range1)==YES)
     ||
     (IN(Phi2,Phi2S,Range1)==YES && IN(Psi2,Psi2S,Range1)==YES && 
      IN(Phi3,Phi3S,Range2)==YES && IN(Psi3,Psi3S,Range1)==YES)
     ||
     (IN(Phi2,Phi2S,Range1)==YES && IN(Psi2,Psi2S,Range1)==YES && 
      IN(Phi3,Phi3S,Range1)==YES && IN(Psi3,Psi3S,Range2)==YES)
     )
    return(SUCCESS);
  
  return(FAILURE);
}

// Assembly:
movss 0x10(%rsp), %xmm8
movss 0x8(%rsp), %xmm9
movaps %xmm1, %xmm10
subss %xmm8, %xmm10
ucomiss %xmm10, %xmm0
pushq $0x1
popq %rax
jb 0x14d77
movaps %xmm1, %xmm10
addss %xmm8, %xmm10
ucomiss %xmm0, %xmm10
jb 0x14d77
movaps %xmm3, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm2
jb 0x14d77
movaps %xmm3, %xmm10
addss %xmm9, %xmm10
ucomiss %xmm2, %xmm10
jb 0x14d77
movaps %xmm5, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm4
jb 0x14d77
movaps %xmm5, %xmm10
addss %xmm9, %xmm10
ucomiss %xmm4, %xmm10
jb 0x14d77
movaps %xmm7, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm6
jb 0x14d77
movaps %xmm7, %xmm10
addss %xmm9, %xmm10
ucomiss %xmm6, %xmm10
jb 0x14d77
retq
movaps %xmm1, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm0
jb 0x14e67
addss %xmm9, %xmm1
ucomiss %xmm0, %xmm1
jb 0x14e67
movaps %xmm3, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm2
jb 0x14de6
movaps %xmm3, %xmm0
addss %xmm8, %xmm0
ucomiss %xmm2, %xmm0
jb 0x14de6
movaps %xmm5, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm4
jb 0x14de6
movaps %xmm5, %xmm0
addss %xmm9, %xmm0
ucomiss %xmm4, %xmm0
jb 0x14de6
movaps %xmm7, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm6
jb 0x14de6
movaps %xmm7, %xmm0
addss %xmm9, %xmm0
ucomiss %xmm6, %xmm0
jae 0x14d76
movaps %xmm3, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm2
jb 0x14e67
addss %xmm9, %xmm3
ucomiss %xmm2, %xmm3
jb 0x14e67
movaps %xmm5, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm4
jb 0x14e35
movaps %xmm5, %xmm0
addss %xmm8, %xmm0
ucomiss %xmm4, %xmm0
jb 0x14e35
movaps %xmm7, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm6
jb 0x14e35
movaps %xmm7, %xmm0
addss %xmm9, %xmm0
ucomiss %xmm6, %xmm0
jae 0x14d76
movaps %xmm5, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm4
jb 0x14e67
addss %xmm9, %xmm5
ucomiss %xmm4, %xmm5
jb 0x14e67
movaps %xmm7, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm6
jb 0x14e67
addss %xmm8, %xmm7
ucomiss %xmm6, %xmm7
jae 0x14d76
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/dssp.c
// Function: CompPdbDssp
int CompPdbDssp(CHAIN *Chain, DSSP *Dssp)
{

  int Res, CA;

  /* If the first or the last PDB residue does not have Ca, insert one residue in
     coil conformation in the beginning or in the end of the DSSP chain */
  if( !FindAtom(Chain,0,"CA",&CA) ) 
    InsertFirst(Dssp,Chain);

  if( Chain->NRes-1 > 0 && !FindAtom(Chain,Chain->NRes-1,"CA",&CA) ) 
    InsertLast(Dssp,Chain);

  /* Check correspondence of residue types */
  for( Res=0; Res<Chain->NRes; Res++ )
    if( strcmp(Chain->Rsd[Res]->ResType,Dssp->ResType[Res]) )
      return(FAILURE);

  /* If DSSP chain is still longer than PDB chain, shrink it */
  if( Chain->NRes != Dssp->NRes ) 
    Dssp->NRes = Chain->NRes;

  return(SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x47fa(%rip), %rdx      # 0x19de8
leaq 0xc(%rsp), %rcx
xorl %esi, %esi
callq 0x4777
testl %eax, %eax
jne 0x15609
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15692
movl (%r14), %esi
cmpl $0x2, %esi
jl 0x15636
decl %esi
leaq 0x47ce(%rip), %rdx      # 0x19de8
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
callq 0x4777
testl %eax, %eax
jne 0x15636
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15738
movl (%r14), %ebp
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x15674
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rdi
addq $0xa, %rdi
movq 0x408(%rbx), %rax
movq (%rax,%r15,8), %rsi
callq 0x2150
incq %r15
testl %eax, %eax
je 0x15648
xorl %eax, %eax
jmp 0x15685
pushq $0x1
popq %rax
cmpl 0x404(%rbx), %ebp
je 0x15685
movl %ebp, 0x404(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/dssp.c
// Function: InsertFirst
void InsertFirst(DSSP *Dssp, CHAIN *Chain)
{
  int Res;

  for( Res=Dssp->NRes; Res>=1; Res-- ) {
    strcpy(Dssp->ResType[Res],Dssp->ResType[Res-1]);
    strcpy(Dssp->PDB_ResNumb[Res],Dssp->PDB_ResNumb[Res-1]);
    Dssp->SecondStr[Res] = Dssp->SecondStr[Res-1];
  }

  strcpy(Dssp->ResType[0],Chain->Rsd[0]->ResType);
  strcpy(Dssp->PDB_ResNumb[0],Chain->Rsd[0]->PDB_ResNumb);
  Dssp->SecondStr[0] = 'C';
  
  Dssp->NRes++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x404(%rdi), %r15d
movq 0x408(%rbx), %rax
testl %r15d, %r15d
jle 0x156ef
movq -0x8(%rax,%r15,8), %rsi
movq (%rax,%r15,8), %rdi
leaq -0x1(%r15), %r12
callq 0x2070
movq 0x418(%rbx), %rax
movq -0x8(%rax,%r15,8), %rsi
movq (%rax,%r15,8), %rdi
callq 0x2070
movq 0x410(%rbx), %rax
movb -0x1(%rax,%r15), %cl
movb %cl, (%rax,%r15)
movq %r12, %r15
jmp 0x156a7
movq (%rax), %rdi
movq 0x68(%r14), %rax
movq (%rax), %rsi
addq $0xa, %rsi
callq 0x2070
movq 0x418(%rbx), %rax
movq (%rax), %rdi
movq 0x68(%r14), %rax
movq (%rax), %rsi
addq $0x4, %rsi
callq 0x2070
movq 0x410(%rbx), %rax
movb $0x43, (%rax)
incl 0x404(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/outseq.c
// Function: OutSeq
int OutSeq(CHAIN **Chain, int NChain, COMMAND *Cmd)
{
  int Cn, Res;
  FILE *Seq;

  if( (int)strlen(Cmd->SeqFile) == 0 )
    Seq = stdout;
  else 
    if( (Seq = fopen(Cmd->SeqFile,"a")) == NULL )
      die("Error writing sequence file %s\n",Cmd->SeqFile);

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

    if( !Chain[Cn]->Valid )
       continue;

    fprintf(Seq,">%s %c  %d %7.3f\n",
	    Chain[Cn]->File,SpaceToDash(Chain[Cn]->Id),Chain[Cn]->NRes,
	    Chain[Cn]->Resolution);

    for( Res=0; Res<Chain[Cn]->NRes; Res++ ) {
      if( Res%60 == 0 && Res != 0 ) fprintf(Seq,"\n");
      fprintf(Seq,"%c",ThreeToOne(Chain[Cn]->Rsd[Res]->ResType));
    }
    fprintf(Seq,"\n");
  }
  fclose(Seq);
  exit(0);

  return(SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
addq $0x802, %r12            # imm = 0x802
movq %r12, %rdi
callq 0x20b0
testl %eax, %eax
jne 0x159d6
movq 0xa5ff(%rip), %rax      # 0x1ffd0
movq (%rax), %r15
jmp 0x15a01
leaq 0x30e4(%rip), %rsi      # 0x18ac1
movq %r12, %rdi
callq 0x21c0
movq %rax, %r15
testq %rax, %rax
jne 0x15a01
leaq 0x42f9(%rip), %rdi      # 0x19ced
xorl %r15d, %r15d
movq %r12, %rsi
xorl %eax, %eax
callq 0x7c4c
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
movq %rbx, (%rsp)
pushq $0x3c
popq %rbx
pushq $0xa
popq %rbp
cmpq (%rsp), %r12
je 0x15ac0
movq (%r14,%r12,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x15ab8
movq 0x48(%rax), %r13
movsbl 0x40(%rax), %edi
callq 0x4969
movsbl %al, %ecx
movq (%r14,%r12,8), %rax
movl (%rax), %r8d
cvtss2sd 0x50(%rax), %xmm0
movq %r15, %rdi
leaq 0x42bb(%rip), %rsi      # 0x19d0d
movq %r13, %rdx
movb $0x1, %al
callq 0x2160
xorl %r13d, %r13d
movl %r13d, %eax
xorl %edx, %edx
divl %ebx
movq (%r14,%r12,8), %rcx
movslq (%rcx), %rdx
cmpq %rdx, %r13
jge 0x15aae
testq %r13, %r13
je 0x15a8d
imull $-0x3c, %eax, %eax
addl %r13d, %eax
jne 0x15a8d
movl %ebp, %edi
movq %r15, %rsi
callq 0x2110
movq (%r14,%r12,8), %rcx
movq 0x68(%rcx), %rax
movq (%rax,%r13,8), %rdi
addq $0xa, %rdi
callq 0x43b0
movsbl %al, %edi
movq %r15, %rsi
callq 0x2110
incq %r13
jmp 0x15a5f
movl %ebp, %edi
movq %r15, %rsi
callq 0x2110
incq %r12
jmp 0x15a14
movq %r15, %rdi
callq 0x20a0
xorl %edi, %edi
callq 0x2240
nop
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/chkchain.c
// Function: NotValid
int NotValid(CHAIN *Chain, char *Message)
{
  
  fprintf(stderr,"IGNORED %s %c ",Chain->File,SpaceToDash(Chain->Id));
  fprintf(stderr,"(%s)\n",Message);
  Chain->Valid = NO;
  return(FAILURE);
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x9dc0(%rip), %r13      # 0x1fff0
movq (%r13), %r15
movq 0x48(%rdi), %r12
movsbl 0x40(%rdi), %edi
callq 0x4969
movsbl %al, %ecx
leaq 0x3c83(%rip), %rsi      # 0x19ece
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2160
movq (%r13), %rdi
leaq 0x3c7a(%rip), %rsi      # 0x19edd
movq %r14, %rdx
xorl %eax, %eax
callq 0x2160
andl $0x0, 0x58(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/elem.c
// Function: CompareElements
int CompareElements(char *Asn1, char *Asn2, char *Asn3, int Length, 
		   char SecStrType, int *Better, int *Worse)
{

  register int i, j, Count1, Count2;
  int TotalNumber = 0, Beg;

  *Better = 0;
  *Worse = 0;

  Beg = -1;
  
  for( i=0; i<Length; i++ ) {
    if( (Asn1[i] == SecStrType || Asn2[i] == SecStrType || Asn3[i] == SecStrType) &&
	(i == 0 || 
	 ( Asn1[i-1] != SecStrType && Asn2[i-1] != SecStrType && Asn3[i-1] != SecStrType) ) ) {
      TotalNumber++;
      Beg = i;
    }
    else
    if( Beg != -1 && ( i == Length-1 || 
	 ( Asn1[i] != SecStrType && Asn2[i] != SecStrType && Asn3[i] != SecStrType ) ) ) {
      Count1 = Count2 = 0;
      for( j=Beg; j<=i; j++ ) {
	if( (Asn1[j] == SecStrType || Asn2[j] == SecStrType) && Asn1[j] != Asn2[j] ) 
	  Count1++;
	if( (Asn3[j] == SecStrType || Asn2[j] == SecStrType) && Asn3[j] != Asn2[j] ) 
	  Count2++;
      }
      if( Count1 > Count2 ) 
	(*Worse)++;
      else
      if( Count2 > Count1 ) 
	(*Better)++;
      Beg = -1;
    }
  }
  return(TotalNumber);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x38(%rsp), %rax
movq %r9, -0x10(%rsp)
andl $0x0, (%r9)
andl $0x0, (%rax)
leal -0x1(%rcx), %eax
movq %rax, -0x8(%rsp)
xorl %ebx, %ebx
testl %ecx, %ecx
cmovlel %ebx, %ecx
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %r11d, %r14d
cmpq %rcx, %rbx
je 0x16641
movb (%rdi,%rbx), %r15b
cmpb %r8b, %r15b
je 0x16570
cmpb %r8b, (%rsi,%rbx)
je 0x16570
cmpb %r8b, (%rdx,%rbx)
jne 0x1658e
testq %rbx, %rbx
je 0x16602
cmpb %r8b, -0x1(%rbx,%rdi)
je 0x1658e
cmpb %r8b, -0x1(%rsi,%rbx)
je 0x1658e
cmpb %r8b, -0x1(%rdx,%rbx)
jne 0x16602
cmpl $-0x1, %r14d
je 0x16636
cmpq -0x8(%rsp), %rbx
jne 0x16615
movslq %r14d, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq %rbx, %r15
jg 0x16609
movb (%rdi,%r15), %r10b
movb (%rsi,%r15), %r13b
cmpb %r8b, %r10b
jne 0x165bf
movl %r13d, %ebp
jmp 0x165c7
movl %r8d, %ebp
cmpb %r8b, %r13b
jne 0x165d7
xorl %r13d, %r13d
cmpb %bpl, %r10b
setne %r13b
addl %r13d, %r14d
movl %ebp, %r13d
movb (%rdx,%r15), %r10b
cmpb %r8b, %r10b
sete %bpl
cmpb %r8b, %r13b
sete %r9b
orb %bpl, %r9b
cmpb %r13b, %r10b
setne %r10b
andb %r9b, %r10b
movzbl %r10b, %r9d
addl %r9d, %r12d
incq %r15
jmp 0x165a8
incl %eax
movl %ebx, %r14d
jmp 0x16639
cmpl %r12d, %r14d
jle 0x1662c
movq 0x38(%rsp), %r9
jmp 0x16633
cmpb %r8b, %r15b
je 0x16639
cmpb %r8b, (%rsi,%rbx)
je 0x16639
cmpb %r8b, (%rdx,%rbx)
jne 0x1659f
jmp 0x16639
jge 0x16636
movq -0x10(%rsp), %r9
incl (%r9)
movl %r11d, %r14d
incq %rbx
jmp 0x16552
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/asngener.c
// Function: CorrectAsn
void CorrectAsn(char *Asn, int Length, char SecStrType, char EditChar, int MaxLength)
{

  int NStr = 0, Res, Flag = 0, Bound[MAX_ASSIGN][2], i;

  for( Res=0; Res<Length; Res++ ) {
    if( Asn[Res] == SecStrType && Flag == 0 ) {
      Flag = 1; 
      Bound[NStr][0] = Res;
    }
    else
    if( Asn[Res] != SecStrType && Flag == 1 ) {
      Flag = 0; 
      Bound[NStr++][1] = Res-1;
    }
  }

  for( i=0; i<NStr; i++ )
    if( Bound[i][1]-Bound[i][0]+1 <= MaxLength )
      for( Res=Bound[i][0]; Res<=Bound[i][1]; Res++ ) 
	Asn[Res] = EditChar;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xf20, %rsp            # imm = 0xF20
xorl %r9d, %r9d
testl %esi, %esi
cmovlel %r9d, %esi
movl $0x1, %r10d
xorl %eax, %eax
xorl %r11d, %r11d
cmpq %r9, %rsi
je 0x17463
movb (%rdi,%r9), %bpl
cmpb %dl, %bpl
sete %bl
testl %r11d, %r11d
sete %r14b
andb %bl, %r14b
movslq %eax, %rbx
cmpb $0x1, %r14b
jne 0x17437
movl %r9d, -0x80(%rsp,%rbx,8)
movl %r10d, %r11d
jmp 0x1745e
cmpb %dl, %bpl
setne %bpl
cmpl $0x1, %r11d
sete %r14b
andb %bpl, %r14b
cmpb $0x1, %r14b
jne 0x1745e
leal 0x1(%rbx), %eax
leal -0x1(%r9), %r11d
movl %r11d, -0x7c(%rsp,%rbx,8)
xorl %r11d, %r11d
incq %r9
jmp 0x1740b
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rax, %rdx
je 0x17497
movslq -0x7c(%rsp,%rdx,8), %rsi
movslq -0x80(%rsp,%rdx,8), %r9
movl %esi, %r10d
subl %r9d, %r10d
cmpl %r8d, %r10d
jge 0x17492
cmpq %rsi, %r9
jg 0x17492
movb %cl, (%rdi,%r9)
incq %r9
jmp 0x17484
incq %rdx
jmp 0x1746a
addq $0xf20, %rsp            # imm = 0xF20
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/asngener.c
// Function: CorrectAsnDouble
void CorrectAsnDouble(char *Asn1, char *Asn2, char *KnownAsn, int Length, 
		      char SecStrType, char EditChar)
{

  register int Res;

  for( Res=0; Res<Length; Res++ )
    if( (Asn1[Res] == SecStrType || Asn2[Res] == SecStrType) && KnownAsn[Res] != SecStrType &&
        ( (Res == 0 && Asn1[Res+1] != SecStrType && Asn2[Res+1] != SecStrType) ||
	  (Res == Length-1 && Asn1[Res-1] != SecStrType && Asn2[Res-1] != SecStrType) ||
          (Res > 0 && Res < Length-1 && 
	   Asn1[Res-1] != SecStrType && Asn2[Res-1] != SecStrType && 
	   Asn1[Res+1] != SecStrType && Asn2[Res+1] != SecStrType) ) )
      Asn1[Res] = Asn2[Res] = EditChar;
      
}

// Assembly:
pushq %rbp
pushq %rbx
leal -0x1(%rcx), %eax
movslq %eax, %r10
xorl %r11d, %r11d
testl %ecx, %ecx
cmovlel %r11d, %ecx
cmpq %r11, %rcx
je 0x1752a
cmpb %r8b, (%rdi,%r11)
je 0x174c5
cmpb %r8b, (%rsi,%r11)
jne 0x17525
cmpb %r8b, (%rdx,%r11)
je 0x17525
testq %r11, %r11
jne 0x174dc
cmpb %r8b, 0x1(%rdi)
je 0x174dc
cmpb %r8b, 0x1(%rsi)
jne 0x1751d
cmpq %r11, %rax
jne 0x174ef
cmpb %r8b, -0x1(%rdi,%rax)
je 0x174ef
cmpb %r8b, -0x1(%rsi,%rax)
jne 0x1751d
testq %r11, %r11
sete %bl
cmpq %r10, %r11
setge %bpl
orb %bl, %bpl
jne 0x17525
cmpb %r8b, -0x1(%rdi,%r11)
je 0x17525
cmpb %r8b, -0x1(%rsi,%r11)
je 0x17525
cmpb %r8b, 0x1(%rdi,%r11)
je 0x17525
cmpb %r8b, 0x1(%rsi,%r11)
je 0x17525
movb %r9b, (%rsi,%r11)
movb %r9b, (%rdi,%r11)
incq %r11
jmp 0x174b4
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/asngener.c
// Function: Difference
int Difference(char *TestAsn, char *KnownAsn, int Length, char SecStrType, QUALITY *Qual)
{
  register int Res;

  Qual->TP = Qual->TN = Qual->FP = Qual->FN = 0;

  for( Res=0; Res<Length; Res++ ) {
    if( KnownAsn[Res] != 'X' ) { 

      if( KnownAsn[Res] == SecStrType && TestAsn[Res]  == SecStrType ) Qual->TP++;
      else 
      if( KnownAsn[Res] != SecStrType && TestAsn[Res]  != SecStrType ) Qual->TN++;
      else 
      if( KnownAsn[Res] != SecStrType && TestAsn[Res]  == SecStrType ) Qual->FP++;
      else 
      if( KnownAsn[Res] == SecStrType && TestAsn[Res]  != SecStrType ) Qual->FN++;
    }
  }

  if( Qual->TP == 0 && Qual->TN == 0 && Qual->FP == 0 && Qual->FN == 0 )  {
    Qual->Perc = 0.0;
    return(FAILURE);
  }

  Qual->Perc = 
    ((float)Qual->TP+(float)Qual->TN)/
      ((float)Qual->TP+(float)Qual->TN+(float)Qual->FP+(float)Qual->FN);

  return(SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorps %xmm0, %xmm0
movups %xmm0, (%r8)
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %ebx, %ebx
cmpq %rbx, %rdx
je 0x17593
movb (%rsi,%rbx), %r14b
cmpb $0x58, %r14b
jne 0x1755e
incq %rbx
jmp 0x1754a
movb (%rdi,%rbx), %bpl
cmpb %cl, %r14b
jne 0x17573
cmpb %cl, %bpl
jne 0x17581
incl %eax
movl %eax, (%r8)
jmp 0x17559
cmpb %cl, %bpl
jne 0x1758a
incl %r10d
movl %r10d, 0x8(%r8)
jmp 0x17559
incl %r9d
movl %r9d, 0xc(%r8)
jmp 0x17559
incl %r11d
movl %r11d, 0x4(%r8)
jmp 0x17559
testl %eax, %eax
jne 0x175ad
testl %r11d, %r11d
jne 0x175ad
testl %r10d, %r10d
jne 0x175ad
testl %r9d, %r9d
jne 0x175ad
xorl %eax, %eax
xorps %xmm0, %xmm0
jmp 0x175d5
cvtsi2ss %eax, %xmm1
cvtsi2ss %r11d, %xmm0
cvtsi2ss %r10d, %xmm2
addss %xmm1, %xmm0
cvtsi2ss %r9d, %xmm1
addss %xmm0, %xmm2
addss %xmm2, %xmm1
divss %xmm1, %xmm0
movl $0x1, %eax
movss %xmm0, 0x14(%r8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/asngener.c
// Function: PercentCorrect
float PercentCorrect(char *TestAsn, char *KnownAsn, int Length)
{
  int Res, Count=0;;

  for( Res=0; Res<Length; Res++ )
    if( KnownAsn[Res] == TestAsn[Res] )
      Count++;

  return( ((float)Count/(float)Length) );
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
xorl %r8d, %r8d
cmpq %rax, %rcx
je 0x1760b
movb (%rsi,%rax), %r9b
xorl %r10d, %r10d
cmpb (%rdi,%rax), %r9b
sete %r10b
addl %r10d, %r8d
incq %rax
jmp 0x175ef
cvtsi2ss %r8d, %xmm0
cvtsi2ss %edx, %xmm1
divss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/josch[P]stride/asngener.c
// Function: AssessCorr
int AssessCorr(QUALITY *Qual)
{

  float TP, TN, FP, FN;

  if( (Qual->TP == 0 && Qual->FN == 0) || (Qual->TP == 0 && Qual->FP == 0) ) return(FAILURE);
  else {
    TP = (float)Qual->TP; 
    TN = (float)Qual->TN; 
    FP = (float)Qual->FP; 
    FN =(float)Qual->FN;

    Qual->Corr = (TP*TN - FN*FP)/sqrt((TN+FN)*(TN+FP)*(TP+FN)*(TP+FP));

    return(SUCCESS);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x176b1
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
cvtsi2ss %ecx, %xmm0
cvtsi2ssl 0x4(%rbx), %xmm1
cvtsi2ss %esi, %xmm2
cvtsi2ss %edx, %xmm3
movaps %xmm2, %xmm4
mulss %xmm3, %xmm4
movaps %xmm0, %xmm5
mulss %xmm1, %xmm5
subss %xmm4, %xmm5
cvtss2sd %xmm5, %xmm5
movaps %xmm1, %xmm4
addss %xmm3, %xmm4
addss %xmm2, %xmm1
mulss %xmm4, %xmm1
addss %xmm0, %xmm3
mulss %xmm1, %xmm3
addss %xmm2, %xmm0
mulss %xmm3, %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1768a
sqrtsd %xmm0, %xmm0
jmp 0x1769b
movsd %xmm5, 0x8(%rsp)
callq 0x2260
movsd 0x8(%rsp), %xmm5
divsd %xmm0, %xmm5
cvtsd2ss %xmm5, %xmm0
movss %xmm0, 0x10(%rbx)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
movl 0xc(%rbx), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x176ab
movl 0x8(%rbx), %esi
testl %esi, %esi
jne 0x17631
jmp 0x176ab