LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/report.c
// Function: ReportSSBonds
void ReportSSBonds(CHAIN **Chain, FILE *Out)
{
  register int i;
  BUFFER Bf, Tmp;
  SSBOND *s;

  if( !Chain[0]->NBond ) return;

  PrepareBuffer(Bf,Chain);

  for( i=0; i<Chain[0]->NBond; i++ ) {
    s = Chain[0]->SSbond[i];
    sprintf(Tmp,"LOC  Disulfide    CYS  %4s %c      CYS   %4s %c         ",
	    s->PDB_ResNumb1,SpaceToDash(s->ChainId1),
	    s->PDB_ResNumb2,SpaceToDash(s->ChainId2));

    if( s->AsnSource == Pdb )
      strcat(Tmp,"   PDB");
    else
      strcat(Tmp,"STRIDE\n");
    Glue(Bf,Tmp,Out);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %rsi, 0x8(%rsp)
movq (%rdi), %rsi
cmpl $0x0, 0x2c(%rsi)
je 0x10ad1
movq %rdi, %r14
movaps 0x97f8(%rip), %xmm0     # 0x1a1e0
leaq 0x46b(%rsp), %r15
movaps %xmm0, -0xb(%r15)
movaps %xmm0, -0x1b(%r15)
movaps %xmm0, -0x2b(%r15)
movaps %xmm0, -0x3b(%r15)
movaps %xmm0, -0x4b(%r15)
addq $0xb0, %rsi
movq %r15, %rdi
callq 0x2070
movw $0xa, 0x4(%r15)
movq (%r14), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x10ad1
leaq 0x10(%rsp), %r12
xorl %ebx, %ebx
movq 0xa0(%rax), %rax
movq (%rax,%rbx,8), %rbp
movsbl 0xe(%rbp), %edi
callq 0x517a
movsbl %al, %r15d
leaq 0x6(%rbp), %r13
movsbl 0xf(%rbp), %edi
callq 0x517a
movsbl %al, %r9d
movq %r12, %rdi
leaq 0x9ca6(%rip), %rsi      # 0x1a70c
movq %rbp, %rdx
movl %r15d, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x2220
movl 0x10(%rbp), %ebp
movq %r12, %rdi
callq 0x20b0
addq %rsp, %rax
addq $0x10, %rax
cmpl $0x1, %ebp
jne 0x10a9c
movl $0x424450, 0x3(%rax)    # imm = 0x424450
movl $0x50202020, (%rax)     # imm = 0x50202020
jmp 0x10aa9
movabsq $0xa454449525453, %rcx  # imm = 0xA454449525453
movq %rcx, (%rax)
leaq 0x420(%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x112df
incq %rbx
movq (%r14), %rax
movslq 0x2c(%rax), %rcx
cmpq %rcx, %rbx
jl 0x10a33
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/nsc.c
// Function: safe_asin
double safe_asin(double f) {
  if ( (fabs(f) < 1.00) ) return( asin(f) );
  if ( (fabs(f) - 1.00)  < DP_TOL ) return(HALFPI);
  else ERROR("ASIN : invalid argument %f", f);
  return(0.0);
  }

// Assembly:
movapd 0x8578(%rip), %xmm1     # 0x198b0
andpd %xmm0, %xmm1
movsd 0x8524(%rip), %xmm2     # 0x19868
ucomisd %xmm1, %xmm2
ja 0x2210
addsd 0x8502(%rip), %xmm1     # 0x19858
movsd 0x951a(%rip), %xmm2     # 0x1a878
ucomisd %xmm1, %xmm2
jbe 0x1136d
movsd 0x9504(%rip), %xmm0     # 0x1a870
retq
pushq %rax
leaq 0x95e4(%rip), %rax      # 0x1a959
movq %rax, 0x112c4(%rip)     # 0x22640
movl $0x61, 0x112b2(%rip)    # 0x22638
leaq 0x95d2(%rip), %rdi      # 0x1a95f
movb $0x1, %al
callq 0x24b8
xorpd %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/nsc.c
// Function: mycalloc
void * mycalloc(const char * filename, const int linenr,
                size_t nelem, size_t elsize) {
  int * ip;
  ip = (int *) calloc(nelem, elsize);
  if(ip) return(ip);
  else ERROR("CALLOC : failed in file %s at line %d", filename, linenr);
  return(void *)ip;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x2140
movq %rax, %r14
testq %rax, %rax
je 0x113c3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x958f(%rip), %rax      # 0x1a959
movq %rax, 0x1126f(%rip)     # 0x22640
movl $0x6b, 0x1125d(%rip)    # 0x22638
leaq 0x9598(%rip), %rdi      # 0x1a97a
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x24b8
jmp 0x113ba
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/nsc.c
// Function: myrealloc
void * myrealloc(const char * filename, const int linenr,
                 void * ptr, size_t size) {
  int * ip;
  ip = (int *) realloc(ptr, size);
  if(ip) return(ip);
  else ERROR("REALLOC : failed in file %s at line %d", filename, linenr);
  return(void*)ip;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x21a0
movq %rax, %r14
testq %rax, %rax
je 0x11416
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x953c(%rip), %rax      # 0x1a959
movq %rax, 0x1121c(%rip)     # 0x22640
movl $0x75, 0x1120a(%rip)    # 0x22638
leaq 0x956b(%rip), %rdi      # 0x1a9a0
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x24b8
jmp 0x1140d
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/nsc.c
// Function: icosaeder_vertices
void icosaeder_vertices(double *xus) {
  rh = sqrt(1.-2.*cos(TORAD(72.)))/(1.-cos(TORAD(72.)));
  rg = cos(TORAD(72.))/(1.-cos(TORAD(72.)));
/* icosaeder vertices */
  xus[ 0] = 0.;                  xus[ 1] = 0.;                  xus[ 2] = 1.;
  xus[ 3] = rh*cos(TORAD(72.));  xus[ 4] = rh*sin(TORAD(72.));  xus[ 5] = rg;
  xus[ 6] = rh*cos(TORAD(144.)); xus[ 7] = rh*sin(TORAD(144.)); xus[ 8] = rg;
  xus[ 9] = rh*cos(TORAD(216.)); xus[10] = rh*sin(TORAD(216.)); xus[11] = rg;
  xus[12] = rh*cos(TORAD(288.)); xus[13] = rh*sin(TORAD(288.)); xus[14] = rg;
  xus[15] = rh;                  xus[16] = 0;                   xus[17] = rg;
  xus[18] = rh*cos(TORAD(36.));  xus[19] = rh*sin(TORAD(36.));  xus[20] = -rg;
  xus[21] = rh*cos(TORAD(108.)); xus[22] = rh*sin(TORAD(108.)); xus[23] = -rg;
  xus[24] = -rh;                 xus[25] = 0;                   xus[26] = -rg;
  xus[27] = rh*cos(TORAD(252.)); xus[28] = rh*sin(TORAD(252.)); xus[29] = -rg;
  xus[30] = rh*cos(TORAD(324.)); xus[31] = rh*sin(TORAD(324.)); xus[32] = -rg;
  xus[33] = 0.;                  xus[34] = 0.;                  xus[35] = -1.;
  }

// Assembly:
movabsq $0x3fec9f25d83b2f4b, %rax # imm = 0x3FEC9F25D83B2F4B
movq %rax, 0x111f4(%rip)     # 0x22648
movabsq $0x3fdc9f257bd2e79a, %rax # imm = 0x3FDC9F257BD2E79A
movq %rax, 0x111eb(%rip)     # 0x22650
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movaps 0x933e(%rip), %xmm1     # 0x1a7b0
movups %xmm1, 0x10(%rdi)
movabsq $0x3feb388821fab2fd, %rcx # imm = 0x3FEB388821FAB2FD
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movaps 0x9331(%rip), %xmm1     # 0x1a7c0
movups %xmm1, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movaps 0x9332(%rip), %xmm1     # 0x1a7d0
movups %xmm1, 0x48(%rdi)
movq %rax, 0x58(%rdi)
movaps 0x9333(%rip), %xmm1     # 0x1a7e0
movups %xmm1, 0x60(%rdi)
movq %rax, 0x70(%rdi)
movsd 0x93c3(%rip), %xmm1     # 0x1a880
movups %xmm1, 0x78(%rdi)
movq %rax, 0x88(%rdi)
movaps 0x9321(%rip), %xmm1     # 0x1a7f0
movups %xmm1, 0x90(%rdi)
movabsq $-0x402360da842d1866, %rax # imm = 0xBFDC9F257BD2E79A
movq %rax, 0xa0(%rdi)
movaps 0x9312(%rip), %xmm1     # 0x1a800
movups %xmm1, 0xa8(%rdi)
movq %rax, 0xb8(%rdi)
movsd 0x9384(%rip), %xmm1     # 0x1a888
movups %xmm1, 0xc0(%rdi)
movq %rax, 0xd0(%rdi)
movaps 0x92f7(%rip), %xmm1     # 0x1a810
movups %xmm1, 0xd8(%rdi)
movq %rax, 0xe8(%rdi)
movaps 0x92f2(%rip), %xmm1     # 0x1a820
movups %xmm1, 0xf0(%rdi)
movq %rax, 0x100(%rdi)
movups %xmm0, 0x108(%rdi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x118(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/nsc.c
// Function: unsp_type
int unsp_type(int densit) {
  int i1, i2;
  i1 = 1;
  while (10*i1*i1+2 < densit) i1++;
  i2 = 1;
  while (30*i2*i2+2 < densit) i2++;
  if (10*i1*i1-2 < 30*i2*i2-2) return UNSP_ICO_ARC;
  else return UNSP_ICO_DOD;
  }

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

  register int i;
  SSBOND *ptr;

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

  return(FAILURE);
}

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

// Assembly:
movss 0x10(%rsp), %xmm8
movss 0x8(%rsp), %xmm9
movaps %xmm1, %xmm10
subss %xmm8, %xmm10
ucomiss %xmm10, %xmm0
jb 0x15435
movaps %xmm1, %xmm10
addss %xmm8, %xmm10
ucomiss %xmm0, %xmm10
jb 0x15435
movaps %xmm3, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm2
jb 0x15435
movaps %xmm3, %xmm10
addss %xmm9, %xmm10
ucomiss %xmm2, %xmm10
jb 0x15435
movaps %xmm5, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm4
jb 0x15435
movaps %xmm5, %xmm10
addss %xmm9, %xmm10
ucomiss %xmm4, %xmm10
jb 0x15435
movaps %xmm7, %xmm10
subss %xmm9, %xmm10
ucomiss %xmm10, %xmm6
jb 0x15435
movaps %xmm7, %xmm10
addss %xmm9, %xmm10
movl $0x1, %eax
ucomiss %xmm6, %xmm10
jb 0x15435
retq
movaps %xmm1, %xmm10
subss %xmm9, %xmm10
addss %xmm9, %xmm1
cmpleps %xmm0, %xmm10
cmpleps %xmm1, %xmm0
andps %xmm10, %xmm0
movd %xmm0, %ecx
testb $0x1, %cl
je 0x15553
movaps %xmm3, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm2
jb 0x154b0
movaps %xmm3, %xmm0
addss %xmm8, %xmm0
ucomiss %xmm2, %xmm0
jb 0x154b0
movaps %xmm5, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm4
jb 0x154b0
movaps %xmm5, %xmm0
addss %xmm9, %xmm0
ucomiss %xmm4, %xmm0
jb 0x154b0
movaps %xmm7, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm6
jb 0x154b0
movaps %xmm7, %xmm0
addss %xmm9, %xmm0
movl $0x1, %eax
ucomiss %xmm6, %xmm0
jae 0x15434
testb $0x1, %cl
je 0x15553
movaps %xmm3, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm2
addss %xmm9, %xmm3
jb 0x1550d
ucomiss %xmm2, %xmm3
jb 0x1550d
movaps %xmm5, %xmm1
subss %xmm8, %xmm1
ucomiss %xmm1, %xmm4
jb 0x1550d
movaps %xmm5, %xmm1
addss %xmm8, %xmm1
ucomiss %xmm4, %xmm1
jb 0x1550d
movaps %xmm7, %xmm1
subss %xmm9, %xmm1
ucomiss %xmm1, %xmm6
jb 0x1550d
movaps %xmm7, %xmm1
addss %xmm9, %xmm1
movl $0x1, %eax
ucomiss %xmm6, %xmm1
jae 0x15434
testb $0x1, %cl
je 0x15553
ucomiss %xmm0, %xmm2
jb 0x15553
ucomiss %xmm2, %xmm3
jb 0x15553
movaps %xmm5, %xmm0
subss %xmm9, %xmm0
ucomiss %xmm0, %xmm4
jb 0x15553
addss %xmm9, %xmm5
ucomiss %xmm4, %xmm5
jb 0x15553
movaps %xmm7, %xmm0
subss %xmm8, %xmm0
ucomiss %xmm0, %xmm6
jb 0x15553
addss %xmm8, %xmm7
movl $0x1, %eax
ucomiss %xmm6, %xmm7
jae 0x15434
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/dssp.c
// Function: CompPdbDssp
int CompPdbDssp(CHAIN *Chain, DSSP *Dssp)
{

  int Res, CA;

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

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

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

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

  return(SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5101(%rip), %rdx      # 0x1ae48
leaq 0x4(%rsp), %rcx
xorl %esi, %esi
callq 0x4f78
testl %eax, %eax
jne 0x15d62
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15ded
movl (%r14), %esi
cmpl $0x2, %esi
jl 0x15d8f
decl %esi
leaq 0x50d5(%rip), %rdx      # 0x1ae48
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
callq 0x4f78
testl %eax, %eax
jne 0x15d8f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15e97
movslq (%r14), %r15
testq %r15, %r15
jle 0x15dc5
movq 0x68(%r14), %r12
movq 0x408(%rbx), %r13
xorl %r14d, %r14d
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rdi
addq $0xa, %rdi
movq (%r13,%rbp,8), %rsi
callq 0x2150
testl %eax, %eax
jne 0x15ddb
incq %rbp
cmpq %rbp, %r15
jne 0x15da7
movl $0x1, %r14d
cmpl 0x404(%rbx), %r15d
je 0x15ddb
movl %r15d, 0x404(%rbx)
movl %r14d, %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/dssp.c
// Function: InsertFirst
void InsertFirst(DSSP *Dssp, CHAIN *Chain)
{
  int Res;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x404(%rdi), %r15
testq %r15, %r15
jle 0x15e4d
incq %r15
movq 0x408(%rbx), %rax
movq -0x10(%rax,%r15,8), %rsi
movq -0x8(%rax,%r15,8), %rdi
callq 0x2070
movq 0x418(%rbx), %rax
movq -0x10(%rax,%r15,8), %rsi
movq -0x8(%rax,%r15,8), %rdi
callq 0x2070
movq 0x410(%rbx), %rax
movb -0x2(%rax,%r15), %cl
movb %cl, -0x1(%rax,%r15)
decq %r15
cmpq $0x1, %r15
jg 0x15e07
movq 0x408(%rbx), %rax
movq (%rax), %rdi
movq 0x68(%r14), %rax
movq (%rax), %rsi
addq $0xa, %rsi
callq 0x2070
movq 0x418(%rbx), %rax
movq (%rax), %rdi
movq 0x68(%r14), %rax
movq (%rax), %rsi
addq $0x4, %rsi
callq 0x2070
movq 0x410(%rbx), %rax
movb $0x43, (%rax)
incl 0x404(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/dssp.c
// Function: InsertLast
void InsertLast(DSSP *Dssp, CHAIN *Chain)
{

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x408(%rdi), %rax
movslq 0x404(%rdi), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x68(%rsi), %rax
movq (%rax,%rcx,8), %rsi
addq $0xa, %rsi
callq 0x2070
movq 0x418(%r14), %rax
movslq 0x404(%r14), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x68(%rbx), %rax
movq (%rax,%rcx,8), %rsi
addq $0x4, %rsi
callq 0x2070
movq 0x410(%r14), %rax
movslq 0x404(%r14), %rcx
movb $0x43, (%rax,%rcx)
incl 0x404(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/outseq.c
// Function: OutSeq
int OutSeq(CHAIN **Chain, int NChain, COMMAND *Cmd)
{
  int Cn, Res;
  FILE *Seq;

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

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

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

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

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

  return(SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
addq $0x802, %r15            # imm = 0x802
movq %r15, %rdi
callq 0x20b0
testl %eax, %eax
jne 0x16102
movq 0xaed3(%rip), %rax      # 0x20fd0
movq (%rax), %r14
jmp 0x1612d
leaq 0x39a8(%rip), %rsi      # 0x19ab1
movq %r15, %rdi
callq 0x21b0
movq %rax, %r14
testq %rax, %rax
jne 0x1612d
leaq 0x4c2d(%rip), %rdi      # 0x1ad4d
xorl %r14d, %r14d
movq %r15, %rsi
xorl %eax, %eax
callq 0x8900
testl %ebp, %ebp
jle 0x161fa
movl %ebp, %r13d
xorl %ebp, %ebp
movl $0x88888889, %r15d      # imm = 0x88888889
movq (%rbx,%rbp,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x161ee
movq 0x48(%rax), %r12
movsbl 0x40(%rax), %edi
callq 0x517a
movsbl %al, %ecx
movq (%rbx,%rbp,8), %rax
movl (%rax), %r8d
xorps %xmm0, %xmm0
cvtss2sd 0x50(%rax), %xmm0
movq %r14, %rdi
leaq 0x4bf6(%rip), %rsi      # 0x1ad6d
movq %r12, %rdx
movb $0x1, %al
callq 0x2160
movq (%rbx,%rbp,8), %rax
cmpl $0x0, (%rax)
jle 0x161e1
xorl %r12d, %r12d
testq %r12, %r12
je 0x161b2
movl %r12d, %eax
imulq %r15, %rax
shrq $0x25, %rax
imull $-0x3c, %eax, %eax
addl %r12d, %eax
jne 0x161b2
movl $0xa, %edi
movq %r14, %rsi
callq 0x2110
movq (%rbx,%rbp,8), %rax
movq 0x68(%rax), %rax
movq (%rax,%r12,8), %rdi
addq $0xa, %rdi
callq 0x4ba4
movsbl %al, %edi
movq %r14, %rsi
callq 0x2110
incq %r12
movq (%rbx,%rbp,8), %rax
movslq (%rax), %rax
cmpq %rax, %r12
jl 0x1618d
movl $0xa, %edi
movq %r14, %rsi
callq 0x2110
incq %rbp
cmpq %r13, %rbp
jne 0x16140
movq %r14, %rdi
callq 0x20a0
xorl %edi, %edi
callq 0x2230
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/elem.c
// Function: CompareElements
int CompareElements(char *Asn1, char *Asn2, char *Asn3, int Length, 
		   char SecStrType, int *Better, int *Worse)
{

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

  *Better = 0;
  *Worse = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x20(%rsp)
movq 0x38(%rsp), %rdx
xorl %eax, %eax
movq %r9, -0x10(%rsp)
movl %eax, (%r9)
movl %eax, (%rdx)
testl %ecx, %ecx
jle 0x16e54
leal -0x1(%rcx), %eax
movq %rax, -0x8(%rsp)
movl %ecx, %r9d
xorl %ebx, %ebx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0x1, %ebp
xorl %eax, %eax
movq %r9, -0x18(%rsp)
movb (%rdi,%rbx), %cl
cmpb %r8b, %cl
je 0x16d3a
cmpb %r8b, (%rsi,%rbx)
je 0x16d3a
movq -0x20(%rsp), %rdx
cmpb %r8b, (%rdx,%rbx)
jne 0x16d61
testq %rbx, %rbx
je 0x16e08
cmpb %r8b, -0x1(%rbx,%rdi)
je 0x16d61
cmpb %r8b, -0x1(%rsi,%rbx)
je 0x16d61
movq -0x20(%rsp), %rdx
cmpb %r8b, -0x1(%rdx,%rbx)
jne 0x16e08
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
je 0x16e43
cmpq -0x8(%rsp), %rbx
jne 0x16e0f
movl %eax, -0x24(%rsp)
movq %rsi, %rax
movslq %r15d, %r12
xorl %r11d, %r11d
movl $0x0, %ecx
cmpq %r12, %rbx
jl 0x16dee
leaq (%rdi,%r12), %r13
leaq (%rax,%r12), %r10
addq -0x20(%rsp), %r12
movl %ebp, %r9d
subl %r15d, %r9d
xorl %r15d, %r15d
xorl %ecx, %ecx
xorl %r11d, %r11d
movb (%r13,%r15), %dl
cmpb %r8b, %dl
je 0x16dbe
cmpb %r8b, (%r10,%r15)
jne 0x16dcb
xorl %esi, %esi
cmpb (%r10,%r15), %dl
setne %sil
addl %esi, %r11d
movb (%r12,%r15), %dl
cmpb %r8b, %dl
je 0x16dda
cmpb %r8b, (%r10,%r15)
jne 0x16de6
xorl %esi, %esi
cmpb (%r10,%r15), %dl
setne %sil
addl %esi, %ecx
incq %r15
cmpl %r15d, %r9d
jne 0x16dae
cmpl %ecx, %r11d
jle 0x16e2e
movq 0x38(%rsp), %rcx
incl (%rcx)
movq %rax, %rsi
movq -0x18(%rsp), %r9
movl -0x24(%rsp), %eax
jmp 0x16e43
incl %eax
movl %ebx, %r14d
jmp 0x16e43
cmpb %r8b, %cl
je 0x16e29
cmpb %r8b, (%rsi,%rbx)
je 0x16e29
movq -0x20(%rsp), %rcx
cmpb %r8b, (%rcx,%rbx)
jne 0x16d7c
movl %r15d, %r14d
jmp 0x16e43
movq %rax, %rsi
movl -0x24(%rsp), %eax
jge 0x16e3e
movq -0x10(%rsp), %rcx
incl (%rcx)
movq -0x18(%rsp), %r9
incq %rbx
incl %ebp
movl %r14d, %r15d
cmpq %r9, %rbx
jne 0x16d21
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/asngener.c
// Function: CorrectAsn
void CorrectAsn(char *Asn, int Length, char SecStrType, char EditChar, int MaxLength)
{

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xfa0, %rsp            # imm = 0xFA0
movl %r8d, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x17dab
movl %esi, %esi
xorl %edi, %edi
xorl %r8d, %r8d
xorl %eax, %eax
movb (%r14,%rdi), %r9b
cmpb %dl, %r9b
sete %r10b
testl %r8d, %r8d
sete %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x17d78
movslq %eax, %r8
movl %edi, (%rsp,%r8,8)
movl $0x1, %r8d
jmp 0x17da1
cmpb %dl, %r9b
setne %r9b
cmpl $0x1, %r8d
sete %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x17da1
movslq %eax, %r8
incl %eax
leal -0x1(%rdi), %r9d
movl %r9d, 0x4(%rsp,%r8,8)
xorl %r8d, %r8d
incq %rdi
cmpq %rdi, %rsi
jne 0x17d4e
jmp 0x17dad
xorl %eax, %eax
testl %eax, %eax
jle 0x17de9
movl %eax, %r15d
xorl %r12d, %r12d
movzbl %cl, %ebp
movl (%rsp,%r12,8), %ecx
movl 0x4(%rsp,%r12,8), %edx
movl %edx, %eax
subl %ecx, %eax
cmpl %ebx, %eax
jge 0x17de1
cmpl %ecx, %edx
jl 0x17de1
movslq %ecx, %rdi
addq %r14, %rdi
movl %eax, %edx
incq %rdx
movl %ebp, %esi
callq 0x20f0
incq %r12
cmpq %r12, %r15
jne 0x17dba
addq $0xfa0, %rsp            # imm = 0xFA0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/asngener.c
// Function: CorrectAsnDouble
void CorrectAsnDouble(char *Asn1, char *Asn2, char *KnownAsn, int Length, 
		      char SecStrType, char EditChar)
{

  register int Res;

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

// Assembly:
testl %ecx, %ecx
jle 0x17e84
pushq %rbp
pushq %rbx
leal -0x1(%rcx), %eax
movslq %eax, %r10
movl %ecx, %ecx
xorl %r11d, %r11d
cmpb %r8b, (%rdi,%r11)
je 0x17e1a
cmpb %r8b, (%rsi,%r11)
jne 0x17e7a
cmpb %r8b, (%rdx,%r11)
je 0x17e7a
testq %r11, %r11
jne 0x17e31
cmpb %r8b, 0x1(%rdi)
je 0x17e31
cmpb %r8b, 0x1(%rsi)
jne 0x17e72
cmpq %r11, %rax
jne 0x17e44
cmpb %r8b, -0x1(%rdi,%r11)
je 0x17e44
cmpb %r8b, -0x1(%rsi,%r11)
jne 0x17e72
testq %r11, %r11
sete %bl
cmpq %r10, %r11
setge %bpl
orb %bl, %bpl
jne 0x17e7a
cmpb %r8b, -0x1(%rdi,%r11)
je 0x17e7a
cmpb %r8b, -0x1(%rsi,%r11)
je 0x17e7a
cmpb %r8b, 0x1(%rdi,%r11)
je 0x17e7a
cmpb %r8b, 0x1(%rsi,%r11)
je 0x17e7a
movb %r9b, (%rsi,%r11)
movb %r9b, (%rdi,%r11)
incq %r11
cmpq %r11, %rcx
jne 0x17e0e
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/asngener.c
// Function: Difference
int Difference(char *TestAsn, char *KnownAsn, int Length, char SecStrType, QUALITY *Qual)
{
  register int Res;

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

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

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

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

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

  return(SUCCESS);
}

// Assembly:
pushq %r14
pushq %rbx
leaq 0xc(%r8), %rax
leaq 0x8(%r8), %r9
leaq 0x4(%r8), %r10
xorps %xmm0, %xmm0
movups %xmm0, (%r8)
testl %edx, %edx
jle 0x17ef2
movl %edx, %edx
xorl %r11d, %r11d
movb (%rsi,%r11), %bl
cmpb $0x58, %bl
je 0x17ee2
cmpb %cl, %bl
jne 0x17ebe
movq %r8, %r14
cmpb %cl, (%rdi,%r11)
je 0x17edf
cmpb %cl, %bl
je 0x17ecb
movq %r10, %r14
cmpb %cl, (%rdi,%r11)
jne 0x17edf
cmpb %cl, %bl
jne 0x17ed6
movq %rax, %r14
cmpb %cl, (%rdi,%r11)
jne 0x17edf
jmp 0x17ee2
movq %r9, %r14
cmpb %cl, (%rdi,%r11)
jne 0x17eec
incl (%r14)
incq %r11
cmpq %r11, %rdx
jne 0x17ea4
jmp 0x17ef2
cmpb %cl, %bl
je 0x17ecb
jmp 0x17ee2
movl (%r8), %ecx
testl %ecx, %ecx
jne 0x17f0a
cmpl $0x0, (%r10)
jne 0x17f0a
cmpl $0x0, (%r9)
jne 0x17f0a
cmpl $0x0, (%rax)
je 0x17f41
cvtsi2ss %ecx, %xmm1
xorps %xmm0, %xmm0
cvtsi2ssl (%r10), %xmm0
cvtsi2ssl (%r9), %xmm2
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl (%rax), %xmm1
addss %xmm0, %xmm2
addss %xmm2, %xmm1
divss %xmm1, %xmm0
movl $0x1, %eax
movss %xmm0, 0x14(%r8)
popq %rbx
popq %r14
retq
xorl %eax, %eax
xorps %xmm0, %xmm0
jmp 0x17f37
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/asngener.c
// Function: PercentCorrect
float PercentCorrect(char *TestAsn, char *KnownAsn, int Length)
{
  int Res, Count=0;;

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

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

// Assembly:
testl %edx, %edx
jle 0x17f74
movl %edx, %eax
xorl %ecx, %ecx
xorl %r8d, %r8d
movb (%rsi,%rcx), %r9b
xorl %r10d, %r10d
cmpb (%rdi,%rcx), %r9b
sete %r10b
addl %r10d, %r8d
incq %rcx
cmpq %rcx, %rax
jne 0x17f53
cvtsi2ss %r8d, %xmm0
jmp 0x17f77
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm1
divss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/asngener.c
// Function: AssessCorr
int AssessCorr(QUALITY *Qual)
{

  float TP, TN, FP, FN;

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

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

    return(SUCCESS);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x18027
cvtsi2ss %ecx, %xmm0
cvtsi2ssl 0x4(%rbx), %xmm1
movsd 0x8(%rbx), %xmm2
cvtdq2ps %xmm2, %xmm2
movaps %xmm2, %xmm3
shufps $0x55, %xmm2, %xmm3     # xmm3 = xmm3[1,1],xmm2[1,1]
movaps %xmm2, %xmm4
mulss %xmm3, %xmm4
movaps %xmm0, %xmm5
mulss %xmm1, %xmm5
subss %xmm4, %xmm5
xorps %xmm4, %xmm4
cvtss2sd %xmm5, %xmm4
addss %xmm1, %xmm3
addss %xmm2, %xmm1
mulss %xmm3, %xmm1
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
addps %xmm2, %xmm0
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
mulss %xmm1, %xmm2
mulss %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x17ffb
sqrtsd %xmm0, %xmm0
jmp 0x1800c
movsd %xmm4, 0x8(%rsp)
callq 0x2250
movsd 0x8(%rsp), %xmm4
divsd %xmm0, %xmm4
xorps %xmm0, %xmm0
cvtsd2ss %xmm4, %xmm0
movss %xmm0, 0x10(%rbx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
xorl %eax, %eax
cmpl $0x0, 0xc(%rbx)
je 0x18021
testl %ecx, %ecx
jne 0x17f92
cmpl $0x0, 0x8(%rbx)
jne 0x17f92
jmp 0x18021
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/asngener.c
// Function: AssessPerc
int AssessPerc(QUALITY *Qual)
{

  float TP, TN, FP, FN;

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

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

  return(SUCCESS);
}

// Assembly:
movsd (%rdi), %xmm0
cvtsi2ssl 0x8(%rdi), %xmm1
cvtdq2ps %xmm0, %xmm0
cvtsi2ssl 0xc(%rdi), %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
addss %xmm0, %xmm3
addss %xmm3, %xmm1
addss %xmm2, %xmm1
divss %xmm1, %xmm3
movss %xmm3, 0x14(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/asngener.c
// Function: ExcludeObvious
void ExcludeObvious(char *Asn1, char *Asn2, char *KnownAsn, int Length)
{
  register int i;

  for( i=0; i<Length; i++ )
    if( Asn1[i] == Asn2[i] ) {
      KnownAsn[i] = 'X';
      Asn1[i] = 'X';
      Asn2[i] = 'X';
    }
}

// Assembly:
testl %ecx, %ecx
jle 0x1809f
movl %ecx, %eax
xorl %ecx, %ecx
movb $0x58, %r8b
movb (%rdi,%rcx), %r9b
cmpb (%rsi,%rcx), %r9b
jne 0x18097
movb %r8b, (%rdx,%rcx)
movb %r8b, (%rdi,%rcx)
movb %r8b, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x18081
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/p_endmdl.c
// Function: Process_ENDMDL
int Process_ENDMDL(BUFFER Buffer, CHAIN **Chain, int *ChainNumber)
{

  int CC;

  for( CC=0; CC < *ChainNumber; CC++ )
    Chain[CC]->Ter = 1;
  
  return(SUCCESS);
}

// Assembly:
cmpl $0x0, (%rdx)
jle 0x180bd
xorl %eax, %eax
movq (%rsi,%rax,8), %rcx
movl $0x1, 0xc(%rcx)
incq %rax
movslq (%rdx), %rcx
cmpq %rcx, %rax
jl 0x180a7
movl $0x1, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/stred.c
// Function: Replace
int Replace(char *String, char From, char To)
{

  int Replaced=0;

  if( From == '\0' )
    return(Replaced);

  for( ; *String != '\0'; String++ )
    if( *String == From ) {
      *String = To;
    Replaced++;
    }

  return(Replaced);
}

// Assembly:
xorl %eax, %eax
testb %sil, %sil
je 0x180e9
movb (%rdi), %cl
testb %cl, %cl
je 0x180e9
incq %rdi
xorl %eax, %eax
cmpb %sil, %cl
jne 0x180e0
movb %dl, -0x1(%rdi)
incl %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x180d6
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/stred.c
// Function: Delete
int Delete(char *String, char From)
{
  
  int Deleted = 0;
  char *c;
  
  if( From == '\0' )
    return(Deleted);
  
  for( ; *String != '\0'; String++ )
    if( *String == From ) {
      c = String;
      for( ;; c++ ) {
	*c = *(c+1);
	if( *c == '\0' ) 
	  break;
      }
      Deleted++;
      String--;
    }
  return(Deleted);
}

// Assembly:
xorl %eax, %eax
testb %sil, %sil
je 0x1811d
movb (%rdi), %cl
testb %cl, %cl
je 0x1811d
xorl %eax, %eax
cmpb %sil, %cl
jne 0x18113
leaq 0x1(%rdi), %rcx
movb (%rcx), %dl
movb %dl, -0x1(%rcx)
incq %rcx
testb %dl, %dl
jne 0x18102
incl %eax
decq %rdi
movb 0x1(%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x180f9
retq
nop
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/contact_map.c
// Function: ContactMap
void ContactMap(CHAIN **Chain, int NChain, COMMAND *Cmd )
{

  register int Res1, Res2;
  int Cn1, Cn2, CA1, CA2;
  float D;
  
  for( Cn1=0; Cn1<NChain; Cn1++ ) {
    
    if( !Chain[Cn1]->Valid )
      continue;


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

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

      for( Res1=0; Res1<Chain[Cn1]->NRes; Res1++ ) {

	if( !FindAtom(Chain[Cn1],Res1,"CA",&CA1) )
	  continue;

	for( Res2=0; Res2<Chain[Cn2]->NRes; Res2++ ) {
	  
	  if( !FindAtom(Chain[Cn2],Res2,"CA",&CA2) )
	    continue;

	  D = Dist(Chain[Cn1]->Rsd[Res1]->Coord[CA1],
		   Chain[Cn2]->Rsd[Res2]->Coord[CA2]);
	  printf("%c %d <-> %c %d : %7.3f\n",
		 SpaceToDash(Chain[Cn1]->Id),Res1,
		 SpaceToDash(Chain[Cn2]->Id),Res2,D);
	}
      }
    }
  }
  exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x18692
movq %rdi, %rbx
movl %esi, %eax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x18684
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x18676
movq (%rbx,%r12,8), %rdi
cmpl $0x0, (%rdi)
jle 0x18676
xorl %ebp, %ebp
movl %ebp, %esi
leaq 0x28be(%rip), %rdx      # 0x1ae48
leaq 0xc(%rsp), %rcx
callq 0x4f78
testl %eax, %eax
je 0x18663
movq (%rbx,%r14,8), %rdi
cmpl $0x0, (%rdi)
jle 0x18663
xorl %r15d, %r15d
movl %r15d, %esi
leaq 0x2892(%rip), %rdx      # 0x1ae48
leaq 0x8(%rsp), %rcx
callq 0x4f78
testl %eax, %eax
je 0x18650
movq (%rbx,%r12,8), %rax
movq 0x68(%rax), %rax
movslq 0xc(%rsp), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x2, %rdi
addq (%rax,%rbp,8), %rdi
movl $0x188, %edx            # imm = 0x188
addq %rdx, %rdi
movq (%rbx,%r14,8), %rax
movq 0x68(%rax), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rsi
shlq $0x2, %rsi
addq (%rax,%r15,8), %rsi
addq %rdx, %rsi
callq 0x40d5
movss %xmm0, 0x4(%rsp)
movq (%rbx,%r12,8), %rax
movsbl 0x40(%rax), %edi
callq 0x517a
movsbl %al, %r13d
movq (%rbx,%r14,8), %rax
movsbl 0x40(%rax), %edi
callq 0x517a
movsbl %al, %ecx
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
leaq 0x2b16(%rip), %rdi      # 0x1b157
movl %r13d, %esi
movl %ebp, %edx
movl %r15d, %r8d
movb $0x1, %al
callq 0x20d0
incq %r15
movq (%rbx,%r14,8), %rdi
movslq (%rdi), %rax
cmpq %rax, %r15
jl 0x185ac
incq %rbp
movq (%rbx,%r12,8), %rdi
movslq (%rdi), %rax
cmpq %rax, %rbp
jl 0x18581
incq %r14
cmpq 0x10(%rsp), %r14
jne 0x18564
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x18553
xorl %edi, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_03/syscalls.c
// Function: main
int main(void)
{
  FILE *file_in_p;
  FILE *file_out_p;

  if ((file_in_p = file_open("syscalls.c", "r")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  if ((file_out_p = file_open("out.txt", "w")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }

  char c;
  while ((c = getc(file_in_p)) != EOF)
  {
    putc(c, file_out_p);
  }
  file_close(file_in_p);
  file_close(file_out_p);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0xbf0(%rip), %rdi       # 0x2020
leaq 0xbf4(%rip), %rsi       # 0x202b
callq 0x12da
testq %rax, %rax
je 0x14b0
movq %rax, %rbx
leaq 0xc03(%rip), %rdi       # 0x204e
leaq 0xc04(%rip), %rsi       # 0x2056
callq 0x12da
testq %rax, %rax
je 0x14b0
movq %rax, %r14
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
testl %eax, %eax
jle 0x147a
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
jmp 0x1482
movq %rbx, %rdi
callq 0x11ac
cmpb $-0x1, %al
je 0x14cd
movl (%r14), %ecx
leal -0x1(%rcx), %edx
movl %edx, (%r14)
testl %ecx, %ecx
jle 0x14a3
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %al, (%rcx)
jmp 0x145f
movsbl %al, %edi
movq %r14, %rsi
callq 0x1226
jmp 0x145f
leaq 0xb76(%rip), %rsi       # 0x202d
movl $0x1, %ebp
movl $0x21, %edx
movl $0x1, %edi
callq 0x1040
jmp 0x1506
movq 0x10(%rbx), %rdi
callq 0x1030
xorl %ebp, %ebp
movl %ebp, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movl 0x1c(%rbx), %edi
callq 0x1060
movq 0x10(%r14), %rdi
callq 0x1030
movl %ebp, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movl 0x1c(%r14), %edi
callq 0x1060
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/main.c
// Function: master_loop
int		master_loop(t_control *control)
{
	t_list	*tokens_list;
	t_btree	*ast;

	while (!control->quit)
	{
		if (!termios_enable_raw_mode(control, &control->termios_default))
			break ;
		tokens_list = input_root(control);
		if (!termios_reset_cooked_mode(control, &control->termios_default))
			break ;
		if (control->quit || control->ctrl_c || control->lexer_end.unexpected)
			continue;
		ast = parser_root(tokens_list, control);
		if (control->quit)
			break ;
		exe_root(ast, control);
		btree_clear(&ast, del_token);
	}
	return (control->exit_status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0x1, (%rdi)
jne 0x23c5
leaq 0x3c(%rbx), %r14
leaq 0x42d(%rip), %r15       # 0x2789
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40c4
testl %eax, %eax
je 0x23c5
movq %rbx, %rdi
callq 0x3dc4
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x418b
testl %eax, %eax
je 0x23c5
testb $0x3, (%rbx)
jne 0x23c0
cmpl $0x0, 0x2c(%rbx)
jne 0x23c0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x61a4
movq %rax, 0x8(%rsp)
testb $0x1, (%rbx)
jne 0x23c5
movq %rax, %rdi
movq %rbx, %rsi
callq 0x64f8
movq %r12, %rdi
movq %r15, %rsi
callq 0xaed8
testb $0x1, (%rbx)
je 0x2361
movl 0x4(%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/main.c
// Function: main
int		main(void)
{
	int				exit_status;
	t_control		control;

	ft_signalhandler_enable();
	if (!control_init_struct(&control) ||
		!(termios_enable_raw_mode(&control, &control.termios_default)))
	{
		ft_perror(NULL, NULL, errno ? strerror(errno) : "Couldn't initialize");
		control_free_struct(&control);
		return (1);
	}
	exit_status = master_loop(&control);
	control_free_struct(&control);
	terminfo_reset_terminal();
	termios_reset_cooked_mode(&control, &control.termios_default);
	return (exit_status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
callq 0x8ea5
movq %rsp, %rdi
callq 0x5c68
testl %eax, %eax
je 0x242d
leaq 0x3c(%rsp), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x40c4
testl %eax, %eax
je 0x242d
movq %rsp, %r14
movq %r14, %rdi
callq 0x233c
movl %eax, %ebp
movq %r14, %rdi
callq 0x5dca
callq 0x438f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x418b
jmp 0x245f
callq 0x2040
movl (%rax), %edi
testl %edi, %edi
je 0x2442
callq 0x2220
movq %rax, %rdx
jmp 0x2449
leaq 0x8bbb(%rip), %rdx      # 0xb004
xorl %edi, %edi
xorl %esi, %esi
callq 0x2511
movq %rsp, %rdi
callq 0x5dca
movl $0x1, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_fork
void	ft_fork(pid_t *pid)
{
	*pid = fork();
	if (*pid == -1)
		ft_exit("fork", NULL, strerror(errno), EXIT_FAILURE);
	errno = 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2230
movl %eax, %ebp
movl %eax, (%rbx)
callq 0x2040
cmpl $-0x1, %ebp
je 0x24d9
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl (%rax), %edi
callq 0x2220
leaq 0x8b36(%rip), %rdi      # 0xb01d
xorl %esi, %esi
movq %rax, %rdx
callq 0x2511
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_perror
int		ft_perror(char *cmd, char *param, char *str)
{
	const int fd = STDERR_FILENO;

	ft_putstr_fd("\033[0;91m", fd);
	ft_putstr_fd("minishell: ", fd);
	if (cmd)
	{
		ft_putstr_fd(cmd, fd);
		ft_putstr_fd(": ", fd);
	}
	if (param)
	{
		ft_putstr_fd("`", fd);
		ft_putstr_fd(param, fd);
		ft_putstr_fd("': ", fd);
	}
	if (errno && !str)
		str = strerror(errno);
	if (str)
	{
		ft_putstr_fd("Error: ", fd);
		ft_putendl_fd(str, fd);
	}
	ft_putstr_fd("\033[0m", fd);
	return (-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8afc(%rip), %rdi      # 0xb022
movl $0x2, %esi
callq 0x9f24
leaq 0x8af3(%rip), %rdi      # 0xb02a
movl $0x2, %esi
callq 0x9f24
testq %r15, %r15
je 0x2564
movq %r15, %rdi
movl $0x2, %esi
callq 0x9f24
leaq 0x8f14(%rip), %rdi      # 0xb46e
movl $0x2, %esi
callq 0x9f24
testq %r14, %r14
je 0x2598
leaq 0x8d03(%rip), %rdi      # 0xb273
movl $0x2, %esi
callq 0x9f24
movq %r14, %rdi
movl $0x2, %esi
callq 0x9f24
leaq 0x8aa8(%rip), %rdi      # 0xb036
movl $0x2, %esi
callq 0x9f24
callq 0x2040
movl (%rax), %edi
testl %edi, %edi
sete %al
testq %rbx, %rbx
setne %cl
orb %al, %cl
jne 0x25b6
callq 0x2220
movq %rax, %rbx
testq %rbx, %rbx
je 0x25d9
leaq 0x8a78(%rip), %rdi      # 0xb03a
movl $0x2, %esi
callq 0x9f24
movq %rbx, %rdi
movl $0x2, %esi
callq 0x9e78
leaq 0x966a(%rip), %rdi      # 0xbc4a
movl $0x2, %esi
callq 0x9f24
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/minishell_utils.c
// Function: ft_ambiguous_redirect
void	ft_ambiguous_redirect(char *str, int fd)
{
	ft_putstr_fd("\033[0;91m", fd);
	ft_putstr_fd("minishell: ", fd);
	ft_putstr_fd(str, fd);
	ft_putstr_fd(": ambiguous redirect\n", fd);
	ft_putstr_fd("\033[0m", fd);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8a1d(%rip), %rdi      # 0xb022
callq 0x9f24
leaq 0x8a19(%rip), %rdi      # 0xb02a
movl %ebx, %esi
callq 0x9f24
movq %r14, %rdi
movl %ebx, %esi
callq 0x9f24
leaq 0x8a19(%rip), %rdi      # 0xb042
movl %ebx, %esi
callq 0x9f24
leaq 0x9613(%rip), %rdi      # 0xbc4a
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9f24
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_root.c
// Function: lexer_root
t_list	*lexer_root(char *input, t_control *control)
{
	t_list	*tokens_head;
	t_list	*tokens_elem;
	t_token	*new_token;
	int		i;

	i = 0;
	tokens_head = NULL;
	while (input[i])
	{
		tokens_elem = NULL;
		if ((!(new_token = lexer_build_next_token(input, &i, control)) &&
		control->quit) || (new_token && !(tokens_elem = ft_lstnew(new_token))))
		{
			control->quit = 1;
			del_token(new_token);
			ft_lstclear(&tokens_head, del_token);
			return (NULL);
		}
		ft_lstadd_back(&tokens_head, tokens_elem);
		//debug_token_struct(new_token);
	}
	ft_bzero(&control->lexer_end, sizeof(lexer_end));
	if (!lexer_end(tokens_head, control))
		ft_lstclear(&tokens_head, del_token);
	//debug_lexer_flags(control);
	//debug_tokens_list(tokens_head);
	return (tokens_head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl $0x0, 0xc(%rsp)
movq $0x0, (%rsp)
cmpb $0x0, (%rdi)
je 0x26bb
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2718
movq %rax, %r13
testq %rax, %rax
je 0x269d
movq %r13, %rdi
callq 0xa894
testq %rax, %rax
jne 0x26a4
jmp 0x26ee
testb $0x1, (%rbx)
jne 0x26ee
xorl %eax, %eax
movq %r12, %rdi
movq %rax, %rsi
callq 0xa7e4
movslq 0xc(%rsp), %rax
cmpb $0x0, (%r14,%rax)
jne 0x2678
leaq 0x28(%rbx), %rdi
movl $0x1, %esi
callq 0x9bc0
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x2f4a
testl %eax, %eax
jne 0x26e8
leaq 0xa9(%rip), %rsi        # 0x2789
movq %rsp, %rdi
callq 0xa820
movq (%rsp), %rax
jmp 0x270a
orb $0x1, (%rbx)
movq %r13, %rdi
callq 0x2789
leaq 0x89(%rip), %rsi        # 0x2789
movq %rsp, %rdi
callq 0xa820
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_root.c
// Function: lexer_build_next_token
t_token	*lexer_build_next_token(const char *input, int *j, t_control *control)
{
	t_token		*token;

	token = NULL;
	while (input[*j] == ' ')
		(*j)++;
	if (!input[*j])
		return (token);
	if (!(token = lexer_init_token()) ||
		!lexer_find_token(input, j, token))
	{
		control->quit = 1;
		del_token(token);
		return (NULL);
	}
	return (token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rcx
leal 0x1(%rcx), %eax
addq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x20, %edx
jne 0x2744
movl %eax, (%r14)
incq %rcx
incl %eax
jmp 0x2732
testl %edx, %edx
je 0x2777
movl $0x20, %edi
callq 0xaa1c
movq %rax, %r12
testq %rax, %rax
je 0x276c
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x27e0
testl %eax, %eax
jne 0x277a
orb $0x1, (%rbx)
movq %r12, %rdi
callq 0x2789
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_root.c
// Function: del_token
void	del_token(void *token)
{
	if (!token)
		return ;
	if (token_id(token) == CMD)
		free_t_simple_cmd((t_simple_cmd**)(((t_token *)token)->str));
	else if (token_id(token) == LIST)
		ft_lstclear((t_list **)&(((t_token *)token)->str), del_token);
	else
		ft_free((void **)&(((t_token *)token)->str));
	ft_free(&token);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x27d4
callq 0x63e8
movq (%rsp), %rdi
cmpl $0x10, %eax
jne 0x27ab
movq (%rdi), %rdi
callq 0x8ce2
jmp 0x27cc
callq 0x63e8
movq (%rsp), %rdi
cmpl $0xf, %eax
jne 0x27c7
leaq -0x37(%rip), %rsi       # 0x2789
callq 0xa820
jmp 0x27cc
callq 0xaa9c
movq %rsp, %rdi
callq 0xaa9c
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_find_token.c
// Function: lexer_find_token
int	lexer_find_token(const char *input, int *j, t_token *token)
{
	if (!input[*j])
		return (1);
	if (input[*j] == '\\')
		return (lexer_just_token(input, j, token));
	else if (ft_strchr("\"\'", input[*j]))
		return (lexer_quoted(input, j, token));
	else if (ft_strchr("&<>()|;", input[*j]))
		return (lexer_operator(input, j, token));
	else if (ft_isdigit(input[*j]))
		return (lexer_token_or_indirection(input, j, token));
	return (lexer_just_token(input, j, token));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq (%rsi), %rax
movzbl (%rdi,%rax), %eax
testl %eax, %eax
je 0x2811
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x5c, %eax
jne 0x281c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2b84
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movsbl %al, %esi
leaq 0x8832(%rip), %rdi      # 0xb058
callq 0xa47c
testq %rax, %rax
je 0x2843
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x28a4
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x8809(%rip), %rdi      # 0xb05b
callq 0xa47c
testq %rax, %rax
je 0x286f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2a3c
movslq (%r14), %rax
movsbl (%r15,%rax), %edi
callq 0x9c08
testl %eax, %eax
je 0x27fe
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2c95