LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/strutil.c
// Function: ChInStr
BOOLEAN ChInStr(char *String, char Char)
{

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

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movsbl 0x17(%rsp), %edi
callq 0x2070
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x20c0
cmpq $0x0, %rax
jne 0x65ef
movq 0x18(%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0x20c0
cmpq $0x0, %rax
jne 0x65ef
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movsbl 0x17(%rsp), %edi
callq 0x2150
movq (%rsp), %rdi
movl %eax, %esi
callq 0x20c0
cmpq $0x0, %rax
je 0x65f9
movl $0x1, 0x24(%rsp)
jmp 0x6601
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/strutil.c
// Function: ExistsSecStr
BOOLEAN ExistsSecStr(CHAIN **Chain, int NChain)
{
  register int i, Cn;
  
  for( Cn=0; Cn<NChain; Cn++ )
    for( i=0; i<Chain[Cn]->NRes; i++ )
      if( Chain[Cn]->Rsd[i]->Prop->Asn != 'C' )
	return(YES);

  return(NO);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x67ec
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x10(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0x67dd
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x68(%rax), %rax
movslq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x768(%rax), %rax
movsbl 0x1c(%rax), %eax
cmpl $0x43, %eax
je 0x67ce
movl $0x1, -0x4(%rsp)
jmp 0x67f4
jmp 0x67d0
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x6783
jmp 0x67df
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x6771
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/strutil.c
// Function: SecStrContent
float SecStrContent(CHAIN *Chain, int *HelAlp, int *HelPI, int *Hel310, int *Sheet, int *Turn)
{

  int Res;
  float Content = 0.0;

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

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

  return(Content);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rsp)
movq -0x10(%rsp), %rax
movl $0x0, (%rax)
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movq -0x20(%rsp), %rax
movl $0x0, (%rax)
movq -0x28(%rsp), %rax
movl $0x0, (%rax)
movq -0x30(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x690e
movq -0x8(%rsp), %rax
movq 0x68(%rax), %rax
movslq -0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x768(%rax), %rax
movsbl 0x1d(%rax), %eax
addl $-0x45, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rsp)
subl $0xf, %eax
ja 0x68fc
movq -0x40(%rsp), %rax
leaq 0x25105(%rip), %rcx     # 0x2b9b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x68fc
movq -0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x68fc
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x68fc
movq -0x28(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x68fc
movq -0x30(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x68fe
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x6866
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
addl (%rcx), %eax
movq -0x20(%rsp), %rcx
addl (%rcx), %eax
movq -0x28(%rsp), %rcx
addl (%rcx), %eax
movq -0x30(%rsp), %rcx
addl (%rcx), %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rsp), %rax
cvtsi2ssl (%rax), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x38(%rsp)
movss -0x38(%rsp), %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/memory.c
// Function: FloatCube
float ***FloatCube(int M, int N, int K)
{
  int m, n, k;
  float ***Cube;

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

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

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

  return(Cube);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movslq 0x24(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x74ba
movslq 0x20(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x74ab
movslq 0x1c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x7360
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x746c
jmp 0x74ad
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x743b
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x753f
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x7530
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x7521
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x74e6
jmp 0x7523
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x74d4
jmp 0x7532
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x74c2
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/memory.c
// Function: Float4Dim
float ****Float4Dim(int M, int N, int K, int L)
{
  int m, n, k, l;
  float ****FourDim;

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


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

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

  return(FourDim);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movslq 0x24(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x765a
movslq 0x20(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x7648
movslq 0x1c(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x7636
movslq 0x18(%rsp), %rdi
shlq $0x2, %rdi
callq 0x7360
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x75ef
jmp 0x7638
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x75b2
jmp 0x764a
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x757e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x7712
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x7700
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x76ee
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x76df
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x769c
jmp 0x76e1
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x768a
jmp 0x76f0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7678
jmp 0x7702
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x7662
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/memory.c
// Function: IntCube
int ***IntCube(int M, int N, int K)
{
  int m, n, k;
  int ***Cube;

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

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

  return(Cube);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movslq 0x24(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x781a
movslq 0x20(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x780b
movslq 0x1c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x7360
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x77cc
jmp 0x780d
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x779b
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x789e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x788f
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x7880
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7846
jmp 0x7882
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x7834
jmp 0x7891
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x7822
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movslq 0x24(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x7a2a
movslq 0x20(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x7a18
movslq 0x1c(%rsp), %rdi
shlq $0x3, %rdi
callq 0x7360
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x7a06
movslq 0x18(%rsp), %rdi
shlq $0x2, %rdi
callq 0x7360
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x79bf
jmp 0x7a08
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7982
jmp 0x7a1a
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x794e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x7ae1
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x7acf
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x7abd
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x7aae
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x7a6c
jmp 0x7ab0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7a5a
jmp 0x7abf
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7a48
jmp 0x7ad1
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x7a32
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x7c79
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x7c59
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x7c2a
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x7c19
movq 0x10(%rsp), %rdi
callq 0x2030
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x7d09
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x7ce9
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x7cba
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x7ca9
movq 0x10(%rsp), %rdi
callq 0x2030
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xbcf7
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0xbce8
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x8(%rsp), %esi
callq 0x4d20
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x8(%rsp), %esi
callq 0x4ee0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xbc97
jmp 0xbcea
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xbc85
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/command.c
// Function: efopen
FILE *efopen(char *file, char *mode, char *progname)    /* fopen file, die if can't */
{
  FILE *fp;
  
  if( (fp=fopen(file,mode)) ) 
    return fp;
  else 
    die("%s: can't open file %s mode %s\n",progname,file,mode);
  return(FAILURE);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2190
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xc0b7
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xc0dd
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x1fbfb(%rip), %rdi     # 0x2bcc8
movb $0x0, %al
callq 0xc970
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc1ae
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xc130
jmp 0xc19e
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xc19c
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xc15d
jmp 0xc18f
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0xc18d
movl $0x0, 0x24(%rsp)
jmp 0xc1b6
jmp 0xc18f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xc13b
jmp 0xc19e
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xc105
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/command.c
// Function: Specified
BOOLEAN Specified(char **List, int ListLength, char Option)
{
    int i;

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

    return(NO);
}

// Assembly:
movb %dl, %al
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movb %al, -0x15(%rsp)
movl $0x1, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0xc22b
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xc21c
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
movsbl -0x15(%rsp), %ecx
cmpl %ecx, %eax
jne 0xc21c
movl $0x1, -0x4(%rsp)
jmp 0xc233
jmp 0xc21e
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xc1d7
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xc2b2
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xc27c
jmp 0xc2a5
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0xc2a3
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xc2ba
jmp 0xc2a5
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc25a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0xc390
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xc37e
callq 0x2250
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xc37e
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x2, %rdi
callq 0x21d0
cmpl 0x18(%rsp), %eax
jne 0xc37e
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rsp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xc380
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xc2f6
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
testb %al, %al
je 0xc9ac
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x235fc(%rip), %rax     # 0x2fff8
movq (%rax), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x21a0
movl $0x1, %edi
callq 0x2210
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x770(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x20(%rsp), %rax
movq 0x770(%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x10941
movq -0x40(%rsp), %rax
cmpl $0x0, 0x34(%rax)
je 0x10941
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
movq -0x38(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x1093f
movq -0x38(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rsp)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
movq -0x40(%rsp), %rcx
cmpl 0x34(%rcx), %eax
jge 0x1092d
movl -0x2c(%rsp), %eax
movq -0x40(%rsp), %rcx
movslq -0x28(%rsp), %rdx
cmpl 0x18(%rcx,%rdx,4), %eax
jne 0x1091e
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x10(%rax)
je 0x1091e
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x10949
jmp 0x10920
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x108de
jmp 0x1092f
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x108b7
jmp 0x10941
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x770(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x20(%rsp), %rax
movq 0x770(%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x10a31
movq -0x40(%rsp), %rax
cmpl $0x0, 0x34(%rax)
je 0x10a31
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
movq -0x38(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x10a2f
movq -0x38(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rsp)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
movq -0x40(%rsp), %rcx
cmpl 0x34(%rcx), %eax
jge 0x10a1d
movl -0x2c(%rsp), %eax
movq -0x40(%rsp), %rcx
movslq -0x28(%rsp), %rdx
cmpl 0x18(%rcx,%rdx,4), %eax
jne 0x10a0e
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x14(%rax)
je 0x10a0e
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x10a39
jmp 0x10a10
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x109ce
jmp 0x10a1f
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x109a7
jmp 0x10a31
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x10c05
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x10bf3
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movq -0x8(%rsp), %rcx
movslq -0x14(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jne 0x10be1
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq (%rax), %rax
movsbl 0x40(%rax), %eax
movq -0x8(%rsp), %rcx
movslq -0x14(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movsbl 0x40(%rcx), %ecx
cmpl %ecx, %eax
jne 0x10be1
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x10(%rax)
je 0x10be1
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x10(%rax)
je 0x10be1
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x1b2bf(%rip), %xmm0    # 0x2be10
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10b7d
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x10(%rax)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x10bdf
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x1b25d(%rip), %xmm0    # 0x2be10
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10bdd
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x10(%rax)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x10bdf
jmp 0x10be1
jmp 0x10be3
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x10a77
jmp 0x10bf5
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x10a59
movl -0x18(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jne 0x1279e
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
je 0x12816
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x127bc
movl -0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jg 0x127bc
movl -0x8(%rsp), %eax
cmpl -0x10(%rsp), %eax
jle 0x12816
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jle 0x127da
movl -0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jl 0x127da
movl -0x8(%rsp), %eax
cmpl -0x10(%rsp), %eax
jge 0x12816
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x127f8
movl -0xc(%rsp), %eax
cmpl -0x18(%rsp), %eax
jg 0x127f8
movl -0xc(%rsp), %eax
cmpl -0x14(%rsp), %eax
jle 0x12816
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jle 0x12820
movl -0xc(%rsp), %eax
cmpl -0x18(%rsp), %eax
jl 0x12820
movl -0xc(%rsp), %eax
cmpl -0x14(%rsp), %eax
jl 0x12820
movl $0x1, -0x4(%rsp)
jmp 0x12828
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/mergepat.c
// Function: JoinNeighbours
void JoinNeighbours(int *Lnk1A, int Res1, int *Lnk1D, int Res2, PATTERN **Nei, 
		    PATTERN *Pat, int *MinDB1, int DB, int *MinDW1, int DW, int *Min, int j)
{
  *Lnk1A = Res1;
  *Lnk1D = Res2;
  (*Nei) = Pat;
  *MinDB1 = DB;
  *MinDW1 = DW;
  *Min = j;
}

// Assembly:
movl 0x30(%rsp), %eax
movq 0x28(%rsp), %rax
movl 0x20(%rsp), %eax
movq 0x18(%rsp), %rax
movl 0x10(%rsp), %eax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movl -0x1c(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x30(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x20(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0x30(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
movl 0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x128f0
movl -0x14(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jg 0x128f0
movl -0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jle 0x1294a
movl 0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jle 0x1290e
movl -0x14(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jl 0x1290e
movl -0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x1294a
movl 0x10(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x1292c
movl -0x10(%rsp), %eax
cmpl -0x18(%rsp), %eax
jg 0x1292c
movl -0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jle 0x1294a
movl 0x10(%rsp), %eax
cmpl -0x18(%rsp), %eax
jle 0x12957
movl -0x10(%rsp), %eax
cmpl -0x18(%rsp), %eax
jl 0x12957
movl -0x10(%rsp), %eax
cmpl 0x10(%rsp), %eax
jl 0x12957
movl $0x1, -0x4(%rsp)
jmp 0x129e0
movl 0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jne 0x129d6
movl 0x10(%rsp), %eax
cmpl -0x18(%rsp), %eax
jne 0x129d6
cmpl $-0x1, -0x8(%rsp)
je 0x129cc
movl -0x10(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0x1299a
movl -0x8(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0x1299a
movl -0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jl 0x1299a
movl -0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x129c2
movl -0x10(%rsp), %eax
cmpl 0x10(%rsp), %eax
jl 0x129cc
movl -0x8(%rsp), %eax
cmpl 0x10(%rsp), %eax
jl 0x129cc
movl -0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jg 0x129cc
movl -0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jg 0x129cc
movl $0x0, -0x4(%rsp)
jmp 0x129e0
movl $0x1, -0x4(%rsp)
jmp 0x129e0
jmp 0x129d8
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jne 0x146d2
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
je 0x147c6
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x14712
movl -0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x14712
movl -0x8(%rsp), %eax
cmpl -0x10(%rsp), %eax
jg 0x14712
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jg 0x14712
movl -0xc(%rsp), %eax
cmpl -0x18(%rsp), %eax
jg 0x14712
movl -0xc(%rsp), %eax
cmpl -0x14(%rsp), %eax
jle 0x147c6
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jle 0x1474e
movl -0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jle 0x1474e
movl -0x8(%rsp), %eax
cmpl -0x10(%rsp), %eax
jl 0x1474e
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jl 0x1474e
movl -0xc(%rsp), %eax
cmpl -0x18(%rsp), %eax
jl 0x1474e
movl -0xc(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x147c6
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x1478a
movl -0xc(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x1478a
movl -0xc(%rsp), %eax
cmpl -0x14(%rsp), %eax
jg 0x1478a
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jg 0x1478a
movl -0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jg 0x1478a
movl -0x8(%rsp), %eax
cmpl -0x10(%rsp), %eax
jle 0x147c6
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jle 0x147d0
movl -0xc(%rsp), %eax
cmpl -0x18(%rsp), %eax
jle 0x147d0
movl -0xc(%rsp), %eax
cmpl -0x14(%rsp), %eax
jl 0x147d0
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jl 0x147d0
movl -0x8(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jl 0x147d0
movl -0x8(%rsp), %eax
cmpl -0x10(%rsp), %eax
jl 0x147d0
movl $0x1, -0x4(%rsp)
jmp 0x147d8
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/fillasn.c
// Function: Alias
void Alias(int *D1,int *A1,int *D2,int *A2,char *D1Cn,char *A1Cn,char *D2Cn,char *A2Cn,
	  PATTERN *Pat)
{
    *D1 = Pat->Hb1->Dnr->D_Res;
    *A1 = Pat->Hb1->Acc->A_Res; 
    *D2 = Pat->Hb2->Dnr->D_Res;
    *A2 = Pat->Hb2->Acc->A_Res;
    *D1Cn = Pat->Hb1->Dnr->Chain->Id;
    *A1Cn = Pat->Hb1->Acc->Chain->Id;
    *D2Cn = Pat->Hb2->Dnr->Chain->Id;
    *A2Cn = Pat->Hb2->Acc->Chain->Id;
}

// Assembly:
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movb 0x40(%rax), %cl
movq -0x28(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movb 0x40(%rax), %cl
movq -0x30(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movb 0x40(%rax), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movb 0x40(%rax), %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xd8, %rsp
testb %al, %al
je 0x194ac
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %edi, 0xd4(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rsp, %rax
movq %rax, 0xc0(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movl $0x30, 0xb4(%rsp)
movl $0x10, 0xb0(%rsp)
movq 0x16af1(%rip), %rax     # 0x2fff8
movq (%rax), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x21a0
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq 0x1a0(%rsp), %rdi
movq %rsp, %rsi
movl $0xa, %edx
callq 0x37c0
movq 0x8(%rsp), %rdi
leaq 0x12a1d(%rip), %rsi     # 0x2bf85
movl $0x3, %edx
callq 0x2050
cmpl $0x0, %eax
jne 0x195d6
movq 0x10(%rsp), %rdi
leaq 0x12a06(%rip), %rsi     # 0x2bf89
movl $0x2, %edx
callq 0x2050
cmpl $0x0, %eax
jne 0x195d6
movq 0x18(%rsp), %rdi
leaq 0x129ee(%rip), %rsi     # 0x2bf8c
movl $0x2, %edx
callq 0x2050
cmpl $0x0, %eax
jne 0x195d6
movq 0x20(%rsp), %rdi
leaq 0x129d6(%rip), %rsi     # 0x2bf8f
movl $0x9, %edx
callq 0x2050
cmpl $0x0, %eax
jne 0x195d6
movq 0x198(%rsp), %rax
movl $0x0, (%rax)
movl $0x1, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq 0x1b0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0xa, %edx
callq 0x37c0
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x1b67b
movslq 0xc(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rdi
leaq 0x101bb(%rip), %rsi     # 0x2b7c4
callq 0x2130
cmpl $0x0, %eax
jne 0x1b623
movq 0x1a8(%rsp), %rax
movl $0x2, (%rax)
jmp 0x1b669
movslq 0xc(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rdi
leaq 0x109a0(%rip), %rsi     # 0x2bfd4
callq 0x2130
cmpl $0x0, %eax
je 0x1b659
movslq 0xc(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rdi
leaq 0x10989(%rip), %rsi     # 0x2bfd8
callq 0x2130
cmpl $0x0, %eax
jne 0x1b667
movq 0x1a8(%rsp), %rax
movl $0x1, (%rax)
jmp 0x1b669
jmp 0x1b66b
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b5ea
movl $0x1, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1090a(%rip), %rsi     # 0x2bfd4
callq 0x2240
cmpq $0x0, %rax
je 0x1b6e0
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x10(%rsp), %rdi
leaq 0x100d8(%rip), %rsi     # 0x2b7c4
callq 0x2240
cmpq $0x0, %rax
je 0x1b70e
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x1b70c
movq 0x8(%rsp), %rax
movl $0x2, (%rax)
jmp 0x1b70e
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x401, %rdi            # imm = 0x401
callq 0x20b0
cmpq $0x0, %rax
jne 0x1b75e
movq 0x14883(%rip), %rax     # 0x2ffd8
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x1b79c
movq 0x8(%rsp), %rdi
addq $0x401, %rdi            # imm = 0x401
leaq 0x10577(%rip), %rsi     # 0x2bce8
callq 0x2190
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x1b79a
movq 0x8(%rsp), %rsi
addq $0x401, %rsi            # imm = 0x401
leaq 0x108f7(%rip), %rdi     # 0x2c08a
movb $0x0, %al
callq 0xc970
jmp 0x1b79c
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1d6c(%rax)
jne 0x1b7b8
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1b8c0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1bb10
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1c0e0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1c460
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1c6e0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1d6c(%rax)
jne 0x1b830
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1c840
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1d70(%rax)
je 0x1b85a
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1cbe0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1d88(%rax)
je 0x1b89d
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
xorl %edx, %edx
callq 0x27830
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
movl $0x1, %edx
callq 0x27830
movq (%rsp), %rax
movq 0x14730(%rip), %rcx     # 0x2ffd8
cmpq (%rcx), %rax
je 0x1b8b6
movq (%rsp), %rdi
callq 0x20a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x858, %rsp            # imm = 0x858
movq %rdi, 0x850(%rsp)
movq %rsi, 0x848(%rsp)
movq 0x850(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x1c70d
jmp 0x1c834
leaq 0x440(%rsp), %rdi
movq 0x850(%rsp), %rsi
callq 0x1d3d0
movl $0x0, 0x844(%rsp)
movl 0x844(%rsp), %eax
movq 0x850(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x1c834
movq 0x850(%rsp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movslq 0x844(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movsbl 0xe(%rax), %edi
callq 0x6550
movsbl %al, %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
addq $0x6, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movsbl 0xf(%rax), %edi
callq 0x6550
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %r8
movsbl %al, %r9d
leaq 0xfdd8(%rip), %rsi      # 0x2c5a6
movb $0x0, %al
callq 0x2200
movq 0x28(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x1c7f3
leaq 0x30(%rsp), %rdi
leaq 0xfdf3(%rip), %rsi      # 0x2c5df
callq 0x21e0
jmp 0x1c804
leaq 0x30(%rsp), %rdi
leaq 0xfde7(%rip), %rsi      # 0x2c5e6
callq 0x21e0
leaq 0x440(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x848(%rsp), %rdx
callq 0x1d430
movl 0x844(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x844(%rsp)
jmp 0x1c72d
addq $0x858, %rsp            # imm = 0x858
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/report.c
// Function: PrepareBuffer
void PrepareBuffer(BUFFER Bf, CHAIN **Chain)
{

  memset(Bf,' ',OUTPUTWIDTH);

  strcpy(Bf+OUTPUTWIDTH-5,Chain[0]->PdbIdent);
  Bf[OUTPUTWIDTH] = '\0';
  Bf[OUTPUTWIDTH-1]   = '\n';
	   
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x20, %esi
movl $0x50, %edx
callq 0x20e0
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
addq $-0x5, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq $0xb0, %rsi
callq 0x2060
movq 0x10(%rsp), %rax
movb $0x0, 0x50(%rax)
movq 0x10(%rsp), %rax
movb $0xa, 0x4f(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)