LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/parser.c
// Function: GetCmd
int GetCmd(void)
{
  extern int LabelTable[256];

  int len = 0;
  char *ptr = Current.Cmd;

  memset(Current.Cmd, 0, 80);
  Current.CmdLen = 0;

  if ( KillSpace() ){
    if (isalpha(atom) || atom == '_' || atom == '.' )
      do{
        *ptr++ = atom;
        len++;
      }while ( GetAtom() && (LabelTable[atom] || atom == '.') );
  }
  Current.CmdLen = len;
  *ptr++ = 0;
  return (len == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x121b2(%rip), %rax     # 0x185f8
addq $0x94, %rax
movq %rax, -0x10(%rbp)
leaq 0x121a1(%rip), %rdi     # 0x185f8
addq $0x94, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x30c0
leaq 0x12187(%rip), %rax     # 0x185f8
movl $0x0, 0x90(%rax)
callq 0x5ad0
cmpl $0x0, %eax
je 0x6524
callq 0x31d0
movq (%rax), %rax
movslq 0x1aa88(%rip), %rcx     # 0x20f20
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x64b8
cmpl $0x5f, 0x1aa73(%rip)    # 0x20f20
je 0x64b8
cmpl $0x2e, 0x1aa6a(%rip)    # 0x20f20
jne 0x6522
jmp 0x64ba
movl 0x1aa60(%rip), %eax     # 0x20f20
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
callq 0x59e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x6519
movslq 0x1aa2c(%rip), %rdx     # 0x20f20
movb $0x1, %al
leaq 0x1b2a3(%rip), %rcx     # 0x217a0
cmpl $0x0, (%rcx,%rdx,4)
movb %al, -0x12(%rbp)
jne 0x6513
cmpl $0x2e, 0x1aa13(%rip)    # 0x20f20
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x64ba
jmp 0x6522
jmp 0x6524
movl -0x4(%rbp), %ecx
leaq 0x120ca(%rip), %rax     # 0x185f8
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
cmpl $0x0, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/parser.c
// Function: GetComment
int GetComment(void)
{
  if ( !KillSpace() ) return 0;

  if ( atom != ';' ){
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5ad0
cmpl $0x0, %eax
jne 0x657b
movl $0x0, -0x4(%rbp)
jmp 0x6594
cmpl $0x3b, 0x1a99e(%rip)    # 0x20f20
je 0x658d
movl $0x1, -0x4(%rbp)
jmp 0x6594
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: InitLabels
void InitLabels(void)
{
  int c,c1;

  memset((char *) hash, 0, 256*sizeof(label_t *));
  next_local =
    local_labels = (label_t *)my_malloc( sizeof(label_t) * MAX_LOCAL_LABELS );
  next_global =
    global_labels = (label_t *)my_malloc( sizeof(label_t) * MAX_GLOBAL_LABELS );
  next_macro =
    macro_labels = (label_t *)my_malloc( sizeof(label_t) * MAX_MACRO_LABELS );
  next_macroname =
    macronames = (label_t *)my_malloc( sizeof(label_t) * MAX_MACROS);

  memset((char *)LabelTable, FALSE, 256 * sizeof(int) );

  for (c = 'A',c1 = 'a'; c <= 'Z'; c++,c1++){
    LabelTable[ c ] = TRUE;
    LabelTable[ c1 ]= TRUE;
  }
  for (c = '0'; c <= '9'; c++)
    LabelTable[ c ] = TRUE;

  LabelTable[(int)'_'] = TRUE;
  LabelTable[(int)'@'] = TRUE;
  LabelTable[(int)'.'] = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1a911(%rip), %rdi     # 0x20f60
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x30c0
movl $0xc000, %edi           # imm = 0xC000
callq 0x32e0
movq %rax, 0x1b0f4(%rip)     # 0x21760
movq %rax, 0x1b0f5(%rip)     # 0x21768
movl $0xc0000, %edi          # imm = 0xC0000
callq 0x32e0
movq %rax, 0x1b0ec(%rip)     # 0x21770
movq %rax, 0x1b0ed(%rip)     # 0x21778
movl $0xc000, %edi           # imm = 0xC000
callq 0x32e0
movq %rax, 0x1b0e4(%rip)     # 0x21780
movq %rax, 0x1b0e5(%rip)     # 0x21788
movl $0x18000, %edi          # imm = 0x18000
callq 0x32e0
movq %rax, 0x1b0dc(%rip)     # 0x21790
movq %rax, 0x1b0dd(%rip)     # 0x21798
leaq 0x1b0de(%rip), %rdi     # 0x217a0
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x30c0
movl $0x41, -0x4(%rbp)
movl $0x61, -0x8(%rbp)
cmpl $0x5a, -0x4(%rbp)
jg 0x671a
movslq -0x4(%rbp), %rcx
leaq 0x1b0b3(%rip), %rax     # 0x217a0
movl $0x1, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0x1b0a1(%rip), %rax     # 0x217a0
movl $0x1, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x66dc
movl $0x30, -0x4(%rbp)
cmpl $0x39, -0x4(%rbp)
jg 0x6744
movslq -0x4(%rbp), %rcx
leaq 0x1b06e(%rip), %rax     # 0x217a0
movl $0x1, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6721
movl $0x1, 0x1b1ce(%rip)     # 0x2191c
movl $0x1, 0x1b148(%rip)     # 0x218a0
movl $0x1, 0x1b0f6(%rip)     # 0x21858
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: ComputeHash
int ComputeHash(char * s)
{
  int hashval = 0;
  int pos = 0;
  while ( *s ){
    hashval ^= pos;
    hashval += (int) *s;
    ++s;
    ++pos;
  }
  return (hashval & 255);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x67bc
movl -0x10(%rbp), %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6786
movl -0xc(%rbp), %eax
andl $0xff, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: ClearLocals
void ClearLocals()
{
  CheckForUnsolvedLocals();
  next_local = local_labels;
  local_hook = NULL;
  memset((char *)local_labels, 0,  sizeof(label_t)*MAX_LOCAL_LABELS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, %al
callq 0x4bc0
movq 0x1af7e(%rip), %rax     # 0x21760
movq %rax, 0x1af7f(%rip)     # 0x21768
movq $0x0, 0x1a73c(%rip) # 0x20f30
movq 0x1af65(%rip), %rdi     # 0x21760
xorl %esi, %esi
movl $0xc000, %edx           # imm = 0xC000
callq 0x30c0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: FindLabel
label_t * FindLabel(label_t *l, int32_t *value)
{
  label_t *next;

  if ( l->type & LOCAL ){
    next = local_hook;
    if ( l->type & MACRO ){
      next = macro_hook;
    }
  } else {
    next = hash[ComputeHash(l->name)];
  }

  for ( ; next; next = next->next ){

    //  printf("FindLabel:(%s)%p\n",next->name,next->next);

    if ( (l->len == next->len) && !strcmp(l->name,next->name)){
      *value = (int32_t)next->value;
      l->type = next->type;
      if ( next->type & UNSOLVED )
        return 0;
      else
        return next;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6f66
movq 0x19fea(%rip), %rax     # 0x20f30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6f64
movq 0x19fd8(%rip), %rax     # 0x20f38
movq %rax, -0x20(%rbp)
jmp 0x6f85
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x6770
movslq %eax, %rcx
leaq 0x19fe3(%rip), %rax     # 0x20f60
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x6f87
cmpq $0x0, -0x20(%rbp)
je 0x700c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x6ff9
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
addq $0x38, %rsi
callq 0x3100
cmpl $0x0, %eax
jne 0x6ff9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x6fef
movq $0x0, -0x8(%rbp)
jmp 0x7014
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7014
jmp 0x6ffb
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6f87
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: FindMacro
int FindMacro(char *s, label_t ** macro)
{
  label_t *ptr = macroname_hook;

  while ( ptr ){
    if ( ! strcmp(s,ptr->name) ){
      break;
    }
    ptr = ptr->next;
  }
  if ( ! ptr ){
    return 1;
  }

  *macro = ptr;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x19f09(%rip), %rax     # 0x20f40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7068
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x38, %rsi
callq 0x3100
cmpl $0x0, %eax
jne 0x705a
jmp 0x7068
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x703b
cmpq $0x0, -0x20(%rbp)
jne 0x7078
movl $0x1, -0x4(%rbp)
jmp 0x708a
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: DumpGlobals
void DumpGlobals()
{
  label_t * next;
  int i;
  fprintf(my_stderr,"Global labels:\n");
  for (i = 0; i < 256; ++i){
    for( next = hash[i] ; next ; next = next->next ){
      if ( !(next->type & UNSOLVED) && (next->type & GLOBAL)){
        if ( Global.mainMode == JAGUAR_DSP || Global.mainMode == JAGUAR_GPU ){
          fprintf(my_stderr,"<%32s> = %016"PRIx64" %02x [%5d %s]\n",
                  next->name, next->value, next->type,
                  next->line, file_list[next->file].name);
        } else {
          fprintf(my_stderr,"<%32s> = %08x %02x [%5d %s]\n",
                  next->name, (uint32_t)next->value, next->type,
                  next->line, file_list[next->file].name);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x114f9(%rip), %rax     # 0x185e8
movq (%rax), %rdi
leaq 0xa085(%rip), %rsi      # 0x1117e
movb $0x0, %al
callq 0x3120
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x724f
movslq -0xc(%rbp), %rcx
leaq 0x19e41(%rip), %rax     # 0x20f60
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x723f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x722c
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x722c
leaq 0x1123f(%rip), %rax     # 0x183a0
cmpl $0x3, 0x1c(%rax)
je 0x7174
leaq 0x11232(%rip), %rax     # 0x183a0
cmpl $0x2, 0x1c(%rax)
jne 0x71cf
leaq 0x1146d(%rip), %rax     # 0x185e8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x38, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rsi
leaq 0x11623(%rip), %rax     # 0x187d0
imulq $0x204, %rsi, %rsi      # imm = 0x204
addq %rsi, %rax
addq $0x4, %rax
leaq 0x9fcc(%rip), %rsi      # 0x1118e
movq %rax, (%rsp)
movb $0x0, %al
callq 0x3120
jmp 0x722a
leaq 0x11412(%rip), %rax     # 0x185e8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x38, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rsi
leaq 0x115c6(%rip), %rax     # 0x187d0
imulq $0x204, %rsi, %rsi      # imm = 0x204
addq %rsi, %rax
addq $0x4, %rax
leaq 0x9f8e(%rip), %rsi      # 0x111ad
movq %rax, (%rsp)
movb $0x0, %al
callq 0x3120
jmp 0x722c
jmp 0x722e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7127
jmp 0x7241
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7107
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: hashStatistics
void hashStatistics()
{
  int i,total = 0;
  label_t *next;
  for(i = 0 ; i < 256;++i){
    int o = 0;
    for (next = hash[i]; next; next = next->next ){
      ++o;
    }
    total += o;
    printf("%4d ",o);
  }
  printf("\n total:%d\n",total);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x74ec
movl $0x0, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x19abf(%rip), %rax     # 0x20f60
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x74c7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x74a9
movl -0x14(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %esi
leaq 0x9d37(%rip), %rdi      # 0x11211
movb $0x0, %al
callq 0x30b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7486
movl -0x8(%rbp), %esi
leaq 0x9d20(%rip), %rdi      # 0x11216
movb $0x0, %al
callq 0x30b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: DumpLocals
void DumpLocals()
{
  label_t * next = local_labels;
  fprintf(my_stderr,"Local labels:\n");
  for ( ; next ; next = next->next ){
    if ( Global.mainMode == JAGUAR_DSP || Global.mainMode == JAGUAR_GPU ){
      fprintf(my_stderr,"<%32s> = %0"PRIx64" [%5d %s]\n",
              next->name,next->value,next->line,file_list[next->file].name);
    } else {
      fprintf(my_stderr,"<%32s> = %04x [%5d %s]\n",
              next->name,(uint32_t)next->value,
              next->line,file_list[next->file].name);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1a241(%rip), %rax     # 0x21760
movq %rax, -0x8(%rbp)
leaq 0x110be(%rip), %rax     # 0x185e8
movq (%rax), %rdi
leaq 0x9cee(%rip), %rsi      # 0x11222
movb $0x0, %al
callq 0x3120
cmpq $0x0, -0x8(%rbp)
je 0x7611
leaq 0x10e53(%rip), %rax     # 0x183a0
cmpl $0x3, 0x1c(%rax)
je 0x7560
leaq 0x10e46(%rip), %rax     # 0x183a0
cmpl $0x2, 0x1c(%rax)
jne 0x75af
leaq 0x11081(%rip), %rax     # 0x185e8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x38, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r8d
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rax
leaq 0x1123f(%rip), %r9      # 0x187d0
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rax, %r9
addq $0x4, %r9
leaq 0x9c8b(%rip), %rsi      # 0x11231
movb $0x0, %al
callq 0x3120
jmp 0x75fe
leaq 0x11032(%rip), %rax     # 0x185e8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x38, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r8d
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rax
leaq 0x111ee(%rip), %r9      # 0x187d0
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rax, %r9
addq $0x4, %r9
leaq 0x9c52(%rip), %rsi      # 0x11249
movb $0x0, %al
callq 0x3120
jmp 0x7600
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x753b
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: DumpMacros
void DumpMacros()
{
  label_t * next = macroname_hook;
  fprintf(my_stderr,"Macros:\n");
  for ( ; next ; next = next->next ){
    fprintf(my_stderr,"<%32s> [%5d %s]\n",
            next->name,next->line,file_list[next->file].name);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x19911(%rip), %rax     # 0x20f40
movq %rax, -0x8(%rbp)
leaq 0x10fae(%rip), %rax     # 0x185e8
movq (%rax), %rdi
leaq 0x9c1d(%rip), %rsi      # 0x11261
movb $0x0, %al
callq 0x3120
cmpq $0x0, -0x8(%rbp)
je 0x76a4
leaq 0x10f8f(%rip), %rax     # 0x185e8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x38, %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rax
leaq 0x11156(%rip), %r8      # 0x187d0
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rax, %r8
addq $0x4, %r8
leaq 0x99cf(%rip), %rsi      # 0x1105e
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x764b
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/label.c
// Function: newSymbol
label_t * newSymbol(const char *name, uint64_t value)
{
  label_t label = {0};
  int solved;

  label.value = value;
  label.type = NORMAL;
  strcpy(label.name, name);
  label.len   = strlen(name);
  label.file  = 0;
  label.line  = 0;

  return DefineLabel(&label, &solved);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x30c0
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x1, -0x6c(%rbp)
leaq -0x70(%rbp), %rdi
addq $0x38, %rdi
movq -0x8(%rbp), %rsi
callq 0x3060
movq -0x8(%rbp), %rdi
callq 0x30a0
movl %eax, -0x70(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x6810
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/opcode.c
// Function: SearchOpcode
int SearchOpcode(const struct opcode_s *list, const char *s)
{
  const struct opcode_s *curr;

  if ( strlen(s) > 7 ){
    return -1;
  }
  curr = list;
  while ( curr->name[0] ){
    if ( !strcasecmp(curr->name,s) ){
      //      printf("Found (%s)\n",curr->name);
      return curr->func( curr->misc );
    }
    curr++;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30a0
cmpq $0x7, %rax
jbe 0x7758
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x77a6
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x779f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3050
cmpl $0x0, %eax
jne 0x7791
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %edi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x77a6
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x7760
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/opcode.c
// Function: SearchOpcode2
int SearchOpcode2(const struct opcode_s *list,
                  const char *s,
                  int (**fun)(int ),
                  int *para)
{
  const struct opcode_s *curr;
  extern int mac_mode;

  // ignore leading dot
  if ( s[0] == '.' ){
    ++s;
  }
  if ( strlen(s) > 7 && !mac_mode ){
    return -1;
  }

  if ( Global.mainMode != JAGUAR_GPU &&
       Global.mainMode != JAGUAR_DSP &&
       !strcasecmp(s,"DP") )
    {
      return -1;
    }
  curr = list;

  while ( curr->name[0] ){
    if ( !strcasecmp(curr->name,s) ){
      //      printf("Found (%s)\n",curr->name);
      *fun = curr->func;
      *para = curr->misc;
      return 1;
    }
    curr++;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x77e0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30a0
cmpq $0x7, %rax
jbe 0x7807
leaq 0x1a3aa(%rip), %rax     # 0x21ba0
cmpl $0x0, (%rax)
jne 0x7807
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x789c
leaq 0x10b92(%rip), %rax     # 0x183a0
cmpl $0x2, 0x1c(%rax)
je 0x783f
leaq 0x10b85(%rip), %rax     # 0x183a0
cmpl $0x3, 0x1c(%rax)
je 0x783f
movq -0x18(%rbp), %rdi
leaq 0x9a3e(%rip), %rsi      # 0x1126a
callq 0x3050
cmpl $0x0, %eax
jne 0x783f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x789c
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7895
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3050
cmpl $0x0, %eax
jne 0x7887
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x789c
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x7847
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_org
int p_org(int d)
{
  int32_t l;
  int err;

  if ( (err = NeedConst( &l, "ORG" )) ) return err;

  if ( Global.genesis == 1 && mac_mode == 0){
    if ( (uint32_t)l < Global.pc ) return Error(SYNTAX_ERR,"");
    writeSameBytes( 0, l-Global.pc );
  } else {
    Global.pc = (uint32_t)l;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
leaq 0x99a7(%rip), %rsi      # 0x1126d
callq 0xc9f0
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0x78db
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x793d
leaq 0x10abe(%rip), %rax     # 0x183a0
cmpl $0x1, 0x14(%rax)
jne 0x792a
cmpl $0x0, 0x1a2b1(%rip)     # 0x21ba0
jne 0x792a
movl -0xc(%rbp), %eax
leaq 0x10aa5(%rip), %rcx     # 0x183a0
cmpl (%rcx), %eax
jae 0x7915
movl $0x12, %edi
leaq 0x9752(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x793d
movl -0xc(%rbp), %esi
leaq 0x10a81(%rip), %rax     # 0x183a0
subl (%rax), %esi
xorl %edi, %edi
callq 0x3500
jmp 0x7936
movl -0xc(%rbp), %ecx
leaq 0x10a6c(%rip), %rax     # 0x183a0
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_run
int p_run(int d)
{
  int err;
  int32_t l;

  KillSpace();
  if ( !atom ) {
    l = Global.pc;
  } else {
    if ( (err = NeedConst( &l, "RUN" )) ) return err;
  }
  if ( Global.run == -1){
    Global.mainMode = sourceMode;
    Global.run = l;
    Global.genesis = 1;
  }
  Global.pc = l;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x19567(%rip), %rax     # 0x20f20
cmpl $0x0, (%rax)
jne 0x79cc
leaq 0x109db(%rip), %rax     # 0x183a0
movl (%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x79ee
leaq -0x10(%rbp), %rdi
leaq 0x989a(%rip), %rsi      # 0x11271
callq 0xc9f0
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x79ec
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7a3c
jmp 0x79ee
leaq 0x109ab(%rip), %rax     # 0x183a0
cmpl $-0x1, 0x10(%rax)
jne 0x7a29
leaq 0x10bde(%rip), %rax     # 0x185e0
movl (%rax), %ecx
leaq 0x10995(%rip), %rax     # 0x183a0
movl %ecx, 0x1c(%rax)
movl -0x10(%rbp), %ecx
leaq 0x10988(%rip), %rax     # 0x183a0
movl %ecx, 0x10(%rax)
leaq 0x1097e(%rip), %rax     # 0x183a0
movl $0x1, 0x14(%rax)
movl -0x10(%rbp), %ecx
leaq 0x1096d(%rip), %rax     # 0x183a0
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_endm
int p_endm(int d)
{
  if ( Current.Macro.Define ){
    return EndDefineMacro();
  } else {
    Current.SrcPtr = 0;
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0x10a96(%rip), %rax     # 0x185f8
cmpl $0x0, 0xc(%rax)
je 0x7b74
movb $0x0, %al
callq 0xcb30
movl %eax, -0x4(%rbp)
jmp 0x7b8d
leaq 0x10a7d(%rip), %rax     # 0x185f8
movq $0x0, 0x198(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_definebyte
int p_definebyte(int d)
{
  char help[80];
  int err;
  int32_t l;
  int all_err = 0;

  KillSpace();
  if ( atom == EOF ) return Error(SYNTAX_ERR, "Missing String");
  do{
    if ( TestAtom('"') ){
      if ( !GetString( help ,'"' ) ) return Error(SYNTAX_ERR, "Missing '\"'");
      if ( d ){
        translate(help);
      }
      writeBytes(help,(int)strlen(help));
    }
    else if ( TestAtom('\'') ){
      if ( !GetString( help ,'\'' ) ) return Error(SYNTAX_ERR, "Missing \"'\"");
      if ( d ){
        translate(help);
      }
      writeBytes(help,(int)strlen(help));
    }
    else {
      if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
      if ( err == EXPR_UNSOLVED ) ++all_err;
      if ( l < -128 || l > 255 ) return Error(BYTE_ERR,"");
      if ( d ) l = transASCII[l];
      writeByte((char)l);
    }
  } while ( TestAtom(',') );

  if ( all_err ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x6c(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x1935d(%rip), %rax     # 0x20f20
cmpl $-0x1, (%rax)
jne 0x7be1
movl $0x12, %edi
leaq 0x96a6(%rip), %rsi      # 0x1127a
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7d55
jmp 0x7be3
movl $0x22, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0x7c4e
leaq -0x60(%rbp), %rdi
movl $0x22, %esi
callq 0x5b40
cmpl $0x0, %eax
jne 0x7c1e
movl $0x12, %edi
leaq 0x9678(%rip), %rsi      # 0x11289
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7d55
cmpl $0x0, -0x8(%rbp)
je 0x7c2d
leaq -0x60(%rbp), %rdi
callq 0x9f80
leaq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x30a0
movq -0x78(%rbp), %rdi
movl %eax, %esi
callq 0x35b0
jmp 0x7d2c
movl $0x27, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0x7cb6
leaq -0x60(%rbp), %rdi
movl $0x27, %esi
callq 0x5b40
cmpl $0x0, %eax
jne 0x7c89
movl $0x12, %edi
leaq 0x9619(%rip), %rsi      # 0x11295
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7d55
cmpl $0x0, -0x8(%rbp)
je 0x7c98
leaq -0x60(%rbp), %rdi
callq 0x9f80
leaq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x30a0
movq -0x80(%rbp), %rdi
movl %eax, %esi
callq 0x35b0
jmp 0x7d2a
leaq -0x68(%rbp), %rdi
callq 0xc920
movl %eax, -0x64(%rbp)
cmpl $0x1, %eax
jne 0x7cd3
movl $0x1, -0x4(%rbp)
jmp 0x7d55
cmpl $0x2, -0x64(%rbp)
jne 0x7ce2
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
cmpl $-0x80, -0x68(%rbp)
jl 0x7cf1
cmpl $0xff, -0x68(%rbp)
jle 0x7d07
movl $0x1a, %edi
leaq 0x9360(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7d55
cmpl $0x0, -0x8(%rbp)
je 0x7d1f
movslq -0x68(%rbp), %rcx
leaq 0x19e98(%rip), %rax     # 0x21bb0
movsbl (%rax,%rcx), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %eax
movsbl %al, %edi
callq 0x3470
jmp 0x7d2c
jmp 0x7d2e
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0x7be3
cmpl $0x0, -0x6c(%rbp)
je 0x7d4e
movb $0x0, %al
callq 0xcfe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_defineword
int p_defineword(int d)
{
  int err;
  int32_t l;
  int all_err = 0;

  KillSpace();
  if ( atom == EOF ) return Error(SYNTAX_ERR,"");
  do{
    if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
    if ( err == EXPR_UNSOLVED ) ++all_err;
    if ( l < -32768L || l > 65535L ) return Error(WORD_ERR,"");
    if ( Endian() == targetLITTLE_ENDIAN ){
      writeWordLittle((short)l);
    }else{
      writeWordBig((short)l);
    }
  } while ( TestAtom(',') );

  if ( all_err ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x19190(%rip), %rax     # 0x20f20
cmpl $-0x1, (%rax)
jne 0x7dae
movl $0x12, %edi
leaq 0x92bc(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7e57
jmp 0x7db0
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0x7dcd
movl $0x1, -0x4(%rbp)
jmp 0x7e57
cmpl $0x2, -0xc(%rbp)
jne 0x7ddc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movslq -0x10(%rbp), %rax
cmpq $-0x8000, %rax          # imm = 0x8000
jl 0x7df4
movslq -0x10(%rbp), %rax
cmpq $0xffff, %rax           # imm = 0xFFFF
jle 0x7e0a
movl $0x1b, %edi
leaq 0x925d(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7e57
callq 0xb9a0
cmpl $0x4321, %eax           # imm = 0x4321
jne 0x7e23
movl -0x10(%rbp), %eax
movswl %ax, %edi
callq 0x3670
jmp 0x7e2e
movl -0x10(%rbp), %eax
movswl %ax, %edi
callq 0x3730
jmp 0x7e30
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0x7db0
cmpl $0x0, -0x14(%rbp)
je 0x7e50
movb $0x0, %al
callq 0xcfe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_definelong
int p_definelong(int d)
{
  int err;
  int32_t l;
  int all_err = 0;

  KillSpace();
  if ( atom == EOF ) return Error(SYNTAX_ERR,"");
  do{
    if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
    if ( err == EXPR_UNSOLVED ) ++all_err;
    if ( Endian() == targetLITTLE_ENDIAN ){
      writeLongLittle( (long)l );
    }else{
      writeLongBig( (long)l );
    }
  } while ( TestAtom(',') );

  if ( all_err ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x190a0(%rip), %rax     # 0x20f20
cmpl $-0x1, (%rax)
jne 0x7e9b
movl $0x12, %edi
leaq 0x91cc(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7f0f
jmp 0x7e9d
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0x7eb7
movl $0x1, -0x4(%rbp)
jmp 0x7f0f
cmpl $0x2, -0xc(%rbp)
jne 0x7ec6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
callq 0xb9a0
cmpl $0x4321, %eax           # imm = 0x4321
jne 0x7edf
movslq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x37f0
jmp 0x7eea
movslq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x38f0
jmp 0x7eec
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0x7e9d
cmpl $0x0, -0x14(%rbp)
je 0x7f08
movb $0x0, %al
callq 0xcfe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_definephrase
int p_definephrase(int d)
{
  int err;
  int64_t ll;
  int all_err = 0;

  KillSpace();
  if ( atom == EOF ) return Error(SYNTAX_ERR,"");
  do{
    if ( (err = Expression64( &ll )) == EXPR_ERROR ) return 1;
    if ( err == EXPR_UNSOLVED ) ++all_err;
    if ( Endian() == targetLITTLE_ENDIAN ){
      writePhraseLittle( ll );
    }else{
      writePhraseBig( ll );
    }
  } while ( TestAtom(',') );

  if ( all_err ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x18fe0(%rip), %rax     # 0x20f20
cmpl $-0x1, (%rax)
jne 0x7f5b
movl $0x12, %edi
leaq 0x910c(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x7fcb
jmp 0x7f5d
leaq -0x18(%rbp), %rdi
callq 0xc6e0
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0x7f77
movl $0x1, -0x4(%rbp)
jmp 0x7fcb
cmpl $0x2, -0xc(%rbp)
jne 0x7f86
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
callq 0xb9a0
cmpl $0x4321, %eax           # imm = 0x4321
jne 0x7f9d
movq -0x18(%rbp), %rdi
callq 0x39f0
jmp 0x7fa6
movq -0x18(%rbp), %rdi
callq 0x3b70
jmp 0x7fa8
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0x7f5d
cmpl $0x0, -0x1c(%rbp)
je 0x7fc4
movb $0x0, %al
callq 0xcfe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_include
int p_include(int d)
{
  int err;

  if (Global.Files == MAX_INCLUDE) return Error(-INCLUDE_ERR,"");

  if ( GetFileName() ) return 1;

  KillSpace();

  if ( atom ) return Error(GARBAGE_ERR,srcLine);

  ClearLocals();

  struct current_s save_current = Current;

  Global.Files++;
  LoadSource(filename);
  Current.File = Global.Files;
  err = mainloop(0);

  Current = save_current;

  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movl %edi, -0x8(%rbp)
leaq 0x1035b(%rip), %rax     # 0x183a0
cmpl $0x40, 0xc(%rax)
jne 0x8064
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x9006(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8123
movb $0x0, %al
callq 0x5bf0
cmpl $0x0, %eax
je 0x807c
movl $0x1, -0x4(%rbp)
jmp 0x8123
movb $0x0, %al
callq 0x5ad0
leaq 0x18e96(%rip), %rax     # 0x20f20
cmpl $0x0, (%rax)
je 0x80a5
movl $0x18, %edi
leaq 0x18d75(%rip), %rsi     # 0x20e10
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8123
movb $0x0, %al
callq 0x67d0
leaq -0x1d0(%rbp), %rdi
leaq 0x1053e(%rip), %rsi     # 0x185f8
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x3140
leaq 0x102d5(%rip), %rax     # 0x183a0
movl 0xc(%rax), %ecx
addl $0x1, %ecx
leaq 0x102c8(%rip), %rax     # 0x183a0
movl %ecx, 0xc(%rax)
leaq 0x189fe(%rip), %rdi     # 0x20ae0
callq 0x5070
leaq 0x102b2(%rip), %rax     # 0x183a0
movl 0xc(%rax), %ecx
leaq 0x10500(%rip), %rax     # 0x185f8
movl %ecx, 0x4(%rax)
xorl %edi, %edi
callq 0x48f0
movl %eax, -0xc(%rbp)
leaq 0x104ec(%rip), %rdi     # 0x185f8
leaq -0x1d0(%rbp), %rsi
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x3140
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_trans
int p_trans(int d)
{
  long len;
  int32_t offset = 0;

  if ( GetFileName() ) return 1;

  if ( TestAtom(',') ){
    if ( NeedConst( &offset ,"TRANS" ) ) return 1;
  }

  if ( LoadFile(transASCII, offset, 256, filename, &len ) ) return 1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x5bf0
cmpl $0x0, %eax
je 0x8187
movl $0x1, -0x4(%rbp)
jmp 0x81eb
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0x81b6
leaq -0x14(%rbp), %rdi
leaq 0x9100(%rip), %rsi      # 0x112a1
callq 0xc9f0
cmpl $0x0, %eax
je 0x81b4
movl $0x1, -0x4(%rbp)
jmp 0x81eb
jmp 0x81b6
movslq -0x14(%rbp), %rsi
leaq 0x199ef(%rip), %rdi     # 0x21bb0
movl $0x100, %edx            # imm = 0x100
leaq 0x18913(%rip), %rcx     # 0x20ae0
leaq -0x10(%rbp), %r8
callq 0x3d30
cmpl $0x0, %eax
je 0x81e4
movl $0x1, -0x4(%rbp)
jmp 0x81eb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_path
int p_path(int d)
{
  int i;

  KillSpace();

  memset(filename, 0, 512);

  if ( !atom ){
    Global.Path[0] = 0;
    return 0;
  }

  if ( atom != '"' ) return Error(SYNTAX_ERR,"");
  GetAtom();

  if ( !GetString( filename, '"' ) ) return Error(SYNTAX_ERR,"Missing '\"'");

  i = (int)strlen(filename);
  if ( i && filename[i-1] != '/'){
    filename[i] = '/';
  }

  strcat(Global.Path,filename);
  if ( chgPathToUpper ){
    char *ptr = Global.Path;
    char c;
    while ( (c = *ptr) )
      *ptr++ = toupper(c);
  }

  return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x188c7(%rip), %rdi     # 0x20ae0
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x30c0
leaq 0x18cf4(%rip), %rax     # 0x20f20
cmpl $0x0, (%rax)
jne 0x8248
leaq 0x10168(%rip), %rax     # 0x183a0
movb $0x0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8344
leaq 0x18cd1(%rip), %rax     # 0x20f20
cmpl $0x22, (%rax)
je 0x826d
movl $0x12, %edi
leaq 0x8dfd(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8344
callq 0x59e0
leaq 0x18867(%rip), %rdi     # 0x20ae0
movl $0x22, %esi
callq 0x5b40
cmpl $0x0, %eax
jne 0x82a1
movl $0x12, %edi
leaq 0x8ff5(%rip), %rsi      # 0x11289
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8344
leaq 0x18838(%rip), %rdi     # 0x20ae0
callq 0x30a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x82de
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1881a(%rip), %rax     # 0x20ae0
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x82de
movslq -0xc(%rbp), %rcx
leaq 0x18806(%rip), %rax     # 0x20ae0
movb $0x2f, (%rax,%rcx)
leaq 0x100bb(%rip), %rdi     # 0x183a0
addq $0x20, %rdi
leaq 0x187f0(%rip), %rsi     # 0x20ae0
callq 0x3190
leaq 0x102f4(%rip), %rax     # 0x185f0
cmpl $0x0, (%rax)
je 0x833d
leaq 0x10098(%rip), %rax     # 0x183a0
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
cmpb $0x0, %al
je 0x833b
movsbl -0x19(%rbp), %edi
callq 0x3070
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x8310
jmp 0x833d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_equ
int p_equ(int d)
{
  int32_t l;

  if ( NeedConst( &l, "EQU") ) return 1;

  if ( ! Current.Label.len ){
    Error(SYNTAX_ERR,"");
  }
  if ( (Current.Label.type &  REGISTER) ){
    Error(SYNTAX_ERR,"Cannot EQU a register label");
  }

  if ( (Current.Label.type & VARIABLE) == 0){
    Current.LabelPtr->value = l;
  }
  Current.Label.type &= ~CODELABEL;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
leaq 0x8f4d(%rip), %rsi      # 0x112b3
callq 0xc9f0
cmpl $0x0, %eax
je 0x837c
movl $0x1, -0x4(%rbp)
jmp 0x8403
leaq 0x10275(%rip), %rax     # 0x185f8
cmpl $0x0, 0x28(%rax)
jne 0x839a
movl $0x12, %edi
leaq 0x8cc8(%rip), %rsi      # 0x1105d
callq 0xd130
leaq 0x10257(%rip), %rax     # 0x185f8
movl 0x2c(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x83bd
movl $0x12, %edi
leaq 0x8eff(%rip), %rsi      # 0x112b7
callq 0xd130
leaq 0x10234(%rip), %rax     # 0x185f8
movl 0x2c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x83e5
movslq -0xc(%rbp), %rcx
leaq 0x1021e(%rip), %rax     # 0x185f8
movq 0x88(%rax), %rax
movq %rcx, 0x8(%rax)
leaq 0x1020c(%rip), %rax     # 0x185f8
movl 0x2c(%rax), %ecx
andl $-0x1, %ecx
leaq 0x101ff(%rip), %rax     # 0x185f8
movl %ecx, 0x2c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_set
int p_set(int d)
{
  int32_t l;

  if ( NeedConst( &l, "SET") ) return 1;

  if ( ! Current.Label.len ) Error(SYNTAX_ERR,"");

  if ( (Current.Label.type &  REGISTER) ){
    Error(SYNTAX_ERR,"Cannot EQU a register label");
  }


  Current.LabelPtr->type |= VARIABLE;
  Current.LabelPtr->type &= ~CODELABEL;
  Current.LabelPtr->value = l;
  Current.varModifier++;
  //  printf("(%s)%d\n",Current.LabelPtr->name,Current.LabelPtr->value);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
leaq 0x8ead(%rip), %rsi      # 0x112d3
callq 0xc9f0
cmpl $0x0, %eax
je 0x843c
movl $0x1, -0x4(%rbp)
jmp 0x84e5
leaq 0x101b5(%rip), %rax     # 0x185f8
cmpl $0x0, 0x28(%rax)
jne 0x845a
movl $0x12, %edi
leaq 0x8c08(%rip), %rsi      # 0x1105d
callq 0xd130
leaq 0x10197(%rip), %rax     # 0x185f8
movl 0x2c(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x847d
movl $0x12, %edi
leaq 0x8e3f(%rip), %rsi      # 0x112b7
callq 0xd130
leaq 0x10174(%rip), %rax     # 0x185f8
movq 0x88(%rax), %rax
movl 0x4(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x4(%rax)
leaq 0x1015d(%rip), %rax     # 0x185f8
movq 0x88(%rax), %rax
movl 0x4(%rax), %ecx
andl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x10142(%rip), %rax     # 0x185f8
movq 0x88(%rax), %rax
movq %rcx, 0x8(%rax)
leaq 0x10130(%rip), %rax     # 0x185f8
movl 0xe8(%rax), %ecx
addl $0x1, %ecx
leaq 0x10120(%rip), %rax     # 0x185f8
movl %ecx, 0xe8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_if
int p_if(int d)
{
  int32_t l;

  if ( Current.ifCnt+1 == MAX_IF ) return Error(TOOMANYIF_ERR,"");

  PUSH_IF();

  if ( Current.ifFlag ) {
    TestAtom('#');             // skip a '#'

    if ( NeedConst( &l, "IF") ) return 1;

    Current.ifFlag = l != 0 ? 1 : 0;
    Current.ParseOnly = 0;
  } else {
    Current.ParseOnly = 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0x100f6(%rip), %rax     # 0x185f8
movl 0xf4(%rax), %eax
addl $0x1, %eax
cmpl $0x10, %eax
jne 0x8529
movl $0x1e, %edi
leaq 0x8b41(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x860d
leaq 0x100c8(%rip), %rax     # 0x185f8
movl 0xf8(%rax), %edx
leaq 0x100bb(%rip), %rax     # 0x185f8
movl 0xf4(%rax), %eax
addl $0x1, %eax
leaq 0x100ab(%rip), %rcx     # 0x185f8
movl %eax, 0xf4(%rcx)
movslq %eax, %rcx
leaq 0x1009b(%rip), %rax     # 0x185f8
movl %edx, 0xfc(%rax,%rcx,4)
leaq 0x1008d(%rip), %rax     # 0x185f8
movl 0xf0(%rax), %edx
leaq 0x10080(%rip), %rax     # 0x185f8
movslq 0xf4(%rax), %rcx
leaq 0x10072(%rip), %rax     # 0x185f8
movl %edx, 0x140(%rax,%rcx,4)
leaq 0x10064(%rip), %rax     # 0x185f8
cmpl $0x0, 0xf8(%rax)
je 0x85f5
movl $0x23, %edi
callq 0x5a90
leaq -0xc(%rbp), %rdi
leaq 0x8d25(%rip), %rsi      # 0x112d7
callq 0xc9f0
cmpl $0x0, %eax
je 0x85c5
movl $0x1, -0x4(%rbp)
jmp 0x860d
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
leaq 0x1001c(%rip), %rax     # 0x185f8
movl %ecx, 0xf8(%rax)
leaq 0x1000f(%rip), %rax     # 0x185f8
movl $0x0, 0xf0(%rax)
jmp 0x8606
leaq 0xfffc(%rip), %rax      # 0x185f8
movl $0x1, 0xf0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_ifdef
int p_ifdef(int d)
{
  int32_t l;
  label_t test;

  if ( Current.ifCnt+1 == MAX_IF ) return Error(TOOMANYIF_ERR,"");

  PUSH_IF();

  if ( Current.ifFlag ) {

    if ( GetLabel( &test ) ) return 1;

    Current.ifFlag = (FindLabel( &test, &l ) != 0);

    Current.ParseOnly = 0;
  } else {
    Current.ParseOnly = 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
leaq 0xffc6(%rip), %rax      # 0x185f8
movl 0xf4(%rax), %eax
addl $0x1, %eax
cmpl $0x10, %eax
jne 0x8659
movl $0x1e, %edi
leaq 0x8a11(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8735
leaq 0xff98(%rip), %rax      # 0x185f8
movl 0xf8(%rax), %edx
leaq 0xff8b(%rip), %rax      # 0x185f8
movl 0xf4(%rax), %eax
addl $0x1, %eax
leaq 0xff7b(%rip), %rcx      # 0x185f8
movl %eax, 0xf4(%rcx)
movslq %eax, %rcx
leaq 0xff6b(%rip), %rax      # 0x185f8
movl %edx, 0xfc(%rax,%rcx,4)
leaq 0xff5d(%rip), %rax      # 0x185f8
movl 0xf0(%rax), %edx
leaq 0xff50(%rip), %rax      # 0x185f8
movslq 0xf4(%rax), %rcx
leaq 0xff42(%rip), %rax      # 0x185f8
movl %edx, 0x140(%rax,%rcx,4)
leaq 0xff34(%rip), %rax      # 0x185f8
cmpl $0x0, 0xf8(%rax)
je 0x871d
leaq -0x70(%rbp), %rdi
callq 0x5de0
cmpl $0x0, %eax
je 0x86e4
movl $0x1, -0x4(%rbp)
jmp 0x8735
leaq -0x70(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6f20
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0xfef4(%rip), %rax      # 0x185f8
movl %ecx, 0xf8(%rax)
leaq 0xfee7(%rip), %rax      # 0x185f8
movl $0x0, 0xf0(%rax)
jmp 0x872e
leaq 0xfed4(%rip), %rax      # 0x185f8
movl $0x1, 0xf0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_ifvar
int p_ifvar(int d)
{

  if ( Current.ifCnt+1 == MAX_IF ) return Error(TOOMANYIF_ERR,"");

  PUSH_IF();

  if ( Current.ifFlag ) {
    KillSpace();

    Current.ifFlag = (atom != 0) ? 1 : 0;

    Current.ParseOnly = 0;
  } else {
    Current.ParseOnly = 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0xfd86(%rip), %rax      # 0x185f8
movl 0xf4(%rax), %eax
addl $0x1, %eax
cmpl $0x10, %eax
jne 0x8899
movl $0x1e, %edi
leaq 0x87d1(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8962
leaq 0xfd58(%rip), %rax      # 0x185f8
movl 0xf8(%rax), %edx
leaq 0xfd4b(%rip), %rax      # 0x185f8
movl 0xf4(%rax), %eax
addl $0x1, %eax
leaq 0xfd3b(%rip), %rcx      # 0x185f8
movl %eax, 0xf4(%rcx)
movslq %eax, %rcx
leaq 0xfd2b(%rip), %rax      # 0x185f8
movl %edx, 0xfc(%rax,%rcx,4)
leaq 0xfd1d(%rip), %rax      # 0x185f8
movl 0xf0(%rax), %edx
leaq 0xfd10(%rip), %rax      # 0x185f8
movslq 0xf4(%rax), %rcx
leaq 0xfd02(%rip), %rax      # 0x185f8
movl %edx, 0x140(%rax,%rcx,4)
leaq 0xfcf4(%rip), %rax      # 0x185f8
cmpl $0x0, 0xf8(%rax)
je 0x894a
movb $0x0, %al
callq 0x5ad0
leaq 0x18605(%rip), %rax     # 0x20f20
movl (%rax), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
leaq 0xfcc7(%rip), %rax      # 0x185f8
movl %ecx, 0xf8(%rax)
leaq 0xfcba(%rip), %rax      # 0x185f8
movl $0x0, 0xf0(%rax)
jmp 0x895b
leaq 0xfca7(%rip), %rax      # 0x185f8
movl $0x1, 0xf0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_switch
int p_switch(int d)
{
  int32_t l;

  if ( Current.switchCnt ) return Error(SWITCH_ERR,"");

  if ( NeedConst( &l, "SWITCH") ) return 1;

  Current.switchCnt++;
  Current.switchValue = l;
  Current.switchFlag = 0;
  Current.switchCaseMatch = 0;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0xfb96(%rip), %rax      # 0x185f8
cmpl $0x0, 0x184(%rax)
je 0x8a81
movl $0x21, %edi
leaq 0x85e6(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8af7
leaq -0xc(%rbp), %rdi
leaq 0x884e(%rip), %rsi      # 0x112da
callq 0xc9f0
cmpl $0x0, %eax
je 0x8a9f
movl $0x1, -0x4(%rbp)
jmp 0x8af7
leaq 0xfb52(%rip), %rax      # 0x185f8
movl 0x184(%rax), %ecx
addl $0x1, %ecx
leaq 0xfb42(%rip), %rax      # 0x185f8
movl %ecx, 0x184(%rax)
movslq -0xc(%rbp), %rcx
leaq 0xfb31(%rip), %rax      # 0x185f8
movq %rcx, 0x190(%rax)
leaq 0xfb23(%rip), %rax      # 0x185f8
movl $0x0, 0x188(%rax)
leaq 0xfb12(%rip), %rax      # 0x185f8
movl $0x0, 0x18c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_case
int p_case(int d)
{
  int32_t l;

  if ( !Current.switchCnt ) return Error(CASE_ERR,"");

  if ( NeedConst( &l , "CASE") ) return 1;

  Current.switchFlag = (l == Current.switchValue);

  Current.switchCaseMatch |= Current.switchFlag;

  // printf("case: %d %d\n",Current.switchFlag,Current.switchCaseMatch);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0xfae6(%rip), %rax      # 0x185f8
cmpl $0x0, 0x184(%rax)
jne 0x8b31
movl $0x22, %edi
leaq 0x8536(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8ba4
leaq -0xc(%rbp), %rdi
leaq 0x87a5(%rip), %rsi      # 0x112e1
callq 0xc9f0
cmpl $0x0, %eax
je 0x8b4f
movl $0x1, -0x4(%rbp)
jmp 0x8ba4
movslq -0xc(%rbp), %rax
leaq 0xfa9e(%rip), %rcx      # 0x185f8
cmpq 0x190(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0xfa88(%rip), %rax      # 0x185f8
movl %ecx, 0x188(%rax)
leaq 0xfa7b(%rip), %rax      # 0x185f8
movl 0x188(%rax), %ecx
leaq 0xfa6e(%rip), %rax      # 0x185f8
orl 0x18c(%rax), %ecx
leaq 0xfa61(%rip), %rax      # 0x185f8
movl %ecx, 0x18c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_ends
int p_ends(int d)
{
  if ( !Current.switchCnt ) return Error(ENDS_ERR,"");

  Current.switchFlag = 1;
  Current.switchCnt = 0;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0xf9c6(%rip), %rax      # 0x185f8
cmpl $0x0, 0x184(%rax)
jne 0x8c51
movl $0x23, %edi
leaq 0x8416(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x8c7a
leaq 0xf9a0(%rip), %rax      # 0x185f8
movl $0x1, 0x188(%rax)
leaq 0xf98f(%rip), %rax      # 0x185f8
movl $0x0, 0x184(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)