LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/strutil.c
// Function: Boundaries
int Boundaries(char *Asn, int L, char SecondStr, int (*Bound)[2])
{
  register int Res;
  int NStr = 0, Flag = 0;
  
  for( Res=0; Res<L; Res++ ) {
    if( Asn[Res] == SecondStr && Flag == 0 ) {
      Flag = 1; 
      Bound[NStr][0] = Res;
    }
    else
    if( Asn[Res] != SecondStr && Flag == 1 ) {
      Flag = 0; 
      Bound[NStr++][1] = Res-1;
    }
  }
  return(NStr);
}

// Assembly:
testl %esi, %esi
jle 0x504c
pushq %rbx
movl %esi, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movb (%rdi,%r8), %r10b
cmpb %dl, %r10b
sete %r11b
testl %r9d, %r9d
sete %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x5019
movslq %eax, %r9
movl %r8d, (%rcx,%r9,8)
movl $0x1, %r9d
jmp 0x5042
cmpb %dl, %r10b
setne %r10b
cmpl $0x1, %r9d
sete %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x5042
movslq %eax, %r9
incl %eax
leal -0x1(%r8), %r10d
movl %r10d, 0x4(%rcx,%r9,8)
xorl %r9d, %r9d
incq %r8
cmpq %r8, %rsi
jne 0x4ff1
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/strutil.c
// Function: ChInStr
BOOLEAN ChInStr(char *String, char Char)
{

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x2030
movq (%rax), %rax
movslq %r14d, %r15
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x20c0
movl $0x1, %ebp
testq %rax, %rax
jne 0x51e3
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0x20c0
testq %rax, %rax
jne 0x51e3
callq 0x2280
movq (%rax), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x20c0
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x52cc
movl %esi, %eax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rsi
movslq (%rsi), %rdx
testq %rdx, %rdx
jle 0x52c4
movq 0x68(%rsi), %rsi
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movq 0x768(%r9), %r9
cmpb $0x43, 0x1c(%r9)
jne 0x52cf
incq %r8
cmpq %r8, %rdx
jne 0x52aa
incq %rcx
cmpq %rax, %rcx
jne 0x5297
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/strutil.c
// Function: SecStrContent
float SecStrContent(CHAIN *Chain, int *HelAlp, int *HelPI, int *Hel310, int *Sheet, int *Turn)
{

  int Res;
  float Content = 0.0;

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

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

  return(Content);
}

// Assembly:
pushq %r14
pushq %rbx
xorl %eax, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
movl %eax, (%rcx)
movl %eax, (%r8)
movl %eax, (%r9)
movl (%rdi), %ebx
testl %ebx, %ebx
jle 0x5344
movq 0x68(%rdi), %rax
xorl %r10d, %r10d
leaq 0x14752(%rip), %r11     # 0x19a4c
movq (%rax,%r10,8), %rbx
movq 0x768(%rbx), %rbx
movzbl 0x1d(%rbx), %ebx
leal -0x45(%rbx), %r14d
cmpl $0x4, %r14d
ja 0x5325
movslq (%r11,%r14,4), %r14
addq %r11, %r14
movq %rsi, %rbx
jmpq *%r14
movq %r8, %rbx
jmp 0x5337
cmpl $0x54, %ebx
jne 0x5339
movq %r9, %rbx
jmp 0x5337
movq %rcx, %rbx
jmp 0x5337
movq %rdx, %rbx
incl (%rbx)
incq %r10
movslq (%rdi), %rbx
cmpq %rbx, %r10
jl 0x52fa
movl (%rdx), %eax
addl (%rsi), %eax
addl (%rcx), %eax
addl (%r8), %eax
addl (%r9), %eax
cvtsi2ss %eax, %xmm0
cvtsi2ss %ebx, %xmm1
divss %xmm1, %xmm0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/memory.c
// Function: FloatMatrix
float **FloatMatrix(int M, int N)
{
  int m;
  float **Matrix;

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

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

  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 0x59af
leaq 0x141d8(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
testl %ebp, %ebp
jle 0x59ec
movslq %r14d, %r14
shlq $0x2, %r14
movl %ebp, %r13d
leaq 0x141bc(%rip), %r15     # 0x19b80
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x59e0
movq %r15, %rdi
xorl %eax, %eax
callq 0x8900
movq %r12, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x59c6
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_O1/josch[P]stride/memory.c
// Function: FloatCube
float ***FloatCube(int M, int N, int K)
{
  int m, n, k;
  float ***Cube;

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

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

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

  return(Cube);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, (%rsp)
testq %rax, %rax
jne 0x5a36
leaq 0x14151(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movl %r15d, %eax
movq %rax, 0x10(%rsp)
movl %ebp, %r14d
movl %r15d, 0x8(%rsp)
testl %r15d, %r15d
jle 0x5ada
movslq %ebp, %rax
shlq $0x3, %rax
movq %rax, 0x18(%rsp)
movslq %ebx, %r13
shlq $0x2, %r13
xorl %r15d, %r15d
movl %ebp, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5a89
leaq 0x140fe(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq (%rsp), %rax
movq %r15, 0x20(%rsp)
movq %r12, (%rax,%r15,8)
testl %ebp, %ebp
jle 0x5ac7
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5abb
leaq 0x140cc(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq %rbp, (%r12,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x5a9d
movq 0x20(%rsp), %r15
incq %r15
cmpq 0x10(%rsp), %r15
movl 0xc(%rsp), %ebp
jne 0x5a69
cmpl $0x0, 0x8(%rsp)
jle 0x5b1e
movl %ebx, %r15d
shlq $0x2, %r15
xorl %r12d, %r12d
testl %ebp, %ebp
jle 0x5b14
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x5b0c
movq (%rsp), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
incq %r13
cmpq %r13, %r14
jne 0x5af2
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x5aeb
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/memory.c
// Function: Float4Dim
float ****Float4Dim(int M, int N, int K, int L)
{
  int m, n, k, l;
  float ****FourDim;

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


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

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

  return(FourDim);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x4(%rsp)
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x5b6e
leaq 0x14019(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movl %r14d, %eax
movq %rax, 0x20(%rsp)
movl %ebp, %eax
movq %rax, 0x28(%rsp)
movl %ebx, %r15d
movl %r14d, 0x1c(%rsp)
testl %r14d, %r14d
movl %ebx, 0xc(%rsp)
movl %ebp, 0x8(%rsp)
jle 0x5c6c
movslq %ebp, %rax
shlq $0x3, %rax
movq %rax, 0x30(%rsp)
movslq %ebx, %rax
shlq $0x3, %rax
movq %rax, 0x40(%rsp)
movslq 0x4(%rsp), %r13
shlq $0x2, %r13
xorl %r14d, %r14d
movq 0x30(%rsp), %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5bda
leaq 0x13fad(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq 0x10(%rsp), %rax
movq %r14, 0x38(%rsp)
movq %r12, (%rax,%r14,8)
testl %ebp, %ebp
jle 0x5c55
xorl %r14d, %r14d
movq 0x40(%rsp), %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5c0f
leaq 0x13f78(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq %rbp, (%r12,%r14,8)
testl %ebx, %ebx
jle 0x5c47
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5c37
leaq 0x13f50(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq (%r12,%r14,8), %rax
movq %rbp, (%rax,%rbx,8)
incq %rbx
cmpq %rbx, %r15
jne 0x5c19
incq %r14
cmpq 0x28(%rsp), %r14
movl 0xc(%rsp), %ebx
jne 0x5bef
movq 0x38(%rsp), %r14
incq %r14
cmpq 0x20(%rsp), %r14
movl 0x8(%rsp), %ebp
jne 0x5bba
cmpl $0x0, 0x1c(%rsp)
movl 0x4(%rsp), %ebp
jle 0x5cd0
movl %ebp, %r14d
shlq $0x2, %r14
xorl %r12d, %r12d
cmpl $0x0, 0x8(%rsp)
jle 0x5cc6
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x5cb8
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x5cb0
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20f0
incq %rbx
cmpq %rbx, %r15
jne 0x5c91
incq %r13
cmpq 0x28(%rsp), %r13
movl 0xc(%rsp), %ebx
jne 0x5c8b
incq %r12
cmpq 0x20(%rsp), %r12
jne 0x5c81
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_O1/josch[P]stride/memory.c
// Function: IntCube
int ***IntCube(int M, int N, int K)
{
  int m, n, k;
  int ***Cube;

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

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

  return(Cube);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, (%rsp)
testq %rax, %rax
jne 0x5d4c
leaq 0x13e3b(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movl %r15d, %eax
movq %rax, 0x10(%rsp)
movl %ebp, %r14d
movl %r15d, 0x8(%rsp)
testl %r15d, %r15d
jle 0x5df0
movslq %ebp, %rax
shlq $0x3, %rax
movq %rax, 0x18(%rsp)
movslq %ebx, %r13
shlq $0x2, %r13
xorl %r15d, %r15d
movl %ebp, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5d9f
leaq 0x13de8(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq (%rsp), %rax
movq %r15, 0x20(%rsp)
movq %r12, (%rax,%r15,8)
testl %ebp, %ebp
jle 0x5ddd
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5dd1
leaq 0x13db6(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq %rbp, (%r12,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x5db3
movq 0x20(%rsp), %r15
incq %r15
cmpq 0x10(%rsp), %r15
movl 0xc(%rsp), %ebp
jne 0x5d7f
cmpl $0x0, 0x8(%rsp)
jle 0x5e34
movl %ebx, %r15d
shlq $0x2, %r15
xorl %r12d, %r12d
testl %ebp, %ebp
jle 0x5e2a
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x5e22
movq (%rsp), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
incq %r13
cmpq %r13, %r14
jne 0x5e08
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x5e01
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/memory.c
// Function: IntMatrix
int **IntMatrix(int M, int N)
{
  int m;
  int **Matrix;

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

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

  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 0x5e79
leaq 0x13d0e(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
testl %ebp, %ebp
jle 0x5eb6
movslq %r14d, %r14
shlq $0x2, %r14
movl %ebp, %r13d
leaq 0x13cf2(%rip), %r15     # 0x19b80
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5eaa
movq %r15, %rdi
xorl %eax, %eax
callq 0x8900
movq %r12, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x5e90
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_O1/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, 0x4(%rsp)
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x5f05
leaq 0x13c82(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movl %r14d, %eax
movq %rax, 0x20(%rsp)
movl %ebp, %eax
movq %rax, 0x28(%rsp)
movl %ebx, %r15d
movl %r14d, 0x1c(%rsp)
testl %r14d, %r14d
movl %ebx, 0xc(%rsp)
movl %ebp, 0x8(%rsp)
jle 0x6003
movslq %ebp, %rax
shlq $0x3, %rax
movq %rax, 0x30(%rsp)
movslq %ebx, %rax
shlq $0x3, %rax
movq %rax, 0x40(%rsp)
movslq 0x4(%rsp), %r13
shlq $0x2, %r13
xorl %r14d, %r14d
movq 0x30(%rsp), %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5f71
leaq 0x13c16(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq 0x10(%rsp), %rax
movq %r14, 0x38(%rsp)
movq %r12, (%rax,%r14,8)
testl %ebp, %ebp
jle 0x5fec
xorl %r14d, %r14d
movq 0x40(%rsp), %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5fa6
leaq 0x13be1(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq %rbp, (%r12,%r14,8)
testl %ebx, %ebx
jle 0x5fde
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5fce
leaq 0x13bb9(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
movq (%r12,%r14,8), %rax
movq %rbp, (%rax,%rbx,8)
incq %rbx
cmpq %rbx, %r15
jne 0x5fb0
incq %r14
cmpq 0x28(%rsp), %r14
movl 0xc(%rsp), %ebx
jne 0x5f86
movq 0x38(%rsp), %r14
incq %r14
cmpq 0x20(%rsp), %r14
movl 0x8(%rsp), %ebp
jne 0x5f51
cmpl $0x0, 0x1c(%rsp)
movl 0x4(%rsp), %ebp
jle 0x6067
movl %ebp, %r14d
shlq $0x2, %r14
xorl %r12d, %r12d
cmpl $0x0, 0x8(%rsp)
jle 0x605d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x604f
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x6047
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20f0
incq %rbx
cmpq %rbx, %r15
jne 0x6028
incq %r13
cmpq 0x28(%rsp), %r13
movl 0xc(%rsp), %ebx
jne 0x6022
incq %r12
cmpq 0x20(%rsp), %r12
jne 0x6018
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_O1/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 0x60dd
leaq 0x13aaa(%rip), %rdi     # 0x19b80
xorl %eax, %eax
callq 0x8900
testl %ebp, %ebp
jle 0x6116
movslq %r14d, %r14
movl %ebp, %r13d
leaq 0x13a92(%rip), %r15     # 0x19b80
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x610a
movq %r15, %rdi
xorl %eax, %eax
callq 0x8900
movq %r12, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x60f0
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_O1/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 0x61a1
movl %edx, %ebx
movl %esi, %r15d
movl %edx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x6190
xorl %ebp, %ebp
movq (%r14,%r13,8), %rax
movq (%rax,%rbp,8), %rdi
callq 0x2040
incq %rbp
cmpq %rbp, %r12
jne 0x617b
movq (%r14,%r13,8), %rdi
callq 0x2040
incq %r13
cmpq %r15, %r13
jne 0x6175
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_O1/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 0x6200
movl %edx, %ebx
movl %esi, %r15d
movl %edx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x61ef
xorl %ebp, %ebp
movq (%r14,%r13,8), %rax
movq (%rax,%rbp,8), %rdi
callq 0x2040
incq %rbp
cmpq %rbp, %r12
jne 0x61da
movq (%r14,%r13,8), %rdi
callq 0x2040
incq %r13
cmpq %r15, %r13
jne 0x61d4
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8205
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 0x81f3
xorl %ebp, %ebp
movl %ebp, %esi
callq 0x42a6
movq (%rbx,%r15,8), %rdi
movl %ebp, %esi
callq 0x4413
incl %ebp
movq (%rbx,%r15,8), %rdi
cmpl (%rdi), %ebp
jl 0x81d7
incq %r15
cmpq %r14, %r15
jne 0x81cc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8469
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 0x8442
movl $0x2, %r12d
movq (%r14,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x843a
movq %r15, %rdi
callq 0x2150
testl %eax, %eax
je 0x8459
incq %r12
cmpq %r12, %r13
jne 0x8425
incq %rbp
addq $0x8, %r14
decq %r13
cmpq (%rsp), %rbp
jne 0x8415
movl $0x1, %eax
jmp 0x845b
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_O1/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 0x84d8
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %r13d
movl $0x1, %r12d
movq (%r15,%r12,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x84cb
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0x84d5
incq %r12
cmpq %r12, %r13
jne 0x84b6
jmp 0x84d8
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8550
movl %edx, %ebp
movq %rdi, %r14
movl %esi, %r13d
xorl %r15d, %r15d
movl $0x1, %ebx
movq (%r14,%rbx,8), %r12
cmpb $0x2d, (%r12)
jne 0x8548
callq 0x2290
movq (%rax), %rax
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x8548
addq $0x2, %r12
movq %r12, %rdi
callq 0x21f0
cmpl %ebp, %eax
jne 0x8548
movslq %r15d, %rax
incl %r15d
movq (%rsp), %rcx
movl %ebx, (%rcx,%rax,4)
incq %rbx
cmpq %rbx, %r13
jne 0x850b
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_O1/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 0x895e
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 0x1866b(%rip), %rax     # 0x20ff0
movq (%rax), %rdi
movq %r10, %rsi
callq 0x21c0
movl $0x1, %edi
callq 0x2230
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x16c25(%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 0xfc30(%rip), %rsi      # 0x1a027
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 0xfc38(%rip), %rsi      # 0x1a054
movb $0x1, %al
callq 0x2160
cmpl $0x0, 0x10(%rbx)
movq (%r14), %rcx
je 0xa447
xorps %xmm0, %xmm0
cvtss2sd 0x1c(%rbx), %xmm0
leaq 0xfc1a(%rip), %rsi      # 0x1a055
movq %rcx, %rdi
movb $0x1, %al
callq 0x2160
jmp 0xa45d
leaq 0xfc0e(%rip), %rdi      # 0x1a05c
movl $0x8, %esi
movl $0x1, %edx
callq 0x2240
cmpl $0x0, 0x14(%rbx)
movq (%r14), %rcx
je 0xa474
leaq 0xfbf8(%rip), %rdi      # 0x1a065
movl $0x4, %esi
jmp 0xa480
leaq 0xfbef(%rip), %rdi      # 0x1a06a
movl $0x3, %esi
movl $0x1, %edx
callq 0x2240
cmpl $0x0, 0x18(%rbx)
movq (%r14), %rcx
je 0xa4a1
leaq 0xfbd4(%rip), %rdi      # 0x1a06e
movl $0x4, %esi
jmp 0xa4ad
leaq 0xfbcb(%rip), %rdi      # 0x1a073
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_O1/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 0xa528
movq 0x770(%rdx), %rdx
movl 0x34(%rdx), %r8d
testq %r8, %r8
je 0xa528
testl %esi, %esi
jle 0xa528
xorl %r9d, %r9d
testl %r8d, %r8d
jle 0xa51b
movl (%rcx,%r9,4), %r10d
movslq %r10d, %r11
xorl %ebx, %ebx
cmpl 0x18(%rdx,%rbx,4), %r10d
jne 0xa513
movq (%rdi,%r11,8), %r14
cmpl $0x0, 0x10(%r14)
jne 0xa525
incq %rbx
cmpq %rbx, %r8
jne 0xa501
incq %r9
cmpq %rsi, %r9
jne 0xa4f3
jmp 0xa528
movl %r10d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa58f
movq 0x770(%rdx), %rdx
movl 0x34(%rdx), %r8d
testq %r8, %r8
je 0xa58f
testl %esi, %esi
jle 0xa58f
xorl %r9d, %r9d
testl %r8d, %r8d
jle 0xa582
movl (%rcx,%r9,4), %r10d
movslq %r10d, %r11
xorl %ebx, %ebx
cmpl 0x18(%rdx,%rbx,4), %r10d
jne 0xa57a
movq (%rdi,%r11,8), %r14
cmpl $0x0, 0x14(%r14)
jne 0xa58c
incq %rbx
cmpq %rbx, %r8
jne 0xa568
incq %r9
cmpq %rsi, %r9
jne 0xa55a
jmp 0xa58f
movl %r10d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa65d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leal -0x1(%rsi), %ecx
movl %esi, %edx
xorl %esi, %esi
movsd 0xf989(%rip), %xmm0     # 0x19f40
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 0xa63b
movq (%r10), %r13
movb 0x40(%r13), %bpl
movq (%r12), %r12
cmpb 0x40(%r12), %bpl
jne 0xa63b
cmpl $0x0, (%rbx)
je 0xa63b
cmpl $0x0, 0x10(%r15)
je 0xa63b
xorps %xmm1, %xmm1
cvtss2sd 0x1c(%r9), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x1c(%r15), %xmm2
movaps %xmm2, %xmm3
mulsd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0xa625
addq $0x10, %r15
jmp 0xa632
mulsd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
movq %rbx, %r15
jbe 0xa63b
movl $0x0, (%r15)
incl %eax
incq %r14
cmpq %r14, %rdx
jne 0xa5d4
addq $0x8, %r8
decq %rdx
cmpq %rcx, %rsi
jne 0xa5bc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb6bb
movl 0x20(%rsp), %ebx
cmpl %ecx, %ebx
jg 0xb6bb
cmpl %r9d, %ecx
jg 0xb6bb
cmpl %edx, %ecx
jg 0xb6bb
cmpl %esi, %edi
jl 0xb6bb
cmpl %r8d, %esi
jl 0xb6bb
movl 0x18(%rsp), %ebp
cmpl %edi, %ebp
jl 0xb6bb
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 0xb6bb
testl %esi, %esi
js 0xb6bb
testl %r11d, %r11d
js 0xb6bb
testl %r9d, %r9d
js 0xb6bb
cmpl $0x3, %r10d
setl %cl
cmpl $0x6, %esi
setl %dl
testb %dl, %cl
jne 0xb696
cmpl $0x6, %r10d
setl %cl
cmpl $0x3, %esi
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xb6bb
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpl %esi, %r10d
cmovll %r10d, %esi
movl %esi, (%rcx)
cmpl %r9d, %r11d
cmovgl %r11d, %r9d
movl %r9d, (%rax)
xorl %eax, %eax
cmpl %r9d, (%rcx)
setle %al
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb6e2
cmpl %edx, %edi
jg 0xb6e3
cmpl %r9d, %edx
jge 0xb6e3
cmpl %r9d, %edi
jg 0xb6e3
retq
cmpl %edx, %edi
jl 0xb6f1
cmpl %r9d, %edx
jle 0xb6f1
cmpl %r9d, %edi
jge 0xb6e2
cmpl %ecx, %esi
jg 0xb6ff
cmpl %r8d, %ecx
jge 0xb6ff
cmpl %r8d, %esi
jle 0xb6e2
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_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x48(%rsp), %eax
movq 0x40(%rsp), %r10
movl 0x38(%rsp), %r11d
movq 0x30(%rsp), %rbx
movl 0x28(%rsp), %ebp
movq 0x20(%rsp), %r14
movl %esi, (%rdi)
movl %ecx, (%rdx)
movq %r9, (%r8)
movl %ebp, (%r14)
movl %r11d, (%rbx)
movl %eax, (%r10)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb767
cmpl %r9d, %ecx
jg 0xb767
cmpl %r9d, %r10d
jge 0xb767
retq
cmpl %r10d, %ecx
jl 0xb776
cmpl %r9d, %ecx
jl 0xb776
cmpl %r9d, %r10d
jg 0xb766
movl 0x10(%rsp), %r11d
cmpl %r11d, %ecx
jg 0xb78a
cmpl %r8d, %edx
jg 0xb78a
cmpl %r8d, %r11d
jl 0xb766
cmpl %r11d, %edx
jl 0xb799
cmpl %r8d, %edx
jl 0xb799
cmpl %r8d, %r11d
jg 0xb766
xorl %r10d, %r9d
xorl %r11d, %r8d
xorl %eax, %eax
orl %r9d, %r8d
jne 0xb766
cmpl $-0x1, %edi
je 0xb7d3
cmpl %r10d, %ecx
jl 0xb7bf
cmpl %r10d, %esi
jl 0xb7bf
cmpl %r11d, %edx
jg 0xb7bf
cmpl %r11d, %edi
jle 0xb766
cmpl %r10d, %ecx
jg 0xb7d3
cmpl %r11d, %edx
jl 0xb7d3
cmpl %r10d, %esi
jg 0xb7d3
cmpl %r11d, %edi
jge 0xb766
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc8bd
cmpl %ecx, %esi
jg 0xc8be
cmpl %r8d, %esi
jg 0xc8be
cmpl %r8d, %ecx
jg 0xc8be
cmpl %edx, %edi
jg 0xc8be
cmpl %r9d, %edx
jge 0xc8be
cmpl %r9d, %edi
jge 0xc8be
retq
cmpl %ecx, %esi
jl 0xc8da
cmpl %r8d, %esi
jl 0xc8da
cmpl %r8d, %ecx
jl 0xc8da
cmpl %edx, %edi
jl 0xc8da
cmpl %r9d, %edx
jle 0xc8da
cmpl %r9d, %edi
jg 0xc8bd
cmpl %edx, %edi
jg 0xc8f6
cmpl %r9d, %edi
jg 0xc8f6
cmpl %r9d, %edx
jg 0xc8f6
cmpl %ecx, %esi
jg 0xc8f6
cmpl %r8d, %ecx
jge 0xc8f6
cmpl %r8d, %esi
jl 0xc8bd
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_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %r10
movq 0x30(%rsp), %r11
movq (%r11), %rbx
movq (%rbx), %r14
movl 0x8(%r14), %ebp
movl %ebp, (%rdi)
movq 0x8(%rbx), %rdi
movl 0x8(%rdi), %edi
movl %edi, (%rsi)
movq 0x8(%r11), %rsi
movq (%rsi), %rdi
movl 0x8(%rdi), %edi
movl %edi, (%rdx)
movq 0x8(%rsi), %rdx
movl 0x8(%rdx), %edx
movl %edx, (%rcx)
movq (%r14), %rcx
movb 0x40(%rcx), %cl
movb %cl, (%r8)
movq (%r11), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movb 0x40(%rcx), %cl
movb %cl, (%r9)
movq 0x8(%r11), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movb 0x40(%rcx), %cl
movb %cl, (%r10)
movq 0x8(%r11), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movb 0x40(%rcx), %cl
movb %cl, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x36b8
movq 0x8(%r14), %rdi
leaq 0xb4b2(%rip), %rsi      # 0x1a0ce
movl $0x3, %edx
callq 0x2060
testl %eax, %eax
jne 0xec7e
movq 0x10(%rsp), %rdi
leaq 0xb49c(%rip), %rsi      # 0x1a0d2
movl $0x2, %edx
callq 0x2060
testl %eax, %eax
jne 0xec7e
movq 0x18(%rsp), %rdi
leaq 0xb485(%rip), %rsi      # 0x1a0d5
movl $0x2, %edx
callq 0x2060
testl %eax, %eax
jne 0xec7e
movq 0x20(%rsp), %rdi
leaq 0xb46e(%rip), %rsi      # 0x1a0d8
movl $0x9, %edx
callq 0x2060
testl %eax, %eax
jne 0xec7e
movl $0x0, (%rbx)
movl $0x1, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xfc8e
movq %rcx, %r12
addq $0x1c08, %r12           # imm = 0x1C08
movsbl 0xf(%rbx), %edi
callq 0x517a
movsbl %al, %esi
movq %r12, %rdi
callq 0x5187
testl %eax, %eax
je 0xfd6b
cmpl $0x0, (%r15)
jne 0xfca8
movq %r14, %rdi
callq 0x3d9c
movb 0xf(%rbx), %al
movq (%r14), %rcx
movb %al, 0x40(%rcx)
incl (%r15)
movq (%r14), %rax
movslq 0x2c(%rax), %r12
movl $0x14, %edi
callq 0x595c
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 0x36b8
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 0x36b8
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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x36b8
testl %eax, %eax
jle 0xfe03
movl %eax, %ebp
xorl %r12d, %r12d
leaq 0x9a86(%rip), %r14      # 0x19837
movq (%rsp,%r12,8), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xfdf2
movq %r13, %rdi
leaq 0xa34f(%rip), %rsi      # 0x1a11d
callq 0x2150
movl $0x1, %r15d
testl %eax, %eax
je 0xfdf8
movq %r13, %rdi
leaq 0xa33a(%rip), %rsi      # 0x1a121
callq 0x2150
testl %eax, %eax
jne 0xfdfb
jmp 0xfdf8
movl $0x2, %r15d
movl %r15d, (%rbx)
incq %r12
cmpq %r12, %rbp
jne 0xfdb1
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_O1/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 0xa2dc(%rip), %rsi      # 0x1a11d
callq 0x2270
testq %rax, %rax
je 0xfe51
movl $0x1, (%rbx)
leaq 0x99df(%rip), %rsi      # 0x19837
movq %r14, %rdi
callq 0x2270
testq %rax, %rax
je 0xfe70
cmpl $0x0, (%rbx)
jne 0xfe70
movl $0x2, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xfed3
leaq 0x401(%rbx), %r13
leaq 0x9efb(%rip), %rsi      # 0x19da8
movq %r13, %rdi
callq 0x21b0
movq %rax, %r15
testq %rax, %rax
jne 0xfedd
leaq 0xa32c(%rip), %rdi      # 0x1a1f0
xorl %r15d, %r15d
movq %r13, %rsi
xorl %eax, %eax
callq 0x8900
jmp 0xfedd
movq 0x110f6(%rip), %rax     # 0x20fd0
movq (%rax), %r15
cmpl $0x0, 0x1d6c(%rbx)
jne 0xfef1
movq %r14, %rdi
movq %r15, %rsi
callq 0xffb6
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x101b3
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x105d9
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x10832
movq %r14, %rdi
movq %r15, %rsi
callq 0x109bb
cmpl $0x0, 0x1d6c(%rbx)
jne 0xff3c
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x10ae3
cmpl $0x0, 0x1d70(%rbx)
je 0xff55
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x10d97
cmpl $0x0, 0x1d88(%rbx)
je 0xff85
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x16e60
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x16e60
movq 0x11044(%rip), %rax     # 0x20fd0
cmpq (%rax), %r15
je 0xffa7
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_O1/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 0x109ba
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x848, %rsp            # imm = 0x848
movq %rdx, %rbp
movq %rdi, %r12
movl %esi, %r14d
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r12,%rax,8), %rdx
cmpl $0x0, 0x58(%rdx)
je 0x10865
addl 0x28(%rdx), %ecx
incq %rax
cmpq %rax, %r14
jne 0x10858
testl %ecx, %ecx
je 0x109a9
movaps 0x9964(%rip), %xmm0     # 0x1a1e0
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)
leaq 0x440(%rsp), %r15
xorl %ebx, %ebx
movq %r14, (%rsp)
movq %rbp, 0x8(%rsp)
movq (%r12,%rbx,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x10999
movq (%r12,%rbx,8), %rax
cmpl $0x0, 0x28(%rax)
jle 0x10999
xorl %r14d, %r14d
movq 0x98(%rax), %rax
movq (%rax,%r14,8), %rbp
movsbl 0x1a(%rbp), %edi
callq 0x50c4
movq %rax, 0x20(%rsp)
leaq 0xc(%rbp), %rax
movq %rax, 0x28(%rsp)
movq (%r12,%rbx,8), %rax
movsbl 0x40(%rax), %edi
callq 0x517a
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 0x517a
movsbl %al, %r10d
subq $0x8, %rsp
movq %r15, %rdi
leaq 0x9e04(%rip), %rsi      # 0x1a74c
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 0x112df
incq %r14
movq (%r12,%rbx,8), %rax
movslq 0x28(%rax), %rcx
cmpq %rcx, %r14
jl 0x108e4
incq %rbx
movq (%rsp), %r14
cmpq %r14, %rbx
jne 0x108c5
addq $0x848, %rsp            # imm = 0x848
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq