LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 $0x48, %rsp
movl %ecx, %ebx
movl %edx, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movl %edi, %ebp
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x5e36
leaq 0x13d61(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x5f99
movslq 0x8(%rsp), %rax
leaq (,%rax,8), %rcx
movq %rcx, 0x30(%rsp)
movslq 0xc(%rsp), %rcx
leaq (,%rcx,8), %rdx
movq %rdx, 0x40(%rsp)
movl %ebx, 0x1c(%rsp)
movslq %ebx, %r14
shlq $0x2, %r14
movl %ebp, 0x18(%rsp)
movl %ebp, %edx
movq %rdx, 0x20(%rsp)
movl %eax, %eax
movq %rax, 0x28(%rsp)
movl %ecx, %r13d
xorl %ebx, %ebx
movq 0x30(%rsp), %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5ea4
leaq 0x13cf3(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq 0x10(%rsp), %rax
movq %rbx, 0x38(%rsp)
movq %rbp, (%rax,%rbx,8)
cmpl $0x0, 0x8(%rsp)
jle 0x5f23
xorl %r15d, %r15d
movq 0x40(%rsp), %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5edc
leaq 0x13cbb(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq %r12, (%rbp,%r15,8)
cmpl $0x0, 0xc(%rsp)
jle 0x5f19
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5f08
leaq 0x13c8f(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq (%rbp,%r15,8), %rax
movq %r12, (%rax,%rbx,8)
incq %rbx
cmpq %rbx, %r13
jne 0x5eea
incq %r15
cmpq 0x28(%rsp), %r15
jne 0x5ebc
movq 0x38(%rsp), %rbx
incq %rbx
cmpq 0x20(%rsp), %rbx
jne 0x5e84
cmpl $0x0, 0x18(%rsp)
movl 0x1c(%rsp), %ebp
jle 0x5f99
movl %ebp, %r14d
shlq $0x2, %r14
xorl %r15d, %r15d
cmpl $0x0, 0x8(%rsp)
jle 0x5f8f
xorl %r12d, %r12d
cmpl $0x0, 0xc(%rsp)
jle 0x5f85
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x5f7d
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20f0
incq %rbx
cmpq %rbx, %r13
jne 0x5f5e
incq %r12
cmpq 0x28(%rsp), %r12
jne 0x5f55
incq %r15
cmpq 0x20(%rsp), %r15
jne 0x5f4b
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/memory.c
// Function: CharMatrix
char **CharMatrix(int M, int N)
{
  int m;
  char **Matrix;

  Matrix = (char **)ckalloc(M*sizeof(char *));

  for( m=0; m<M; m++ ) Matrix[m] = (char *)ckalloc(N*sizeof(char));

  return(Matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebp
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, %rbx
testq %rax, %rax
jne 0x600f
leaq 0x13b88(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x6048
movslq %r14d, %r14
movl %ebp, %r13d
leaq 0x13b70(%rip), %r15     # 0x19b90
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x603c
movq %r15, %rdi
xorl %eax, %eax
callq 0x87c8
movq %r12, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x6022
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %esi, %esi
jle 0x60d3
movl %edx, %ebx
movl %esi, %r15d
movl %edx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x60c2
xorl %ebp, %ebp
movq (%r14,%r13,8), %rax
movq (%rax,%rbp,8), %rdi
callq 0x2040
incq %rbp
cmpq %rbp, %r12
jne 0x60ad
movq (%r14,%r13,8), %rdi
callq 0x2040
incq %r13
cmpq %r15, %r13
jne 0x60a7
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %esi, %esi
jle 0x6132
movl %edx, %ebx
movl %esi, %r15d
movl %edx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x6121
xorl %ebp, %ebp
movq (%r14,%r13,8), %rax
movq (%rax,%rbp,8), %rdi
callq 0x2040
incq %rbp
cmpq %rbp, %r12
jne 0x610c
movq (%r14,%r13,8), %rdi
callq 0x2040
incq %r13
cmpq %r15, %r13
jne 0x6106
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x80d9
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
cmpl $0x0, (%rdi)
jle 0x80c7
xorl %ebp, %ebp
movl %ebp, %esi
callq 0x4209
movq (%rbx,%r15,8), %rdi
movl %ebp, %esi
callq 0x4376
incl %ebp
movq (%rbx,%r15,8), %rdi
cmpl (%rdi), %ebp
jl 0x80ab
incq %r15
cmpq %r14, %r15
jne 0x80a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x1, %eax
cmpl $0x3, %esi
jl 0x8336
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal -0x1(%rsi), %eax
movq %rax, (%rsp)
movl %esi, %r13d
movl $0x1, %ebp
movq %rdi, %r14
movq (%rbx,%rbp,8), %r15
cmpb $0x2d, (%r15)
jne 0x830f
movl $0x2, %r12d
movq (%r14,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x8307
movq %r15, %rdi
callq 0x2150
testl %eax, %eax
je 0x8326
incq %r12
cmpq %r12, %r13
jne 0x82f2
incq %rbp
addq $0x8, %r14
decq %r13
cmpq (%rsp), %rbp
jne 0x82e2
movl $0x1, %eax
jmp 0x8328
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpl $0x2, %esi
jl 0x83a5
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %r13d
movl $0x1, %r12d
movq (%r15,%r12,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x8398
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0x83a2
incq %r12
cmpq %r12, %r13
jne 0x8383
jmp 0x83a5
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
xorl %r15d, %r15d
cmpl $0x2, %esi
jl 0x841d
movl %edx, %ebp
movq %rdi, %r14
movl %esi, %r13d
xorl %r15d, %r15d
movl $0x1, %ebx
movq (%r14,%rbx,8), %r12
cmpb $0x2d, (%r12)
jne 0x8415
callq 0x2290
movq (%rax), %rax
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x8415
addq $0x2, %r12
movq %r12, %rdi
callq 0x21f0
cmpl %ebp, %eax
jne 0x8415
movslq %r15d, %rax
incl %r15d
movq (%rsp), %rcx
movl %ebx, (%rcx,%rax,4)
incq %rbx
cmpq %rbx, %r13
jne 0x83d8
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x8826
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 0x187a3(%rip), %rax     # 0x20ff0
movq (%rax), %rdi
movq %r10, %rsi
callq 0x21c0
movl $0x1, %edi
callq 0x2230
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x16d1d(%rip), %r14     # 0x20fd0
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 0xfd30(%rip), %rsi      # 0x1a02f
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 0xfd38(%rip), %rsi      # 0x1a05c
movb $0x1, %al
callq 0x2160
cmpl $0x0, 0x10(%rbx)
movq (%r14), %rcx
je 0xa34f
xorps %xmm0, %xmm0
cvtss2sd 0x1c(%rbx), %xmm0
leaq 0xfd1a(%rip), %rsi      # 0x1a05d
movq %rcx, %rdi
movb $0x1, %al
callq 0x2160
jmp 0xa365
leaq 0xfd0e(%rip), %rdi      # 0x1a064
movl $0x8, %esi
movl $0x1, %edx
callq 0x2240
cmpl $0x0, 0x14(%rbx)
movq (%r14), %rcx
je 0xa37c
leaq 0xfcf8(%rip), %rdi      # 0x1a06d
movl $0x4, %esi
jmp 0xa388
leaq 0xfcef(%rip), %rdi      # 0x1a072
movl $0x3, %esi
movl $0x1, %edx
callq 0x2240
cmpl $0x0, 0x18(%rbx)
movq (%r14), %rcx
je 0xa3a9
leaq 0xfcd4(%rip), %rdi      # 0x1a076
movl $0x4, %esi
jmp 0xa3b5
leaq 0xfccb(%rip), %rdi      # 0x1a07b
movl $0x3, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0xa430
movq 0x770(%rdx), %rdx
movl 0x34(%rdx), %r8d
testq %r8, %r8
je 0xa430
testl %esi, %esi
jle 0xa430
xorl %r9d, %r9d
testl %r8d, %r8d
jle 0xa423
movl (%rcx,%r9,4), %r10d
movslq %r10d, %r11
xorl %ebx, %ebx
cmpl 0x18(%rdx,%rbx,4), %r10d
jne 0xa41b
movq (%rdi,%r11,8), %r14
cmpl $0x0, 0x10(%r14)
jne 0xa42d
incq %rbx
cmpq %rbx, %r8
jne 0xa409
incq %r9
cmpq %rsi, %r9
jne 0xa3fb
jmp 0xa430
movl %r10d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0xa497
movq 0x770(%rdx), %rdx
movl 0x34(%rdx), %r8d
testq %r8, %r8
je 0xa497
testl %esi, %esi
jle 0xa497
xorl %r9d, %r9d
testl %r8d, %r8d
jle 0xa48a
movl (%rcx,%r9,4), %r10d
movslq %r10d, %r11
xorl %ebx, %ebx
cmpl 0x18(%rdx,%rbx,4), %r10d
jne 0xa482
movq (%rdi,%r11,8), %r14
cmpl $0x0, 0x14(%r14)
jne 0xa494
incq %rbx
cmpq %rbx, %r8
jne 0xa470
incq %r9
cmpq %rsi, %r9
jne 0xa462
jmp 0xa497
movl %r10d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $0x2, %esi
jl 0xa565
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leal -0x1(%rsi), %ecx
movl %esi, %edx
xorl %esi, %esi
movsd 0xfa89(%rip), %xmm0     # 0x19f48
movq %rdi, %r8
xorl %eax, %eax
movq (%rdi,%rsi,8), %r9
incq %rsi
movq (%r9), %r10
movl 0x8(%r10), %r11d
leaq 0x10(%r9), %rbx
movl $0x1, %r14d
movq (%r8,%r14,8), %r15
movq (%r15), %r12
cmpl 0x8(%r12), %r11d
jne 0xa543
movq (%r10), %r13
movb 0x40(%r13), %bpl
movq (%r12), %r12
cmpb 0x40(%r12), %bpl
jne 0xa543
cmpl $0x0, (%rbx)
je 0xa543
cmpl $0x0, 0x10(%r15)
je 0xa543
xorps %xmm1, %xmm1
cvtss2sd 0x1c(%r9), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x1c(%r15), %xmm2
movaps %xmm2, %xmm3
mulsd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0xa52d
addq $0x10, %r15
jmp 0xa53a
mulsd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
movq %rbx, %r15
jbe 0xa543
movl $0x0, (%r15)
incl %eax
incq %r14
cmpq %r14, %rdx
jne 0xa4dc
addq $0x8, %r8
decq %rdx
cmpq %rcx, %rsi
jne 0xa4c4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xb5b9
movl 0x20(%rsp), %ebx
cmpl %ecx, %ebx
jg 0xb5b9
cmpl %r9d, %ecx
jg 0xb5b9
cmpl %edx, %ecx
jg 0xb5b9
cmpl %esi, %edi
jl 0xb5b9
cmpl %r8d, %esi
jl 0xb5b9
movl 0x18(%rsp), %ebp
cmpl %edi, %ebp
jl 0xb5b9
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 0xb5b9
testl %esi, %esi
js 0xb5b9
testl %r11d, %r11d
js 0xb5b9
testl %r9d, %r9d
js 0xb5b9
cmpl $0x3, %r10d
setb %cl
cmpl $0x6, %esi
setb %dl
testb %dl, %cl
jne 0xb594
cmpl $0x6, %r10d
setb %cl
cmpl $0x3, %esi
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xb5b9
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_O3/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
movl $0x1, %eax
orl %r10d, %r11d
je 0xb5e0
cmpl %edx, %edi
jg 0xb5e1
cmpl %r9d, %edx
jge 0xb5e1
cmpl %r9d, %edi
jg 0xb5e1
retq
cmpl %edx, %edi
jl 0xb5ef
cmpl %r9d, %edx
jle 0xb5ef
cmpl %r9d, %edi
jge 0xb5e0
cmpl %ecx, %esi
jg 0xb5fd
cmpl %r8d, %ecx
jge 0xb5fd
cmpl %r8d, %esi
jle 0xb5e0
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_O3/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:
movl 0x8(%rsp), %r10d
movl $0x1, %eax
cmpl %r10d, %ecx
jg 0xb665
cmpl %r9d, %ecx
jg 0xb665
cmpl %r9d, %r10d
jge 0xb665
retq
cmpl %r10d, %ecx
jl 0xb674
cmpl %r9d, %ecx
jl 0xb674
cmpl %r9d, %r10d
jg 0xb664
movl 0x10(%rsp), %r11d
cmpl %r11d, %ecx
jg 0xb688
cmpl %r8d, %edx
jg 0xb688
cmpl %r8d, %r11d
jl 0xb664
cmpl %r11d, %edx
jl 0xb697
cmpl %r8d, %edx
jl 0xb697
cmpl %r8d, %r11d
jg 0xb664
xorl %r10d, %r9d
xorl %r11d, %r8d
xorl %eax, %eax
orl %r9d, %r8d
jne 0xb664
cmpl $-0x1, %edi
je 0xb6d1
cmpl %r10d, %ecx
jl 0xb6bd
cmpl %r10d, %esi
jl 0xb6bd
cmpl %r11d, %edx
jg 0xb6bd
cmpl %r11d, %edi
jle 0xb664
cmpl %r10d, %ecx
jg 0xb6d1
cmpl %r11d, %edx
jl 0xb6d1
cmpl %r10d, %esi
jg 0xb6d1
cmpl %r11d, %edi
jge 0xb664
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %eax
orl %r10d, %r11d
je 0xc7b1
cmpl %ecx, %esi
jg 0xc7b2
cmpl %r8d, %esi
jg 0xc7b2
cmpl %r8d, %ecx
jg 0xc7b2
cmpl %edx, %edi
jg 0xc7b2
cmpl %r9d, %edx
jge 0xc7b2
cmpl %r9d, %edi
jge 0xc7b2
retq
cmpl %ecx, %esi
jl 0xc7ce
cmpl %r8d, %esi
jl 0xc7ce
cmpl %r8d, %ecx
jl 0xc7ce
cmpl %edx, %edi
jl 0xc7ce
cmpl %r9d, %edx
jle 0xc7ce
cmpl %r9d, %edi
jg 0xc7b1
cmpl %edx, %edi
jg 0xc7ea
cmpl %r9d, %edi
jg 0xc7ea
cmpl %r9d, %edx
jg 0xc7ea
cmpl %ecx, %esi
jg 0xc7ea
cmpl %r8d, %ecx
jge 0xc7ea
cmpl %r8d, %esi
jl 0xc7b1
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
movq %r14, %rsi
movl $0xa, %edx
callq 0x36c4
movq 0x8(%r14), %rax
cmpb $0x52, (%rax)
jne 0xee16
cmpb $0x45, 0x1(%rax)
jne 0xee16
cmpb $0x46, 0x2(%rax)
jne 0xee16
movq 0x10(%rsp), %rax
cmpb $0x54, (%rax)
jne 0xee16
cmpb $0x4f, 0x1(%rax)
jne 0xee16
movq 0x18(%rsp), %rax
cmpb $0x42, (%rax)
jne 0xee16
cmpb $0x45, 0x1(%rax)
jne 0xee16
movq 0x20(%rsp), %rdi
leaq 0xb2cc(%rip), %rsi      # 0x1a0ce
movl $0x9, %edx
callq 0x2060
testl %eax, %eax
jne 0xee16
movl $0x0, (%rbx)
movl $0x1, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5a8, %rsp            # imm = 0x5A8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x1cf8(%rcx)
je 0xfe36
movq %rcx, %r12
addq $0x1c08, %r12           # imm = 0x1C08
movsbl 0xf(%rbx), %edi
callq 0x50a2
movsbl %al, %esi
movq %r12, %rdi
callq 0x50af
testl %eax, %eax
je 0xff15
cmpl $0x0, (%r15)
je 0xfe41
movq (%r14), %rax
jmp 0xfe55
movq %r14, %rdi
callq 0x3d9c
movb 0xf(%rbx), %cl
movq (%r14), %rax
movb %cl, 0x40(%rax)
incl (%r15)
movslq 0x2c(%rax), %r12
movl $0x14, %edi
callq 0x5880
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
movq %r15, %rsi
movl $0x1, %edx
callq 0x36c4
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 $0x1, %edx
callq 0x36c4
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)
movl $0x1, %eax
addq $0x5a8, %rsp            # imm = 0x5A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
movl $0xa, %edx
callq 0x36c4
testl %eax, %eax
jle 0xffaf
movl %eax, %ebp
xorl %r12d, %r12d
leaq 0x98da(%rip), %r14      # 0x19837
movq (%rsp,%r12,8), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xff9e
movq %r13, %rdi
leaq 0xa199(%rip), %rsi      # 0x1a113
callq 0x2150
movl $0x1, %r15d
testl %eax, %eax
je 0xffa4
movq %r13, %rdi
leaq 0xa184(%rip), %rsi      # 0x1a117
callq 0x2150
testl %eax, %eax
jne 0xffa7
jmp 0xffa4
movl $0x2, %r15d
movl %r15d, (%rbx)
incq %r12
cmpq %r12, %rbp
jne 0xff5d
movl $0x1, %eax
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_O3/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 0xa126(%rip), %rsi      # 0x1a113
callq 0x2270
testq %rax, %rax
je 0xfffd
movl $0x1, (%rbx)
leaq 0x9833(%rip), %rsi      # 0x19837
movq %r14, %rdi
callq 0x2270
testq %rax, %rax
je 0x1001c
cmpl $0x0, (%rbx)
jne 0x1001c
movl $0x2, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1007f
leaq 0x401(%rbx), %r13
leaq 0x9d5f(%rip), %rsi      # 0x19db8
movq %r13, %rdi
callq 0x21b0
movq %rax, %r15
testq %rax, %rax
jne 0x10089
leaq 0xa170(%rip), %rdi      # 0x1a1e0
xorl %r15d, %r15d
movq %r13, %rsi
xorl %eax, %eax
callq 0x87c8
jmp 0x10089
movq 0x10f4a(%rip), %rax     # 0x20fd0
movq (%rax), %r15
cmpl $0x0, 0x1d6c(%rbx)
jne 0x1009d
movq %r14, %rdi
movq %r15, %rsi
callq 0x10162
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1035f
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1078d
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x109e9
movq %r14, %rdi
movq %r15, %rsi
callq 0x10b78
cmpl $0x0, 0x1d6c(%rbx)
jne 0x100e8
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x10c9d
cmpl $0x0, 0x1d70(%rbx)
je 0x10101
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x10f49
cmpl $0x0, 0x1d88(%rbx)
je 0x10131
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x16d10
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x16d10
movq 0x10e98(%rip), %rax     # 0x20fd0
cmpq (%rax), %r15
je 0x10153
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_O3/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:
testl %esi, %esi
jle 0x10b77
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x848, %rsp            # imm = 0x848
movq %rdx, %rbp
movl %esi, %ebx
movq %rdi, %r12
movl %esi, %r14d
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r12,%rax,8), %rdx
cmpl $0x0, 0x58(%rdx)
je 0x10a1e
addl 0x28(%rdx), %ecx
incq %rax
cmpq %rax, %r14
jne 0x10a11
testl %ecx, %ecx
je 0x10b66
movaps 0x979b(%rip), %xmm0     # 0x1a1d0
leaq 0x7b(%rsp), %r15
movaps %xmm0, -0xb(%r15)
movaps %xmm0, -0x1b(%r15)
movaps %xmm0, -0x2b(%r15)
movaps %xmm0, -0x3b(%r15)
movaps %xmm0, -0x4b(%r15)
movl $0xb0, %esi
addq (%r12), %rsi
movq %r15, %rdi
callq 0x2070
movw $0xa, 0x4(%r15)
testl %ebx, %ebx
jle 0x10b66
leaq 0x440(%rsp), %r15
xorl %ebx, %ebx
movq %r14, (%rsp)
movq %rbp, 0x8(%rsp)
movq (%r12,%rbx,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x10b56
cmpl $0x0, 0x28(%rax)
jle 0x10b56
xorl %r14d, %r14d
movq 0x98(%rax), %rax
movq (%rax,%r14,8), %rbp
movsbl 0x1a(%rbp), %edi
callq 0x4fec
movq %rax, 0x20(%rsp)
leaq 0xc(%rbp), %rax
movq %rax, 0x28(%rsp)
movq (%r12,%rbx,8), %rax
movsbl 0x40(%rax), %edi
callq 0x50a2
movsbl %al, %r13d
leaq 0x6(%rbp), %rax
movq %rax, 0x18(%rsp)
leaq 0x12(%rbp), %rax
movq %rax, 0x10(%rsp)
movq (%r12,%rbx,8), %rax
movsbl 0x40(%rax), %edi
callq 0x50a2
movsbl %al, %r10d
subq $0x8, %rsp
movq %r15, %rdi
leaq 0x9c37(%rip), %rsi      # 0x1a73c
movq 0x28(%rsp), %rdx
movq %rbp, %rcx
movq 0x30(%rsp), %r8
movl %r13d, %r9d
movq 0x10(%rsp), %rbp
leaq 0x38(%rsp), %r13
xorl %eax, %eax
pushq %r10
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0x2220
addq $0x20, %rsp
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x114b3
incq %r14
movq (%r12,%rbx,8), %rax
movslq 0x28(%rax), %rcx
cmpq %rcx, %r14
jl 0x10aa1
incq %rbx
movq (%rsp), %r14
cmpq %r14, %rbx
jne 0x10a86
addq $0x848, %rsp            # imm = 0x848
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r13
movl 0x2c(%r13), %ebx
testl %ebx, %ebx
je 0x10c8b
movq %rdi, %r14
movaps 0x9629(%rip), %xmm0     # 0x1a1d0
leaq 0x46b(%rsp), %r15
movaps %xmm0, -0xb(%r15)
movaps %xmm0, -0x1b(%r15)
movaps %xmm0, -0x2b(%r15)
movaps %xmm0, -0x3b(%r15)
movaps %xmm0, -0x4b(%r15)
leaq 0xb0(%r13), %rsi
movq %r15, %rdi
callq 0x2070
movw $0xa, 0x4(%r15)
testl %ebx, %ebx
jle 0x10c8b
leaq 0x10(%rsp), %r12
xorl %ebx, %ebx
movq 0xa0(%r13), %rax
movq (%rax,%rbx,8), %rbp
movsbl 0xe(%rbp), %edi
callq 0x50a2
movsbl %al, %r15d
leaq 0x6(%rbp), %r13
movsbl 0xf(%rbp), %edi
callq 0x50a2
movsbl %al, %r9d
movq %r12, %rdi
leaq 0x9adc(%rip), %rsi      # 0x1a6fc
movq %rbp, %rdx
movl %r15d, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x2220
movl 0x10(%rbp), %ebp
movq %r12, %rdi
callq 0x20b0
addq %rsp, %rax
addq $0x10, %rax
cmpl $0x1, %ebp
jne 0x10c56
movl $0x424450, 0x3(%rax)    # imm = 0x424450
movl $0x50202020, (%rax)     # imm = 0x50202020
jmp 0x10c63
movabsq $0xa454449525453, %rcx  # imm = 0xA454449525453
movq %rcx, (%rax)
leaq 0x420(%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x114b3
incq %rbx
movq (%r14), %r13
movslq 0x2c(%r13), %rax
cmpq %rax, %rbx
jl 0x10bed
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x83b4(%rip), %xmm1     # 0x198c0
andpd %xmm0, %xmm1
movsd 0x8350(%rip), %xmm2     # 0x19868
ucomisd %xmm1, %xmm2
ja 0x2210
addsd 0x832e(%rip), %xmm1     # 0x19858
movsd 0x9336(%rip), %xmm2     # 0x1a868
ucomisd %xmm1, %xmm2
jbe 0x11541
movsd 0x9320(%rip), %xmm0     # 0x1a860
retq
pushq %rax
leaq 0x9400(%rip), %rax      # 0x1a949
movq %rax, 0x110f0(%rip)     # 0x22640
movl $0x61, 0x110de(%rip)    # 0x22638
leaq 0x93ee(%rip), %rdi      # 0x1a94f
movb $0x1, %al
callq 0x24b8
xorpd %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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
je 0x11597
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x93ab(%rip), %rax      # 0x1a949
movq %rax, 0x1109b(%rip)     # 0x22640
movl $0x6b, 0x11089(%rip)    # 0x22638
leaq 0x93b4(%rip), %rdi      # 0x1a96a
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x24b8
jmp 0x1158e
// File: /workspace/github_c_makefile_star2_O3/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 0x21a0
movq %rax, %r14
testq %rax, %rax
je 0x115ea
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9358(%rip), %rax      # 0x1a949
movq %rax, 0x11048(%rip)     # 0x22640
movl $0x75, 0x11036(%rip)    # 0x22638
leaq 0x9387(%rip), %rdi      # 0x1a990
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x24b8
jmp 0x115e1
// File: /workspace/github_c_makefile_star2_O3/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, 0x11020(%rip)     # 0x22648
movabsq $0x3fdc9f257bd2e79a, %rax # imm = 0x3FDC9F257BD2E79A
movq %rax, 0x11017(%rip)     # 0x22650
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movaps 0x915a(%rip), %xmm1     # 0x1a7a0
movups %xmm1, 0x10(%rdi)
movabsq $0x3feb388821fab2fd, %rcx # imm = 0x3FEB388821FAB2FD
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movaps 0x914d(%rip), %xmm1     # 0x1a7b0
movups %xmm1, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movaps 0x914e(%rip), %xmm1     # 0x1a7c0
movups %xmm1, 0x48(%rdi)
movq %rax, 0x58(%rdi)
movaps 0x914f(%rip), %xmm1     # 0x1a7d0
movups %xmm1, 0x60(%rdi)
movq %rax, 0x70(%rdi)
movsd 0x91df(%rip), %xmm1     # 0x1a870
movups %xmm1, 0x78(%rdi)
movq %rax, 0x88(%rdi)
movaps 0x913d(%rip), %xmm1     # 0x1a7e0
movups %xmm1, 0x90(%rdi)
movabsq $-0x402360da842d1866, %rax # imm = 0xBFDC9F257BD2E79A
movq %rax, 0xa0(%rdi)
movaps 0x912e(%rip), %xmm1     # 0x1a7f0
movups %xmm1, 0xa8(%rdi)
movq %rax, 0xb8(%rdi)
movsd 0x91a0(%rip), %xmm1     # 0x1a878
movups %xmm1, 0xc0(%rdi)
movq %rax, 0xd0(%rdi)
movaps 0x9113(%rip), %xmm1     # 0x1a800
movups %xmm1, 0xd8(%rdi)
movq %rax, 0xe8(%rdi)
movaps 0x910e(%rip), %xmm1     # 0x1a810
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_O3/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
movl %ecx, (%rsp)
movl %edx, 0x4(%rsp)
movq (%rdi), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x14d21
movq %r9, %rbx
movq %r8, %r14
movl %esi, %r12d
movq %rdi, %r13
xorl %r15d, %r15d
movq 0xa0(%rax), %rax
movq (%rax,%r15,8), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2150
testl %eax, %eax
jne 0x14cc5
leaq 0x6(%rbp), %rsi
movq %rbx, %rdi
callq 0x2150
testl %eax, %eax
jne 0x14cc5
movsbl 0xe(%rbp), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x4f77
cmpl 0x4(%rsp), %eax
jne 0x14cc5
movsbl 0xf(%rbp), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x4f77
cmpl (%rsp), %eax
je 0x14d32
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2150
testl %eax, %eax
jne 0x14d0d
leaq 0x6(%rbp), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
jne 0x14d0d
movsbl 0xe(%rbp), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x4f77
cmpl (%rsp), %eax
jne 0x14d0d
movsbl 0xf(%rbp), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x4f77
cmpl 0x4(%rsp), %eax
je 0x14d32
incq %r15
movq (%r13), %rax
movslq 0x2c(%rax), %rcx
cmpq %rcx, %r15
jl 0x14c72
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x14d23
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
jb 0x15295
movaps %xmm1, %xmm10
addss %xmm8, %xmm10
ucomiss %xmm0, %xmm10
jb 0x15295
movaps %xmm3, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm2
jb 0x15295
movaps %xmm3, %xmm10
addss %xmm9, %xmm10
ucomiss %xmm2, %xmm10
jb 0x15295
movaps %xmm5, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm4
jb 0x15295
movaps %xmm5, %xmm10
addss %xmm9, %xmm10
ucomiss %xmm4, %xmm10
jb 0x15295
movaps %xmm7, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm6
jb 0x15295
movaps %xmm7, %xmm10
addss %xmm9, %xmm10
movl $0x1, %eax
ucomiss %xmm6, %xmm10
jb 0x15295
retq
movaps %xmm1, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm0
jb 0x15394
addss %xmm9, %xmm1
ucomiss %xmm0, %xmm1
jb 0x15394
movaps %xmm3, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm2
jb 0x15309
movaps %xmm3, %xmm0
addss %xmm8, %xmm0
ucomiss %xmm2, %xmm0
jb 0x15309
movaps %xmm5, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm4
jb 0x15309
movaps %xmm5, %xmm0
addss %xmm9, %xmm0
ucomiss %xmm4, %xmm0
jb 0x15309
movaps %xmm7, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm6
jb 0x15309
movaps %xmm7, %xmm0
addss %xmm9, %xmm0
movl $0x1, %eax
ucomiss %xmm6, %xmm0
jae 0x15294
movaps %xmm3, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm2
jb 0x15394
addss %xmm9, %xmm3
ucomiss %xmm2, %xmm3
jb 0x15394
movaps %xmm5, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm4
jb 0x1535d
movaps %xmm5, %xmm0
addss %xmm8, %xmm0
ucomiss %xmm4, %xmm0
jb 0x1535d
movaps %xmm7, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm6
jb 0x1535d
movaps %xmm7, %xmm0
addss %xmm9, %xmm0
movl $0x1, %eax
ucomiss %xmm6, %xmm0
jae 0x15294
movaps %xmm5, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm4
jb 0x15394
addss %xmm9, %xmm5
ucomiss %xmm4, %xmm5
jb 0x15394
movaps %xmm7, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm6
jb 0x15394
addss %xmm8, %xmm7
movl $0x1, %eax
ucomiss %xmm6, %xmm7
jae 0x15294
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x529a(%rip), %rdx      # 0x1ae38
leaq 0xc(%rsp), %rcx
xorl %esi, %esi
callq 0x4ea0
testl %eax, %eax
jne 0x15bb9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15c54
movl (%r14), %ebp
cmpl $0x2, %ebp
movq %rbx, 0x10(%rsp)
jl 0x15bf0
decl %ebp
leaq 0x5269(%rip), %rdx      # 0x1ae38
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x4ea0
testl %eax, %eax
jne 0x15bed
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15cfe
movl (%r14), %ebp
testl %ebp, %ebp
jle 0x15c29
movq 0x68(%r14), %r15
movq 0x10(%rsp), %rax
movq 0x408(%rax), %r12
movl %ebp, %r13d
xorl %r14d, %r14d
xorl %ebx, %ebx
movq (%r15,%rbx,8), %rdi
addq $0xa, %rdi
movq (%r12,%rbx,8), %rsi
callq 0x2150
testl %eax, %eax
jne 0x15c42
incq %rbx
cmpq %rbx, %r13
jne 0x15c0c
movl $0x1, %r14d
movq 0x10(%rsp), %rax
cmpl 0x404(%rax), %ebp
je 0x15c42
movl %ebp, 0x404(%rax)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x404(%rdi), %r15
testq %r15, %r15
jle 0x15cb4
incq %r15
movq 0x408(%rbx), %rax
movq -0x10(%rax,%r15,8), %rsi
movq -0x8(%rax,%r15,8), %rdi
callq 0x2070
movq 0x418(%rbx), %rax
movq -0x10(%rax,%r15,8), %rsi
movq -0x8(%rax,%r15,8), %rdi
callq 0x2070
movq 0x410(%rbx), %rax
movb -0x2(%rax,%r15), %cl
movb %cl, -0x1(%rax,%r15)
decq %r15
cmpq $0x1, %r15
ja 0x15c6e
movq 0x408(%rbx), %rax
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)
popq %rbx
popq %r14
popq %r15
retq