LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x15f76
movq 0xb05f(%rip), %rax      # 0x20fd0
movq (%rax), %r14
jmp 0x15fa1
leaq 0x3b44(%rip), %rsi      # 0x19ac1
movq %r15, %rdi
callq 0x21b0
movq %rax, %r14
testq %rax, %rax
jne 0x15fa1
leaq 0x4da9(%rip), %rdi      # 0x1ad3d
xorl %r14d, %r14d
movq %r15, %rsi
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x1606e
movl %ebp, %r13d
xorl %ebp, %ebp
movl $0x88888889, %r15d      # imm = 0x88888889
movq (%rbx,%rbp,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x16062
movq 0x48(%rax), %r12
movsbl 0x40(%rax), %edi
callq 0x50a2
movsbl %al, %ecx
movq (%rbx,%rbp,8), %rax
movl (%rax), %r8d
xorps %xmm0, %xmm0
cvtss2sd 0x50(%rax), %xmm0
movq %r14, %rdi
leaq 0x4d72(%rip), %rsi      # 0x1ad5d
movq %r12, %rdx
movb $0x1, %al
callq 0x2160
movq (%rbx,%rbp,8), %rax
cmpl $0x0, (%rax)
jle 0x16055
xorl %r12d, %r12d
testq %r12, %r12
je 0x1602a
movl %r12d, %ecx
imulq %r15, %rcx
shrq $0x25, %rcx
imull $-0x3c, %ecx, %ecx
addl %r12d, %ecx
jne 0x1602a
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 0x4acc
movsbl %al, %edi
movq %r14, %rsi
callq 0x2110
incq %r12
movq (%rbx,%rbp,8), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jl 0x16001
movl $0xa, %edi
movq %r14, %rsi
callq 0x2110
incq %rbp
cmpq %r13, %rbp
jne 0x15fb4
movq %r14, %rdi
callq 0x20a0
xorl %edi, %edi
callq 0x2230
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x17ca8
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xfa0, %rsp            # imm = 0xFA0
movl %r8d, %ebx
movq %rdi, %r14
movl %esi, %eax
xorl %edi, %edi
xorl %r8d, %r8d
xorl %esi, %esi
movb (%r14,%rdi), %r9b
cmpb %dl, %r9b
sete %r10b
testl %r8d, %r8d
sete %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x17c2c
movslq %esi, %r8
movl %edi, (%rsp,%r8,8)
movl $0x1, %r8d
jmp 0x17c55
cmpb %dl, %r9b
setne %r9b
cmpl $0x1, %r8d
sete %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x17c55
movslq %esi, %r8
incl %esi
leal -0x1(%rdi), %r9d
movl %r9d, 0x4(%rsp,%r8,8)
xorl %r8d, %r8d
incq %rdi
cmpq %rdi, %rax
jne 0x17c02
testl %esi, %esi
jle 0x17c99
movl %esi, %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 0x17c91
cmpl %ecx, %edx
jl 0x17c91
movslq %ecx, %rdi
addq %r14, %rdi
movl %eax, %edx
incq %rdx
movl %ebp, %esi
callq 0x20f0
incq %r12
cmpq %r12, %r15
jne 0x17c6a
addq $0xfa0, %rsp            # imm = 0xFA0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17d2b
pushq %rbx
leal -0x1(%rcx), %eax
movl %ecx, %ecx
xorl %r10d, %r10d
cmpb %r8b, (%rdi,%r10)
je 0x17cc2
cmpb %r8b, (%rsi,%r10)
jne 0x17d22
cmpb %r8b, (%rdx,%r10)
je 0x17d22
testq %r10, %r10
jne 0x17cd9
cmpb %r8b, 0x1(%rdi)
je 0x17cd9
cmpb %r8b, 0x1(%rsi)
jne 0x17d1a
cmpq %r10, %rax
jne 0x17cec
cmpb %r8b, -0x1(%rdi,%rax)
je 0x17cec
cmpb %r8b, -0x1(%rsi,%rax)
jne 0x17d1a
testq %r10, %r10
sete %r11b
cmpq %rax, %r10
setae %bl
orb %r11b, %bl
jne 0x17d22
cmpb %r8b, -0x1(%rdi,%r10)
je 0x17d22
cmpb %r8b, -0x1(%rsi,%r10)
je 0x17d22
cmpb %r8b, 0x1(%rdi,%r10)
je 0x17d22
cmpb %r8b, 0x1(%rsi,%r10)
je 0x17d22
movb %r9b, (%rsi,%r10)
movb %r9b, (%rdi,%r10)
incq %r10
cmpq %r10, %rcx
jne 0x17cb6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorps %xmm0, %xmm0
movups %xmm0, (%r8)
xorps %xmm0, %xmm0
testl %edx, %edx
jle 0x17de6
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r11d
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r10d, %r10d
xorl %edx, %edx
xorl %ebx, %ebx
movb (%rsi,%rbx), %r14b
cmpb $0x58, %r14b
jne 0x17d65
incq %rbx
cmpq %rbx, %r11
jne 0x17d51
jmp 0x17d99
movb (%rdi,%rbx), %bpl
cmpb %cl, %r14b
jne 0x17d7b
cmpb %cl, %bpl
jne 0x17d89
incl %r10d
movl %r10d, (%r8)
jmp 0x17d5b
cmpb %cl, %bpl
jne 0x17d91
incl %r9d
movl %r9d, 0x8(%r8)
jmp 0x17d5b
incl %edx
movl %edx, 0xc(%r8)
jmp 0x17d5b
incl %eax
movl %eax, 0x4(%r8)
jmp 0x17d5b
movl %r10d, %ecx
orl %eax, %ecx
popq %rbx
popq %r14
popq %rbp
jne 0x17db7
xorl %eax, %eax
testl %r9d, %r9d
jne 0x17db7
xorl %eax, %eax
movl $0x0, %r9d
testl %edx, %edx
je 0x17de8
cvtsi2ss %r10d, %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
cvtsi2ss %r9d, %xmm2
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
addss %xmm0, %xmm2
addss %xmm2, %xmm1
divss %xmm1, %xmm0
movl $0x1, %eax
jmp 0x17de8
xorl %eax, %eax
movss %xmm0, 0x14(%r8)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17e1b
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 0x17dfa
cvtsi2ss %r8d, %xmm0
jmp 0x17e1e
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm1
divss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17ec4
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
cvtsi2ss %ecx, %xmm0
cvtsi2ssl 0x4(%rbx), %xmm1
cvtsi2ss %esi, %xmm2
cvtsi2ss %edx, %xmm3
movaps %xmm2, %xmm4
mulss %xmm3, %xmm4
movaps %xmm0, %xmm5
mulss %xmm1, %xmm5
subss %xmm4, %xmm5
cvtss2sd %xmm5, %xmm5
movaps %xmm1, %xmm4
addss %xmm3, %xmm4
addss %xmm2, %xmm1
mulss %xmm4, %xmm1
addss %xmm0, %xmm3
mulss %xmm1, %xmm3
addss %xmm2, %xmm0
mulss %xmm3, %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x17e98
sqrtsd %xmm0, %xmm0
jmp 0x17ea9
movsd %xmm5, 0x8(%rsp)
callq 0x2250
movsd 0x8(%rsp), %xmm5
divsd %xmm0, %xmm5
xorps %xmm0, %xmm0
cvtsd2ss %xmm5, %xmm0
movss %xmm0, 0x10(%rbx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
movl 0xc(%rbx), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x17ebe
movl 0x8(%rbx), %esi
testl %esi, %esi
jne 0x17e3f
jmp 0x17ebe
// File: /workspace/github_c_makefile_star2_O3/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 0x17f36
movl %ecx, %eax
xorl %ecx, %ecx
movb $0x58, %r8b
movb (%rdi,%rcx), %r9b
cmpb (%rsi,%rcx), %r9b
jne 0x17f2e
movb %r8b, (%rdx,%rcx)
movb %r8b, (%rdi,%rcx)
movb %r8b, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x17f18
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x17f55
xorl %eax, %eax
movq (%rsi,%rax,8), %rcx
movl $0x1, 0xc(%rcx)
incq %rax
movslq (%rdx), %rcx
cmpq %rcx, %rax
jl 0x17f3f
movl $0x1, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x17f81
movb (%rdi), %cl
testb %cl, %cl
je 0x17f81
incq %rdi
xorl %eax, %eax
cmpb %sil, %cl
jne 0x17f78
movb %dl, -0x1(%rdi)
incl %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x17f6e
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17fb5
movb (%rdi), %cl
testb %cl, %cl
je 0x17fb5
xorl %eax, %eax
cmpb %sil, %cl
jne 0x17fab
leaq 0x1(%rdi), %rcx
movb (%rcx), %dl
movb %dl, -0x1(%rcx)
incq %rcx
testb %dl, %dl
jne 0x17f9a
incl %eax
decq %rdi
movb 0x1(%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x17f91
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x184ce
movq %rdi, %rbx
movl %esi, %eax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
cmpl $0x0, 0x58(%rdi)
je 0x184c0
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rax
cmpl $0x0, 0x58(%rax)
je 0x184b2
cmpl $0x0, (%rdi)
jle 0x184b2
xorl %ebp, %ebp
movl %ebp, %esi
leaq 0x2a72(%rip), %rdx      # 0x1ae38
leaq 0xc(%rsp), %rcx
callq 0x4ea0
testl %eax, %eax
je 0x1849f
movq (%rbx,%r14,8), %rdi
cmpl $0x0, (%rdi)
jle 0x1849f
xorl %r15d, %r15d
movl %r15d, %esi
leaq 0x2a46(%rip), %rdx      # 0x1ae38
leaq 0x8(%rsp), %rcx
callq 0x4ea0
testl %eax, %eax
je 0x1848c
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 0x40c3
movss %xmm0, 0x4(%rsp)
movq (%rbx,%r12,8), %rax
movsbl 0x40(%rax), %edi
callq 0x50a2
movsbl %al, %r13d
movq (%rbx,%r14,8), %rax
movsbl 0x40(%rax), %edi
callq 0x50a2
movsbl %al, %ecx
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
leaq 0x2ce2(%rip), %rdi      # 0x1b15f
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 0x183e8
incq %rbp
movq (%rbx,%r12,8), %rdi
movslq (%rdi), %rax
cmpq %rax, %rbp
jl 0x183bd
incq %r14
cmpq 0x10(%rsp), %r14
jne 0x183a4
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x18393
xorl %edi, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xc0a(%rip), %rdi       # 0x2020
leaq 0xc0e(%rip), %rsi       # 0x202b
callq 0x12dd
testq %rax, %rax
je 0x14a2
movq %rax, %rbx
leaq 0xc1d(%rip), %rdi       # 0x204e
leaq 0xc1e(%rip), %rsi       # 0x2056
callq 0x12dd
testq %rax, %rax
je 0x14a2
movq %rax, %r14
movq %rbx, %r12
addq $0x8, %r12
movq %rax, %r15
addq $0x8, %r15
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
testl %eax, %eax
jle 0x146e
movq (%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r12)
movb (%rax), %al
jmp 0x1476
movq %rbx, %rdi
callq 0x11ac
cmpb $-0x1, %al
je 0x14bf
movl (%r14), %ecx
leal -0x1(%rcx), %edx
movl %edx, (%r14)
testl %ecx, %ecx
jle 0x1495
movq (%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r15)
movb %al, (%rcx)
jmp 0x1453
movsbl %al, %edi
movq %r14, %rsi
callq 0x1227
jmp 0x1453
leaq 0xb84(%rip), %rsi       # 0x202d
movl $0x1, %ebp
movl $0x21, %edx
movl $0x1, %edi
callq 0x1040
jmp 0x14f8
movq 0x10(%rbx), %rdi
callq 0x1030
xorl %ebp, %ebp
movl %ebp, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl 0x1c(%rbx), %edi
callq 0x1060
movq 0x10(%r14), %rdi
callq 0x1030
movl %ebp, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movl 0x1c(%r14), %edi
callq 0x1060
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23c7
leaq 0x3c(%rbx), %r14
leaq 0x432(%rip), %r15       # 0x278e
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e8
testl %eax, %eax
je 0x23c7
movq %rbx, %rdi
callq 0x3de4
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41af
testl %eax, %eax
je 0x23c7
movb (%rbx), %al
testb $0x3, %al
jne 0x23c3
cmpl $0x0, 0x2c(%rbx)
jne 0x23c3
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6195
movq %rax, 0x8(%rsp)
testb $0x1, (%rbx)
jne 0x23c7
movq %rax, %rdi
movq %rbx, %rsi
callq 0x64c4
movq %r12, %rdi
movq %r15, %rsi
callq 0xae00
movb (%rbx), %al
testb $0x1, %al
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_O3/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 0x8e21
movq %rsp, %rdi
callq 0x5c64
testl %eax, %eax
je 0x242f
leaq 0x3c(%rsp), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x40e8
testl %eax, %eax
je 0x242f
movq %rsp, %r14
movq %r14, %rdi
callq 0x233c
movl %eax, %ebp
movq %r14, %rdi
callq 0x5dc6
callq 0x43a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41af
jmp 0x2461
callq 0x2040
movl (%rax), %edi
testl %edi, %edi
je 0x2444
callq 0x2220
movq %rax, %rdx
jmp 0x244b
leaq 0x8bb9(%rip), %rdx      # 0xb004
xorl %edi, %edi
xorl %esi, %esi
callq 0x2511
movq %rsp, %rdi
callq 0x5dc6
movl $0x1, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x9e70
leaq 0x8af3(%rip), %rdi      # 0xb02a
movl $0x2, %esi
callq 0x9e70
testq %r15, %r15
je 0x2564
movq %r15, %rdi
movl $0x2, %esi
callq 0x9e70
leaq 0x8f14(%rip), %rdi      # 0xb46e
movl $0x2, %esi
callq 0x9e70
testq %r14, %r14
je 0x2598
leaq 0x8d03(%rip), %rdi      # 0xb273
movl $0x2, %esi
callq 0x9e70
movq %r14, %rdi
movl $0x2, %esi
callq 0x9e70
leaq 0x8aa8(%rip), %rdi      # 0xb036
movl $0x2, %esi
callq 0x9e70
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 0x9e70
movq %rbx, %rdi
movl $0x2, %esi
callq 0x9dcc
leaq 0x966a(%rip), %rdi      # 0xbc4a
movl $0x2, %esi
callq 0x9e70
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9e70
leaq 0x8a19(%rip), %rdi      # 0xb02a
movl %ebx, %esi
callq 0x9e70
movq %r14, %rdi
movl %ebx, %esi
callq 0x9e70
leaq 0x8a19(%rip), %rdi      # 0xb042
movl %ebx, %esi
callq 0x9e70
leaq 0x9613(%rip), %rdi      # 0xbc4a
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9e70
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
testq %rax, %rax
je 0x269d
movq %rax, %r13
movq %rax, %rdi
callq 0xa7bc
testq %rax, %rax
jne 0x26a4
jmp 0x26ee
testb $0x1, (%rbx)
jne 0x26f9
xorl %eax, %eax
movq %r12, %rdi
movq %rax, %rsi
callq 0xa70c
movslq 0xc(%rsp), %rax
cmpb $0x0, (%r14,%rax)
jne 0x2678
leaq 0x28(%rbx), %rdi
movl $0x1, %esi
callq 0x9b68
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x2f6b
testl %eax, %eax
jne 0x26e8
leaq 0xae(%rip), %rsi        # 0x278e
movq %rsp, %rdi
callq 0xa748
movq (%rsp), %rax
jmp 0x270a
orb $0x1, (%rbx)
movq %r13, %rdi
callq 0x278e
leaq 0x8e(%rip), %rsi        # 0x278e
movq %rsp, %rdi
callq 0xa748
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x277c
movl $0x20, %edi
callq 0xa944
testq %rax, %rax
je 0x2779
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x27f4
testl %eax, %eax
jne 0x277f
orb $0x1, (%rbx)
movq %r12, %rdi
callq 0x278e
jmp 0x277c
orb $0x1, (%rbx)
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x27e4
movq %rdi, %rbx
callq 0x63cc
cmpl $0x10, %eax
jne 0x27b4
movq (%rbx), %rdi
callq 0x8c64
jmp 0x27da
movq %rbx, %rdi
callq 0x63cc
cmpl $0xf, %eax
jne 0x27d2
leaq -0x3a(%rip), %rsi       # 0x278e
movq %rbx, %rdi
callq 0xa748
jmp 0x27da
movq %rbx, %rdi
callq 0xa9c0
leaq 0x8(%rsp), %rdi
callq 0xa9c0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2825
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x5c, %eax
jne 0x2830
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2b9c
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movsbl %al, %esi
leaq 0x881e(%rip), %rdi      # 0xb058
callq 0xa3ac
testq %rax, %rax
je 0x2857
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x28b8
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x87f5(%rip), %rdi      # 0xb05b
callq 0xa3ac
testq %rax, %rax
je 0x2883
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2a5c
movslq (%r14), %rax
movsbl (%r15,%rax), %edi
callq 0x9bb0
testl %eax, %eax
je 0x2812
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2cb2
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted
int	lexer_quoted(const char *input, int *j, t_token *token)
{
	char c;

	c = input[*j];
	if (!ft_strappend(&(token->str), c))
		return (0);
	(*j)++;
	token->open_quote = 1;
	if (c == '\'')
	{
		token->id = S_QUOTE;
		return (lexer_quoted_single(input, c, j, token));
	}
	else
	{
		token->id = D_QUOTE;
		return (lexer_quoted_double(input, c, j, token));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movb (%rdi,%rax), %r12b
movsbl %r12b, %ebp
movq %rdx, %rdi
movl %ebp, %esi
callq 0xa8f8
testl %eax, %eax
je 0x2911
incl (%r14)
orb $0x1, 0x10(%rbx)
cmpb $0x27, %r12b
jne 0x291c
movl $0x8, 0x8(%rbx)
movq %r15, %rdi
movl $0x27, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x293b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x9, 0x8(%rbx)
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x29ae
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_single
int	lexer_quoted_single(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq (%rdx), %rax
movb (%rdi,%rax), %al
movl $0x1, %ebp
testb %al, %al
je 0x2989
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa8f8
testl %eax, %eax
je 0x2987
movslq (%r14), %rcx
leaq 0x1(%rcx), %rax
cmpb %r12b, (%r15,%rcx)
movl %eax, (%r14)
je 0x2994
movb (%r15,%rax), %al
testb %al, %al
jne 0x295e
jmp 0x2989
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andb $-0x2, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27f4
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_double
int	lexer_quoted_double(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (!token->esc_next && input[*j] == '\\' && lexer_jump_esc(j, token))
			continue;
		else if (!token->esc_next && input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		token->esc_next = 0;
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq (%rdx), %rax
movb (%rdi,%rax), %al
movl $0x1, %ebp
testb %al, %al
je 0x2a30
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa8f8
testl %eax, %eax
je 0x2a2e
movb 0x10(%rbx), %al
testb $0x2, %al
jne 0x2a08
movslq (%r14), %rcx
cmpb $0x5c, (%r15,%rcx)
jne 0x2a08
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28ab
testl %eax, %eax
je 0x2a05
movl (%r14), %eax
jmp 0x2a22
movb 0x10(%rbx), %al
testb $0x2, %al
jne 0x2a15
movslq (%r14), %rcx
cmpb %r12b, (%r15,%rcx)
je 0x2a3b
andb $-0x3, %al
movb %al, 0x10(%rbx)
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
cltq
movb (%r15,%rax), %al
testb %al, %al
jne 0x29d1
jmp 0x2a30
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
incl %ecx
movl %ecx, (%r14)
andb $-0x2, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27f4
nop
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_operator
int		lexer_operator(const char *input, int *j, t_token *token)
{
	if (token->str)
		return (1);
	lexer_set_operator_id(token, input[*j]);
	if (ft_strchr("();", input[*j]))
	{
		(*j)++;
		if (!(token->str = ft_strdup((char	[2]){input[*j - 1], '\0'})))
			return (0);
		return (1);
	}
	else if (ft_strchr("<>&|", input[*j]))
		return (lexer_operator2(input, j, token));
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x1, %eax
cmpq $0x0, (%rdx)
jne 0x2acc
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movsbl (%rdi,%rax), %esi
movq %rdx, %rdi
callq 0x2b07
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x85e9(%rip), %rdi      # 0xb080
callq 0xa3ac
movslq (%r14), %rcx
testq %rax, %rax
je 0x2ad6
leal 0x1(%rcx), %eax
movl %eax, (%r14)
movb (%r15,%rcx), %al
leaq 0xe(%rsp), %rdi
movb %al, (%rdi)
movb $0x0, 0x1(%rdi)
callq 0xa3e4
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsbl (%r15,%rcx), %esi
leaq 0x85a2(%rip), %rdi      # 0xb084
callq 0xa3ac
testq %rax, %rax
je 0x2b03
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2b30
xorl %eax, %eax
jmp 0x2acc
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_set_operator_id
void	lexer_set_operator_id(t_token *token, char c)
{
	int			i;
	char		(*op_ids)[2];

	op_ids = (char	[][2]){{'(', LBRACE}, {')', RBRACE},
	{'|', PIPE}, {'&', AND}, {';', SEMI}, {'<', LESS}, {'>', GREAT}, {0, 0}};
	i = -1;
	while (op_ids[++i][0])
		if (op_ids[i][0] == c)
			token->id = op_ids[i][1];
}

// Assembly:
movaps 0x8562(%rip), %xmm0     # 0xb070
leaq -0x16(%rsp), %rax
movaps %xmm0, -0x2(%rax)
movb $0x28, %cl
cmpb %sil, %cl
jne 0x2b25
movsbl -0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
movb (%rax), %cl
addq $0x2, %rax
testb %cl, %cl
jne 0x2b19
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_operator2
int		lexer_operator2(const char *input, int *j, t_token *token)
{
	char c;

	c = input[*j];
	if (!ft_strappend(&(token->str), c))
		return (0);
	(*j)++;
	if (input[*j] == c)
	{
		token->id++;
		(*j)++;
		if (!ft_strappend(&(token->str), c))
			return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq (%rsi), %rax
movb (%rdi,%rax), %r13b
movsbl %r13b, %ebp
movq %rdx, %rdi
movl %ebp, %esi
callq 0xa8f8
xorl %ebx, %ebx
testl %eax, %eax
je 0x2b8a
movslq (%r15), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r15)
cmpb %r13b, 0x1(%r12,%rax)
jne 0x2b85
incl 0x8(%r14)
incl (%r15)
movq %r14, %rdi
movl %ebp, %esi
callq 0xa8f8
testl %eax, %eax
je 0x2b8a
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_just_token.c
// Function: lexer_just_token
int	lexer_just_token(const char *input, int *j, t_token *token)
{
	while (input[*j] && (token->esc_next || input[*j] != ' '))
	{
		if (!token->esc_next && ft_strchr("\"\'", input[*j]))
			return (lexer_quoted(input, j, token));
		else if (!token->esc_next && ft_strchr("&<>()|;", input[*j]))
			return (1);
		else if (!token->esc_next && input[*j] == '\\')
		{
			token->esc_next = 1;
			if (!ft_strappend(&(token->str), input[*j]))
				return (0);
			(*j)++;
			continue;
		}
		else if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		token->esc_next = 0;
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movslq (%rsi), %rax
movb (%rdi,%rax), %dl
movl $0x1, %ebx
testb %dl, %dl
je 0x2c85
movq %rsi, %r15
movq %rdi, %r12
leaq 0x848e(%rip), %r13      # 0xb058
leaq 0x848a(%rip), %rbp      # 0xb05b
movb 0x10(%r14), %cl
movl %ecx, %esi
andb $0x2, %sil
movl %edx, %edi
xorb $0x20, %dil
orb %sil, %dil
je 0x2c85
testb $0x2, %cl
jne 0x2c0a
movsbl %dl, %esi
movq %r13, %rdi
callq 0xa3ac
testq %rax, %rax
jne 0x2c96
movb 0x10(%r14), %cl
movl (%r15), %eax
testb $0x2, %cl
jne 0x2c2a
cltq
movsbl (%r12,%rax), %esi
movq %rbp, %rdi
callq 0xa3ac
testq %rax, %rax
jne 0x2c85
movb 0x10(%r14), %cl
movl (%r15), %eax
cltq
movb (%r12,%rax), %al
testb $0x2, %cl
jne 0x2c56
cmpb $0x5c, %al
jne 0x2c56
orb $0x2, %cl
movb %cl, 0x10(%r14)
movslq (%r15), %rax
movsbl (%r12,%rax), %esi
movq %r14, %rdi
callq 0xa8f8
testl %eax, %eax
jne 0x2c6a
jmp 0x2c83
movsbl %al, %esi
movq %r14, %rdi
callq 0xa8f8
testl %eax, %eax
je 0x2c83
andb $-0x3, 0x10(%r14)
movslq (%r15), %rcx
leaq 0x1(%rcx), %rax
movl %eax, (%r15)
movb 0x1(%r12,%rcx), %dl
testb %dl, %dl
jne 0x2bd1
jmp 0x2c85
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28b8
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_just_token.c
// Function: lexer_token_or_indirection
int	lexer_token_or_indirection(const char *input, int *j, t_token *token)
{
	while (ft_isdigit(input[*j]))
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		(*j)++;
	}
	if (input[*j] && input[*j] != ' ')
	{
		if (ft_strchr("&()|;", input[*j]))
			return (1);
		else if (ft_strchr("<>", input[*j]))
			return (lexer_indirection(input, j, token));
		else
			return (lexer_just_token(input, j, token));
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movsbl (%rdi,%rax), %edi
callq 0x9bb0
testl %eax, %eax
je 0x2cf8
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
movq %rbx, %rdi
callq 0xa8f8
testl %eax, %eax
je 0x2d65
movslq (%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r14)
movsbl 0x1(%r15,%rax), %edi
jmp 0x2cc9
movslq (%r14), %rax
movzbl (%r15,%rax), %eax
movl $0x1, %ebp
testb $-0x21, %al
je 0x2d67
movsbl %al, %esi
leaq 0x8376(%rip), %rdi      # 0xb089
callq 0xa3ac
testq %rax, %rax
jne 0x2d67
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x8363(%rip), %rdi      # 0xb08f
callq 0xa3ac
testq %rax, %rax
je 0x2d74
movslq (%r14), %rax
xorl %ecx, %ecx
cmpb $0x3c, (%r15,%rax)
setne %cl
leal 0xa(,%rcx,2), %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b30
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b9c
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_id_cmp
int		lexer_id_cmp(t_token *token, int *id)
{
	while (*id != -1)
	{
		if (token->id == *id)
			return (0);
		id++;
	}
	return (-1);
}

// Assembly:
movl (%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %ecx
je 0x2dca
movl 0x8(%rdi), %edx
addq $0x4, %rsi
cmpl %ecx, %edx
je 0x2dcb
movl (%rsi), %ecx
addq $0x4, %rsi
cmpl $-0x1, %ecx
jne 0x2dbb
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_braces_equal
int		lexer_braces_equal(t_list *tk_head, t_control *control, t_token *last)
{
	int		brace[2];

	brace[0] = 0;
	brace[1] = 0;
	while (tk_head && !control->lexer_end.unexpected)
	{
		if (((t_token *)tk_head->content)->id == LBRACE)
			brace[0]++;
		else if (((t_token *)tk_head->content)->id == RBRACE)
			brace[1]++;
		if (brace[0] < brace[1])
			control->lexer_end.unexpected = RBRACE;
		tk_head = tk_head->next;
	}
	if (brace[0] > brace[1])
	{
		control->lexer_end.brace = 1;
		if (last->id != SEMI && last->id != LBRACE)
			control->lexer_end.add_semi = 1;
	}
	else if (brace[0] == brace[1])
		return (1);
	return (0);
}

// Assembly:
movl $0x1, %eax
testq %rdi, %rdi
je 0x2e46
movl 0x2c(%rsi), %r9d
xorl %ecx, %ecx
xorl %r8d, %r8d
testl %r9d, %r9d
jne 0x2e1e
movq (%rdi), %r9
movl 0x8(%r9), %r9d
cmpl $0x7, %r9d
je 0x2dfd
cmpl $0x6, %r9d
jne 0x2e00
incl %ecx
jmp 0x2e00
incl %r8d
xorl %r9d, %r9d
cmpl %r8d, %ecx
jge 0x2e15
movl $0x7, 0x2c(%rsi)
movl $0x7, %r9d
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x2de1
cmpl %r8d, %ecx
jle 0x2e42
movb 0x28(%rsi), %al
movl %eax, %ecx
orb $0x8, %cl
movb %cl, 0x28(%rsi)
movl 0x8(%rdx), %ecx
cmpl $0x1, %ecx
je 0x2e44
cmpl $0x6, %ecx
je 0x2e44
orb $0x18, %al
movb %al, 0x28(%rsi)
jmp 0x2e44
je 0x2e46
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_signs_near_braces
int		lexer_signs_near_braces(t_list *tk_head, t_control *control)
{
	t_token		*prev_tk;
	t_token		*curr_tk;
	t_token		*next_tk;
	int			*signs;

	signs = (int	[]){LESS, DLESS, GREAT, DGREAT, AND, AND_IF, \
		PIPE, OR_IF, SEMI, -1};
	prev_tk = NULL;
	while (tk_head && !control->lexer_end.unexpected)
	{
		curr_tk = (t_token *)tk_head->content;
		next_tk = (tk_head->next ? (t_token *)tk_head->next->content : NULL);
		if (curr_tk->id == LBRACE && prev_tk &&
			lexer_tk_notbeside(curr_tk, prev_tk, (int *)signs, 1))
			control->lexer_end.unexpected = LBRACE;
		else if (curr_tk->id == RBRACE && next_tk &&
				lexer_tk_notbeside(curr_tk, next_tk, (int *)signs, 1))
			control->lexer_end.unexpected = RBRACE;
		prev_tk = (t_token *)tk_head->content;
		tk_head = tk_head->next;
	}
	return (control->lexer_end.unexpected ? 0 : 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movups 0x8246(%rip), %xmm0     # 0xb0a4
movaps %xmm0, 0x10(%rsp)
movups 0x822a(%rip), %xmm0     # 0xb094
movaps %xmm0, (%rsp)
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x20(%rsp)
testq %rdi, %rdi
je 0x2f22
movq %rdi, %r14
xorl %esi, %esi
movq %rsp, %r15
cmpl $0x0, 0x2c(%rbx)
jne 0x2f22
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2ea6
movq (%rax), %r12
jmp 0x2ea9
xorl %r12d, %r12d
movq (%r14), %r13
movl 0x8(%r13), %eax
cmpl $0x6, %eax
sete %cl
testq %rsi, %rsi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2ee0
movq %r13, %rdi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x3076
movl $0x6, %ecx
testl %eax, %eax
jne 0x2f0f
movl 0x8(%r13), %eax
cmpl $0x7, %eax
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2f12
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x3076
movl $0x7, %ecx
testl %eax, %eax
je 0x2f12
movl %ecx, 0x2c(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x2e8e
xorl %eax, %eax
cmpl $0x0, 0x2c(%rbx)
sete %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_end
int		lexer_end(t_list *token_head, t_control *control)
{
	t_token	*last;

	if (token_head == NULL || (t_token *)(token_head->content) == NULL)
		return (0);
	last = (t_token *)(ft_lstlast(token_head)->content);
	if ((control->lexer_end.unexpected = lexer_forbidden_start(token_head)) ||
	(control->lexer_end.unexpected = lexer_forbidden_combo(token_head)))
		;
	else if (last->open_quote)
		control->lexer_end.quote = 1;
	else if (last->esc_next)
		control->lexer_end.backslash = 1;
	else if (last->id == AND_IF || last->id == PIPE || last->id == OR_IF)
		control->lexer_end.other = 1;
	else if (last->id == LESS || last->id == DLESS ||
			last->id == GREAT || last->id == DGREAT)
		control->lexer_end.unexpected = last->id;
	else if (ft_lstfind(token_head, (int	[]){LBRACE, RBRACE, -1},
			lexer_id_cmp) && !lexer_handle_braces(token_head, control, last))
		;
	else
		return (1);
	if (control->lexer_end.unexpected != 0)
		control->exit_status = (IS_APPLE ? 258 : 2);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2fb6
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x2fb6
movq %rsi, %rbx
movq %r14, %rdi
callq 0xa7a4
movq (%rax), %r15
movq %r14, %rdi
callq 0x30cd
movl %eax, 0x2c(%rbx)
testl %eax, %eax
jne 0x2faf
movq %r14, %rdi
callq 0x318a
movl %eax, 0x2c(%rbx)
testl %eax, %eax
je 0x2fc5
movl $0x2, 0x4(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb 0x10(%r15), %al
testb $0x1, %al
jne 0x2fe9
testb $0x2, %al
jne 0x2fef
movl 0x8(%r15), %eax
cmpl $0xd, %eax
ja 0x3005
movl $0x3c00, %ecx           # imm = 0x3C00
btl %eax, %ecx
jae 0x2ff5
movl %eax, 0x2c(%rbx)
jmp 0x2faf
orb $0x2, 0x28(%rbx)
jmp 0x2fb6
orb $0x4, 0x28(%rbx)
jmp 0x2fb6
movl $0x2c, %ecx
btl %eax, %ecx
jae 0x3005
orb $0x1, 0x28(%rbx)
jmp 0x2fb6
movabsq $0x700000006, %rax      # imm = 0x700000006
leaq 0xc(%rsp), %rsi
movq %rax, (%rsi)
movl $0xffffffff, 0x8(%rsi)  # imm = 0xFFFFFFFF
leaq -0x27d(%rip), %rdx      # 0x2da8
movq %r14, %rdi
callq 0xa7ec
movl $0x1, %ebp
testq %rax, %rax
je 0x2fb8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2f39
testl %eax, %eax
jne 0x2fb8
cmpl $0x0, 0x2c(%rbx)
jne 0x2faf
jmp 0x2fb6
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_tk_notbeside
int		lexer_tk_notbeside(t_token *curr, t_token *next, int *forbid, int self)
{
	if ((self && next->id == curr->id) ||
		(forbid && lexer_tk_id_chr(forbid, next)))
		return (0);
	return (1);
}

// Assembly:
testl %ecx, %ecx
je 0x3082
movl 0x8(%rsi), %eax
cmpl 0x8(%rdi), %eax
je 0x30a2
testq %rdx, %rdx
je 0x309c
pushq %rax
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2da8
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0x30a2
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_start_no_exceptions
int		lexer_forbidden_start_no_exceptions(t_list *token)
{
	t_token *curr_tk;
	t_token *next_tk;

	curr_tk = token->content;
	next_tk = (token->next ? token->next->content : NULL);
	if (next_tk && curr_tk->id == SEMI && next_tk->id == RBRACE)
		return (0);
	return (1);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x30c7
movq (%rax), %rcx
testq %rcx, %rcx
je 0x30c7
movq (%rdi), %rax
cmpl $0x1, 0x8(%rax)
jne 0x30c7
xorl %eax, %eax
cmpl $0x7, 0x8(%rcx)
je 0x30cc
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_start
int		lexer_forbidden_start(t_list *tk_head)
{
	const int	*is_start = (int	[]){SEMI, LBRACE, PIPE, OR_IF, AND_IF, -1};
	const int	*forbidden = (int	[]){SEMI, PIPE, OR_IF, AND_IF, RBRACE, -1};

	if (lexer_tk_id_chr(forbidden, tk_head->content))
		return (((t_token *)tk_head->content)->id);
	while (tk_head)
	{
		if (lexer_forbidden_start_no_exceptions(tk_head))
			if (tk_head->next && lexer_tk_id_chr(is_start, tk_head->content) &&
					lexer_tk_id_chr(forbidden, tk_head->next->content))
				return (((t_token *)tk_head->next->content)->id);
		tk_head = tk_head->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movups 0x7fdb(%rip), %xmm0     # 0xb0bc
movaps %xmm0, (%rsp)
movabsq $-0xfffffffb, %rax      # imm = 0xFFFFFFFF00000005
movq %rax, 0x10(%rsp)
movups 0x7fd9(%rip), %xmm0     # 0xb0d4
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $-0xfffffff9, %rax      # imm = 0xFFFFFFFF00000007
movq %rax, 0x10(%rsi)
movq (%rdi), %rdi
callq 0x2da8
testl %eax, %eax
je 0x3174
movq %rsp, %r14
leaq 0x20(%rsp), %r15
xorl %ebp, %ebp
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x317d
movq (%rbx), %rdi
movq (%rcx), %rax
testq %rax, %rax
je 0x3147
cmpl $0x1, 0x8(%rdi)
jne 0x3147
cmpl $0x7, 0x8(%rax)
je 0x316a
movq %r14, %rsi
callq 0x2da8
movq 0x8(%rbx), %rcx
testl %eax, %eax
jne 0x316a
movq (%rcx), %rdi
movq %r15, %rsi
callq 0x2da8
movq 0x8(%rbx), %rcx
testl %eax, %eax
je 0x3177
movq %rcx, %rbx
testq %rcx, %rcx
jne 0x3127
jmp 0x317d
movq %rbx, %rcx
movq (%rcx), %rax
movl 0x8(%rax), %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_combo
int		lexer_forbidden_combo(t_list *tk_head)
{
	const int	*forbidden = (int	[]){SEMI, PIPE, OR_IF, AND, AND_IF, RBRACE,
		LBRACE, LESS, DLESS, GREAT, DGREAT, -1};
	const int	*matter = (int	[]){LESS, DLESS, GREAT, DGREAT, -1};

	while (tk_head)
	{
		if (lexer_tk_id_chr(matter, tk_head->content))
		{
			if (tk_head->next \
					&& lexer_tk_id_chr(forbidden, tk_head->next->content))
				return (((t_token *)tk_head->next->content)->id);
		}
		tk_head = tk_head->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movups 0x7f71(%rip), %xmm0     # 0xb10c
movaps %xmm0, 0x40(%rsp)
movups 0x7f55(%rip), %xmm0     # 0xb0fc
movaps %xmm0, 0x30(%rsp)
movups 0x7f39(%rip), %xmm0     # 0xb0ec
movaps %xmm0, 0x20(%rsp)
movups 0x7f5d(%rip), %xmm0     # 0xb11c
movaps %xmm0, (%rsp)
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x320d
movq %rdi, %rbx
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2da8
testl %eax, %eax
jne 0x3204
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3204
movq (%rax), %rdi
movq %r15, %rsi
callq 0x2da8
testl %eax, %eax
je 0x321a
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x31dd
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl 0x8(%rax), %ebp
jmp 0x320d
nop