LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_align
int p_align(int d)
{
  int32_t l1,l;
  if ( !(l = d) ){
    l = 2;
    KillSpace();
    if ( atom ){
      if ( NeedConst( &l,"ALIGN") ) return 1;
    }
  }
  l1 = l - ((int32_t)Global.pc) % l;
  if ( l != l1 ) writeSameBytes( 0, l1);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0x8ce2
movl $0x2, -0x10(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x18265(%rip), %rax     # 0x20f20
cmpl $0x0, (%rax)
je 0x8ce0
leaq -0x10(%rbp), %rdi
leaq 0x861b(%rip), %rsi      # 0x112e6
callq 0xc9f0
cmpl $0x0, %eax
je 0x8cde
movl $0x1, -0x4(%rbp)
jmp 0x8d16
jmp 0x8ce0
jmp 0x8ce2
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq 0xf6b1(%rip), %rax      # 0x183a0
movl (%rax), %eax
cltd
idivl -0x10(%rbp)
movl -0x14(%rbp), %eax
subl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x8d0f
movl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x3500
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_rept
int p_rept(int d)
{
  int32_t l;

  if ( Current.rept ) return Error(REPT1_ERR,"");

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

  if ( l <= 0 ) return Error(REPT2_ERR,"");

  Current.reptValue = l;
  Current.reptStart = Current.SrcPtr;
  Current.reptLine = Current.Line;
  Current.rept++;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0xf5e6(%rip), %rax      # 0x185f8
cmpl $0x0, 0x1a8(%rax)
je 0x9034
movl $0x24, %edi
leaq 0x8036(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x90d9
leaq -0xc(%rbp), %rdi
leaq 0x82e8(%rip), %rsi      # 0x11327
callq 0xc9f0
cmpl $0x0, %eax
je 0x9055
movl $0x1, -0x4(%rbp)
jmp 0x90d9
cmpl $0x0, -0xc(%rbp)
jg 0x9071
movl $0x25, %edi
leaq 0x7ff6(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x90d9
movslq -0xc(%rbp), %rcx
leaq 0xf57c(%rip), %rax      # 0x185f8
movq %rcx, 0x1b0(%rax)
leaq 0xf56e(%rip), %rax      # 0x185f8
movq 0x198(%rax), %rcx
leaq 0xf560(%rip), %rax      # 0x185f8
movq %rcx, 0x1a0(%rax)
leaq 0xf552(%rip), %rax      # 0x185f8
movl (%rax), %ecx
leaq 0xf549(%rip), %rax      # 0x185f8
movl %ecx, 0x1b8(%rax)
leaq 0xf53c(%rip), %rax      # 0x185f8
movl 0x1a8(%rax), %ecx
addl $0x1, %ecx
leaq 0xf52c(%rip), %rax      # 0x185f8
movl %ecx, 0x1a8(%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_endr
int p_endr(int d)
{
  if ( ! Current.rept ) return Error(REPT2_ERR,"");

  if ( --Current.reptValue ){
    Current.SrcPtr = Current.reptStart;
    Current.Line = Current.reptLine;
  } else {
    Current.rept--;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0xf4f6(%rip), %rax      # 0x185f8
cmpl $0x0, 0x1a8(%rax)
jne 0x9121
movl $0x25, %edi
leaq 0x7f46(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x919f
leaq 0xf4d0(%rip), %rax      # 0x185f8
movq 0x1b0(%rax), %rax
addq $-0x1, %rax
leaq 0xf4be(%rip), %rcx      # 0x185f8
movq %rax, 0x1b0(%rcx)
cmpq $0x0, %rax
je 0x917b
leaq 0xf4aa(%rip), %rax      # 0x185f8
movq 0x1a0(%rax), %rcx
leaq 0xf49c(%rip), %rax      # 0x185f8
movq %rcx, 0x198(%rax)
leaq 0xf48e(%rip), %rax      # 0x185f8
movl 0x1b8(%rax), %ecx
leaq 0xf481(%rip), %rax      # 0x185f8
movl %ecx, (%rax)
jmp 0x9198
leaq 0xf476(%rip), %rax      # 0x185f8
movl 0x1a8(%rax), %ecx
addl $-0x1, %ecx
leaq 0xf466(%rip), %rax      # 0x185f8
movl %ecx, 0x1a8(%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_ibytes
int p_ibytes(int d)
{
  int32_t offset = 0;

  if ( GetFileName() ) return 1;

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

  if ( Global.genesis ){
    long len;

    if ( LoadFile(code.Ptr, (long)offset, MAX_CODE_SIZE-code.Size, filename, &len ) ) return 1;

    code.Ptr += len;
    Global.pc += len;
    code.Size += len;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, %al
callq 0x5bf0
cmpl $0x0, %eax
je 0x91da
movl $0x1, -0x4(%rbp)
jmp 0x92b0
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0x920c
leaq -0xc(%rbp), %rdi
leaq 0x80b3(%rip), %rsi      # 0x112a7
callq 0xc9f0
cmpl $0x0, %eax
je 0x920a
movl $0x1, -0x4(%rbp)
jmp 0x92b0
jmp 0x920c
leaq 0xf18d(%rip), %rax      # 0x183a0
cmpl $0x0, 0x14(%rax)
je 0x92a9
leaq 0xf39c(%rip), %rax      # 0x185c0
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rsi
movl $0x200000, %edx         # imm = 0x200000
leaq 0xf388(%rip), %rax      # 0x185c0
subq 0x8(%rax), %rdx
leaq 0x1789d(%rip), %rcx     # 0x20ae0
leaq -0x18(%rbp), %r8
callq 0x3d30
cmpl $0x0, %eax
je 0x925a
movl $0x1, -0x4(%rbp)
jmp 0x92b0
movq -0x18(%rbp), %rcx
leaq 0xf35b(%rip), %rax      # 0x185c0
addq 0x10(%rax), %rcx
leaq 0xf350(%rip), %rax      # 0x185c0
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
leaq 0xf121(%rip), %rax      # 0x183a0
movl (%rax), %eax
addq %rcx, %rax
movl %eax, %ecx
leaq 0xf113(%rip), %rax      # 0x183a0
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
leaq 0xf326(%rip), %rax      # 0x185c0
addq 0x8(%rax), %rcx
leaq 0xf31b(%rip), %rax      # 0x185c0
movq %rcx, 0x8(%rax)
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_list
int p_list(int d)
{
  int32_t l;
  if ( NeedConst( &l , "LIST" ) ) return 1;

  if ( l <= 0 ) l = 0;
  if ( l > 3 ) l = 3;
  verbose = l;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
leaq 0x8056(%rip), %rsi      # 0x1132c
callq 0xc9f0
cmpl $0x0, %eax
je 0x92e9
movl $0x1, -0x4(%rbp)
jmp 0x9316
cmpl $0x0, -0xc(%rbp)
jg 0x92f6
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jle 0x9303
movl $0x3, -0xc(%rbp)
movl -0xc(%rbp), %ecx
leaq 0xf05f(%rip), %rax      # 0x1836c
movl %ecx, (%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_global
int p_global(int d)
{
  label_t label;
  label_t *plabel;
  int32_t l;

  do{

    if ( GetLabel( &label ) ) return 1;

    if ( (plabel = FindLabel( &label, &l)) == NULL ){
      int solved;

      label.type = GLOBAL|UNSOLVED;
      label.value = Global.pc;
      DefineLabel( &label, &solved);
    } else {
      if ( plabel->type & LOCAL ) return Error(SYNTAX_ERR,"");

      plabel->type |= GLOBAL;
    }

  }while (TestAtom(','));

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5de0
cmpl $0x0, %eax
je 0x9348
movl $0x1, -0x4(%rbp)
jmp 0x93d0
leaq -0x68(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x6f20
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
jne 0x9382
movl $0x88, -0x64(%rbp)
leaq 0xf033(%rip), %rax      # 0x183a0
movl (%rax), %eax
movq %rax, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6810
jmp 0x93b4
movq -0x70(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x93a7
movl $0x12, %edi
leaq 0x7cc0(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x93d0
movq -0x70(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x4(%rax)
jmp 0x93b6
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0x932e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_mode
int p_mode(int modus)
{
  sourceMode = modus;
  if ( modus == JAGUAR_GPU ){
    jaguar_mode = 0;
  } else  if ( modus == JAGUAR_DSP ){
    jaguar_mode = 1;
  } else {
    jaguar_mode = -1;
  }
  //  printf("Switching to mode %d\n",modus);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
leaq 0xf1ef(%rip), %rax      # 0x185e0
movl %ecx, (%rax)
cmpl $0x2, -0x4(%rbp)
jne 0x9408
leaq 0xf1e4(%rip), %rax      # 0x185e4
movl $0x0, (%rax)
jmp 0x942c
cmpl $0x3, -0x4(%rbp)
jne 0x941d
leaq 0xf1cf(%rip), %rax      # 0x185e4
movl $0x1, (%rax)
jmp 0x942a
leaq 0xf1c0(%rip), %rax      # 0x185e4
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x942c
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/pseudo.c
// Function: p_regtop
int p_regtop(int dummy)
{
  int32_t l;
  if ( sourceMode == LYNX ) {
    return Error(SYNTAX_ERR,"REGTOP only in RISC modes");
  }
  if ( NeedConst( &l, "REGTOP") ) return 1;

  if ( (l < 0 || l > 31) ) Error(REG_ERR,"");

  risc[jaguar_mode].regAllocStart = l;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0xe70e(%rip), %rax      # 0x185e0
cmpl $0x1, (%rax)
jne 0x9eed
movl $0x12, %edi
leaq 0x746b(%rip), %rsi      # 0x1134e
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x9f53
leaq -0xc(%rbp), %rdi
leaq 0x7470(%rip), %rsi      # 0x11368
callq 0xc9f0
cmpl $0x0, %eax
je 0x9f0b
movl $0x1, -0x4(%rbp)
jmp 0x9f53
cmpl $0x0, -0xc(%rbp)
jl 0x9f17
cmpl $0x1f, -0xc(%rbp)
jle 0x9f28
movl $0x2c, %edi
leaq 0x713a(%rip), %rsi      # 0x1105d
callq 0xd130
movl -0xc(%rbp), %ecx
leaq 0xe6b2(%rip), %rax      # 0x185e4
movslq (%rax), %rdx
leaq 0xd1c4(%rip), %rax      # 0x17100
imulq $0x808, %rdx, %rdx      # imm = 0x808
addq %rdx, %rax
movl %ecx, 0x800(%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: CheckPseudo
int CheckPseudo(char *s)
{
  int (*fun)(int );
  int para;

  if ( SearchOpcode2(pseudo, s, &fun, &para) < 0 )
    return -1;

  if ( Current.Macro.Define ){
    if ( (fun == p_macro) || (fun == p_endm) ) return fun(para);
    killLine();
    return 0;
  }

  if ( !Current.ifFlag ){
    if ( ((fun == p_if) || (fun == p_ifdef) ||
          (fun == p_ifundef) || (fun == p_ifvar)) ||
         ((fun == p_else) || (fun == p_endif)) )
    {
      return fun(para);
    }
    killLine();
    return 0;
  }

  if ( !Current.switchFlag ){
    if ( (fun == p_switch) || (fun == p_case) ||
         (fun == p_default) || (fun == p_ends) )
    {
      return fun(para);
    }
    killLine();
    return 0;
  }

  return fun(para);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xafe9(%rip), %rdi      # 0x15000
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
callq 0x77b0
cmpl $0x0, %eax
jge 0xa035
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa164
leaq 0xe5bc(%rip), %rax      # 0x185f8
cmpl $0x0, 0xc(%rax)
je 0xa07e
leaq -0x2549(%rip), %rax     # 0x7b00
cmpq %rax, -0x18(%rbp)
je 0xa05c
leaq -0x2506(%rip), %rax     # 0x7b50
cmpq %rax, -0x18(%rbp)
jne 0xa06d
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xa164
callq 0x5bd0
movl $0x0, -0x4(%rbp)
jmp 0xa164
leaq 0xe573(%rip), %rax      # 0x185f8
cmpl $0x0, 0xf8(%rax)
jne 0xa0f8
leaq -0x1ba5(%rip), %rax     # 0x84f0
cmpq %rax, -0x18(%rbp)
je 0xa0dc
leaq -0x1a82(%rip), %rax     # 0x8620
cmpq %rax, -0x18(%rbp)
je 0xa0dc
leaq -0x196f(%rip), %rax     # 0x8740
cmpq %rax, -0x18(%rbp)
je 0xa0dc
leaq -0x185c(%rip), %rax     # 0x8860
cmpq %rax, -0x18(%rbp)
je 0xa0dc
leaq -0x1759(%rip), %rax     # 0x8970
cmpq %rax, -0x18(%rbp)
je 0xa0dc
leaq -0x1726(%rip), %rax     # 0x89b0
cmpq %rax, -0x18(%rbp)
jne 0xa0ea
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xa164
callq 0x5bd0
movl $0x0, -0x4(%rbp)
jmp 0xa164
leaq 0xe4f9(%rip), %rax      # 0x185f8
cmpl $0x0, 0x188(%rax)
jne 0xa158
leaq -0x16bf(%rip), %rax     # 0x8a50
cmpq %rax, -0x18(%rbp)
je 0xa13c
leaq -0x161c(%rip), %rax     # 0x8b00
cmpq %rax, -0x18(%rbp)
je 0xa13c
leaq -0x1579(%rip), %rax     # 0x8bb0
cmpq %rax, -0x18(%rbp)
je 0xa13c
leaq -0x1516(%rip), %rax     # 0x8c20
cmpq %rax, -0x18(%rbp)
jne 0xa14a
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xa164
callq 0x5bd0
movl $0x0, -0x4(%rbp)
jmp 0xa164
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/mnemonics.c
// Function: ope
int ope(int op)
{
  int32_t l;
  int32_t dst;
  int err_l;
  int err_dst;

  err_l = Expression(&l);

  if ( err_l == EXPR_ERR) return 1;

  if ( l < 0 || l > 255 ) return Error(BYTE_ERR,"");

  if ( !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  err_dst = Expression(&dst);
  if ( err_dst == EXPR_OK ){
    int dist = dst - Global.pc - 3;
    if ( dist > 127 || dist < -128 )return Error(DISTANCE_ERR,"");
    writeConstByte(op);
    writeByte((char)l);
    writeConstByte((char)dist);
  } else {
    saveCurrentLine();
    writeConstByte(op);
    writeByte((char)l);
    writeConstByte(0);
  }

  CYCLES += 5;

  if ( err_l == EXPR_UNSOLVED && err_dst != EXPR_UNSOLVED ) saveCurrentLine();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xc920
movl %eax, -0x14(%rbp)
cmpl $0x11, -0x14(%rbp)
jne 0xa859
movl $0x1, -0x4(%rbp)
jmp 0xa961
cmpl $0x0, -0xc(%rbp)
jl 0xa868
cmpl $0xff, -0xc(%rbp)
jle 0xa881
movl $0x1a, %edi
leaq 0x67e9(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xa961
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xa8a9
movl $0x12, %edi
leaq 0x67c1(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xa961
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xa912
movl -0x10(%rbp), %eax
leaq 0xdadb(%rip), %rcx      # 0x183a0
subl (%rcx), %eax
subl $0x3, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x7f, -0x1c(%rbp)
jg 0xa8d9
cmpl $-0x80, -0x1c(%rbp)
jge 0xa8ef
movl $0x16, %edi
leaq 0x6778(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xa961
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0xc(%rbp), %eax
movsbl %al, %edi
callq 0x3470
movl -0x1c(%rbp), %eax
movsbl %al, %edi
callq 0x3340
jmp 0xa936
movb $0x0, %al
callq 0xcfe0
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0xc(%rbp), %eax
movsbl %al, %edi
callq 0x3470
xorl %edi, %edi
callq 0x3340
leaq 0xde8b(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x5, %ecx
movl %ecx, (%rax)
cmpl $0x2, -0x14(%rbp)
jne 0xa95a
cmpl $0x2, -0x18(%rbp)
je 0xa95a
movb $0x0, %al
callq 0xcfe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/mnemonics.c
// Function: op1
int op1(int op)
{
  int32_t l;
  int err;

  if ( (err = Expression(&l)) == EXPR_ERR) return 1;

  if ( err == EXPR_OK ){
    int dist = l - Global.pc - 2;
    if ( dist > 127 || dist < -128 )return Error(DISTANCE_ERR,"");
    writeConstByte(op);
    writeConstByte((char)dist);
  } else {
    saveCurrentLine();
    writeConstByte(op);
    writeConstByte(0);
  }
  CYCLES += 2;
  if ( (l & ~255) != ( Global.pc & ~255) ) ++CYCLES;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xc920
movl %eax, -0x10(%rbp)
cmpl $0x11, %eax
jne 0xa998
movl $0x1, -0x4(%rbp)
jmp 0xaa47
cmpl $0x0, -0x10(%rbp)
jne 0xa9ea
movl -0xc(%rbp), %eax
leaq 0xd9f8(%rip), %rcx      # 0x183a0
subl (%rcx), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x7f, -0x14(%rbp)
jg 0xa9bc
cmpl $-0x80, -0x14(%rbp)
jge 0xa9d2
movl $0x16, %edi
leaq 0x6695(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xaa47
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0x14(%rbp), %eax
movsbl %al, %edi
callq 0x3340
jmp 0xaa03
movb $0x0, %al
callq 0xcfe0
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
xorl %edi, %edi
callq 0x3340
leaq 0xddbe(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
leaq 0xd97d(%rip), %rcx      # 0x183a0
movl (%rcx), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
cmpl %ecx, %eax
je 0xaa40
leaq 0xdd92(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/mnemonics.c
// Function: opd
int opd(int op)
{
  int err;
  int32_t l;

  if ( !TestAtom('#') ) return Error(SYNTAX_ERR,"");

  if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
  if ( l < -128 || l > 255 ) return Error(BYTE_ERR,"");
  writeConstByte(op);
  writeByte((char)l);
  if ( err == EXPR_UNSOLVED ) saveCurrentLine();
  CYCLES += 7;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x23, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xacd0
movl $0x12, %edi
leaq 0x6397(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xad4a
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0xacea
movl $0x1, -0x4(%rbp)
jmp 0xad4a
cmpl $-0x80, -0x10(%rbp)
jl 0xacf9
cmpl $0xff, -0x10(%rbp)
jle 0xad0f
movl $0x1a, %edi
leaq 0x6358(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xad4a
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movsbl %al, %edi
callq 0x3470
cmpl $0x2, -0xc(%rbp)
jne 0xad32
movb $0x0, %al
callq 0xcfe0
leaq 0xda8f(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x7, %ecx
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/mnemonics.c
// Function: op0
int op0(int op)
{
  writeConstByte( (char) op );
  CYCLES += 2;
  if ( op == 0x48 || op == 0xda || op == 0x5a || op == 0x08 ) ++CYCLES;
  if ( op == 0x68 || op == 0xfa || op == 0x7a || op == 0x28 ) CYCLES += 2;
  if ( op == 0x40 || op == 0x66 ) CYCLES += 6;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movsbl %al, %edi
callq 0x3340
leaq 0xda4b(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
cmpl $0x48, -0x4(%rbp)
je 0xada2
cmpl $0xda, -0x4(%rbp)
je 0xada2
cmpl $0x5a, -0x4(%rbp)
je 0xada2
cmpl $0x8, -0x4(%rbp)
jne 0xadb3
leaq 0xda1f(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0x68, -0x4(%rbp)
je 0xadce
cmpl $0xfa, -0x4(%rbp)
je 0xadce
cmpl $0x7a, -0x4(%rbp)
je 0xadce
cmpl $0x28, -0x4(%rbp)
jne 0xaddf
leaq 0xd9f3(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
cmpl $0x40, -0x4(%rbp)
je 0xadeb
cmpl $0x66, -0x4(%rbp)
jne 0xadfc
leaq 0xd9d6(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x6, %ecx
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/mnemonics.c
// Function: op2
int op2(int op)
{
  int32_t l;
  int err;

  if ( (err = Expression(&l)) == EXPR_ERR) return 1;
  if ( l < 0 || l > 65535 ) return Error(WORD_ERR,"");

  writeConstByte(op);
  writeWordLittle((short) l);

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();

  CYCLES += 6;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xc920
movl %eax, -0x10(%rbp)
cmpl $0x11, %eax
jne 0xb265
movl $0x1, -0x4(%rbp)
jmp 0xb2c5
cmpl $0x0, -0xc(%rbp)
jl 0xb274
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
jle 0xb28a
movl $0x1b, %edi
leaq 0x5ddd(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xb2c5
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0xc(%rbp), %eax
movswl %ax, %edi
callq 0x3670
cmpl $0x2, -0x10(%rbp)
jne 0xb2ad
movb $0x0, %al
callq 0xcfe0
leaq 0xd514(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x6, %ecx
movl %ecx, (%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/mnemonics.c
// Function: opb
int opb(int op)
{
  int err;
  int32_t l;

  if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
  if ( l < 0 || l > 255 ) return Error(BYTE_ERR,"");

  writeConstByte(op);
  writeByte((char)l);

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0xb2f5
movl $0x1, -0x4(%rbp)
jmp 0xb344
cmpl $0x0, -0x10(%rbp)
jl 0xb304
cmpl $0xff, -0x10(%rbp)
jle 0xb31a
movl $0x1a, %edi
leaq 0x5d4d(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xb344
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movsbl %al, %edi
callq 0x3470
cmpl $0x2, -0xc(%rbp)
jne 0xb33d
movb $0x0, %al
callq 0xcfe0
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/mnemonics.c
// Function: op6
int op6(int op)
{
  int err;
  int32_t l;
  int brace;

  KillSpace();
  brace = atom == '(';
  if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
  if ( brace && last_atom == ')' ){
    Warning("STX (n) translates to STX n\n");
  }

  if ( l < 0 || l > 65535 ) return Error(WORD_ERR,"");

  if ( TestAtom(',') ) {
    if ( l > 255 || err == EXPR_UNSOLVED || Current.pass2 ) return Error(BYTE_ERR,"");

    if ( !TestAtomOR('y','Y') ) Error(SYNTAX_ERR,"");
    CYCLES += 4;
    writeConstByte(op | 0x10);
    writeByte((char)l);
  } else {
    if ( l > 255 || err == EXPR_UNSOLVED || Current.pass2 ){
      CYCLES += 4;
      writeConstByte(op | 0x08 );
      writeWordLittle((short)l);
    } else {
      CYCLES += 3;
      writeConstByte(op);
      writeByte((char)l);
    }
  }

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x15bb7(%rip), %rax     # 0x20f20
cmpl $0x28, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0xb394
movl $0x1, -0x4(%rbp)
jmp 0xb4fe
cmpl $0x0, -0x14(%rbp)
je 0xb3b2
leaq 0x15b83(%rip), %rax     # 0x20f24
cmpl $0x29, (%rax)
jne 0xb3b2
leaq 0x60f9(%rip), %rdi      # 0x114a6
callq 0xd910
cmpl $0x0, -0x10(%rbp)
jl 0xb3c1
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jle 0xb3da
movl $0x1b, %edi
leaq 0x5c90(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xb4fe
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0xb476
cmpl $0xff, -0x10(%rbp)
jg 0xb40c
cmpl $0x2, -0xc(%rbp)
je 0xb40c
leaq 0xd1f5(%rip), %rax      # 0x185f8
cmpl $0x0, 0xe4(%rax)
je 0xb425
movl $0x1a, %edi
leaq 0x5c45(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xb4fe
movl $0x79, %edi
movl $0x59, %esi
callq 0x5af0
cmpl $0x0, %eax
jne 0xb44a
movl $0x12, %edi
leaq 0x5c18(%rip), %rsi      # 0x1105d
callq 0xd130
leaq 0xd377(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
orl $0x10, %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movsbl %al, %edi
callq 0x3470
jmp 0xb4ea
cmpl $0xff, -0x10(%rbp)
jg 0xb495
cmpl $0x2, -0xc(%rbp)
je 0xb495
leaq 0xd16c(%rip), %rax      # 0x185f8
cmpl $0x0, 0xe4(%rax)
je 0xb4c1
leaq 0xd32c(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
orl $0x8, %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movswl %ax, %edi
callq 0x3670
jmp 0xb4e8
leaq 0xd300(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x3, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movsbl %al, %edi
callq 0x3470
jmp 0xb4ea
cmpl $0x2, -0xc(%rbp)
jne 0xb4f7
movb $0x0, %al
callq 0xcfe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/mnemonics.c
// Function: op7
int op7(int op)
{
  int err;
  int32_t l;
  int brace;

  KillSpace();
  brace = atom == '(';

  if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
  if ( brace && last_atom == ')' ){
    Warning("STY (n) translates to STY n\n");
  }

  if ( l < 0 || l > 65535 ) return Error(WORD_ERR,"");

  if ( TestAtom(',') ) {

    if ( l > 255 || err == EXPR_UNSOLVED || Current.pass2 ) return Error(BYTE_ERR,"");

    if ( !TestAtomOR('x','X') ) Error(SYNTAX_ERR,"");
    CYCLES += 4;
    writeConstByte(op | 0x10);
    writeByte((char)l);
  } else {
    if ( l > 255 || err == EXPR_UNSOLVED || Current.pass2 ){
      CYCLES += 4;
      writeConstByte(op | 0x08 );
      writeWordLittle((short)l);
    } else {
      CYCLES += 3;
      writeConstByte(op);
      writeByte((char)l);
    }
  }
  if ( err == EXPR_UNSOLVED ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movb $0x0, %al
callq 0x5ad0
leaq 0x159f7(%rip), %rax     # 0x20f20
cmpl $0x28, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0xb554
movl $0x1, -0x4(%rbp)
jmp 0xb6be
cmpl $0x0, -0x14(%rbp)
je 0xb572
leaq 0x159c3(%rip), %rax     # 0x20f24
cmpl $0x29, (%rax)
jne 0xb572
leaq 0x5f56(%rip), %rdi      # 0x114c3
callq 0xd910
cmpl $0x0, -0x10(%rbp)
jl 0xb581
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jle 0xb59a
movl $0x1b, %edi
leaq 0x5ad0(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xb6be
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0xb636
cmpl $0xff, -0x10(%rbp)
jg 0xb5cc
cmpl $0x2, -0xc(%rbp)
je 0xb5cc
leaq 0xd035(%rip), %rax      # 0x185f8
cmpl $0x0, 0xe4(%rax)
je 0xb5e5
movl $0x1a, %edi
leaq 0x5a85(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xb6be
movl $0x78, %edi
movl $0x58, %esi
callq 0x5af0
cmpl $0x0, %eax
jne 0xb60a
movl $0x12, %edi
leaq 0x5a58(%rip), %rsi      # 0x1105d
callq 0xd130
leaq 0xd1b7(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
orl $0x10, %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movsbl %al, %edi
callq 0x3470
jmp 0xb6aa
cmpl $0xff, -0x10(%rbp)
jg 0xb655
cmpl $0x2, -0xc(%rbp)
je 0xb655
leaq 0xcfac(%rip), %rax      # 0x185f8
cmpl $0x0, 0xe4(%rax)
je 0xb681
leaq 0xd16c(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
orl $0x8, %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movswl %ax, %edi
callq 0x3670
jmp 0xb6a8
leaq 0xd140(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x3, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movsbl %al, %edi
callq 0x3470
jmp 0xb6aa
cmpl $0x2, -0xc(%rbp)
jne 0xb6b7
movb $0x0, %al
callq 0xcfe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/mnemonics.c
// Function: op4
int op4(int op)
{
  int err;
  int32_t l;

  if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;

  if ( l < 0 || l > 65535 ) return Error(WORD_ERR,"");

  if ( l > 255 || err == EXPR_UNSOLVED || Current.pass2 ){
    CYCLES += 6;
    writeConstByte(op | 0x08);
    writeWordLittle((short)l);
  } else {
    CYCLES += 5;
    writeConstByte(op);
    writeByte((char)l);
  }
  if ( err == EXPR_UNSOLVED ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0xb8e8
movl $0x1, -0x4(%rbp)
jmp 0xb996
cmpl $0x0, -0x10(%rbp)
jl 0xb8f7
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jle 0xb910
movl $0x1b, %edi
leaq 0x575a(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xb996
cmpl $0xff, -0x10(%rbp)
jg 0xb92f
cmpl $0x2, -0xc(%rbp)
je 0xb92f
leaq 0xccd2(%rip), %rax      # 0x185f8
cmpl $0x0, 0xe4(%rax)
je 0xb95b
leaq 0xce92(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x6, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
orl $0x8, %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movswl %ax, %edi
callq 0x3670
jmp 0xb982
leaq 0xce66(%rip), %rax      # 0x187c8
movq (%rax), %rax
movl (%rax), %ecx
addl $0x5, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x3340
movl -0x10(%rbp), %eax
movsbl %al, %edi
callq 0x3470
cmpl $0x2, -0xc(%rbp)
jne 0xb98f
movb $0x0, %al
callq 0xcfe0
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/mnemonics.c
// Function: CheckMnemonic
int CheckMnemonic(char *s)
{
  if ( Current.ifFlag && Current.switchFlag){
    if ( sourceMode == LYNX ){
      if (SearchOpcode(OpCodes,s) < 0 ) return -1;
    } else {
      if (SearchOpcode(JaguarOpcodes,s) < 0 ) return -1;
    }

    if ( GetComment() ){
      Error(GARBAGE_ERR, srcLinePtr);
      return 1;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xcc15(%rip), %rax      # 0x185f8
cmpl $0x0, 0xf8(%rax)
je 0xba75
leaq 0xcc01(%rip), %rax      # 0x185f8
cmpl $0x0, 0x188(%rax)
je 0xba75
leaq 0xcbd9(%rip), %rax      # 0x185e0
cmpl $0x1, (%rax)
jne 0xba2c
movq -0x10(%rbp), %rsi
leaq 0x9f69(%rip), %rdi      # 0x15980
callq 0x7730
cmpl $0x0, %eax
jge 0xba2a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xba7c
jmp 0xba4c
movq -0x10(%rbp), %rsi
leaq 0xabe9(%rip), %rdi      # 0x16620
callq 0x7730
cmpl $0x0, %eax
jge 0xba4a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xba7c
jmp 0xba4c
callq 0x6560
cmpl $0x0, %eax
je 0xba73
leaq 0x154b3(%rip), %rax     # 0x20f10
movq (%rax), %rsi
movl $0x18, %edi
callq 0xd130
movl $0x1, -0x4(%rbp)
jmp 0xba7c
jmp 0xba75
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/expression.c
// Function: getdec32
int getdec32(int32_t *value)
{
  int64_t dec = 0;
  int i = 0;

  while ( isdigit(atom) ){
    dec *= 10;
    dec += (int64_t)atom - '0';
    GetAtom();
    ++i;
  }

  if ( !i ){
    Error(EXPR_ERR,"");
    return EXPR_ERR;
  }

  if ( (dec < 0) || (i > 20) ){
    *value = 0;
    Error(TOOBIG_ERR,"");
    return EXPR_ERROR;
  }

  *value = (int32_t)dec;
  return EXPR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x31d0
movq (%rax), %rax
leaq 0x15466(%rip), %rcx     # 0x20f20
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xbafa
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x15445(%rip), %rax     # 0x20f20
movslq (%rax), %rax
subq $0x30, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x59e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbaab
cmpl $0x0, -0x1c(%rbp)
jne 0xbb1a
movl $0x11, %edi
leaq 0x5551(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x11, -0x4(%rbp)
jmp 0xbb5e
cmpq $0x0, -0x18(%rbp)
jl 0xbb27
cmpl $0x14, -0x1c(%rbp)
jle 0xbb4b
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x10, %edi
leaq 0x5520(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x1, -0x4(%rbp)
jmp 0xbb5e
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/expression.c
// Function: getdec
int getdec(int64_t *value)
{
  int64_t dec = 0;
  int i = 0;

  while ( isdigit(atom) ){
    dec *= 10;
    dec += (int64_t)atom - '0';
    GetAtom();
    ++i;
  }

  if ( !i ){
    Error(EXPR_ERR,"");
    return EXPR_ERR;
  }

  if ( (dec < 0) || (i > 20) ){
    *value = 0;
    Error(TOOBIG_ERR,"");
    return EXPR_ERROR;
  }

  *value = dec;
  return EXPR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x31d0
movq (%rax), %rax
leaq 0x15386(%rip), %rcx     # 0x20f20
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xbbda
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x15365(%rip), %rax     # 0x20f20
movslq (%rax), %rax
subq $0x30, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x59e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbb8b
cmpl $0x0, -0x1c(%rbp)
jne 0xbbfa
movl $0x11, %edi
leaq 0x5471(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x11, -0x4(%rbp)
jmp 0xbc3e
cmpq $0x0, -0x18(%rbp)
jl 0xbc07
cmpl $0x14, -0x1c(%rbp)
jle 0xbc2c
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x10, %edi
leaq 0x543f(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x1, -0x4(%rbp)
jmp 0xbc3e
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/expression.c
// Function: gethex
int gethex(int64_t *value)
{
  int64_t hex = 0;
  int i = 0;

  while ( (atom >= '0' && atom <= '9') ||
	  (atom >= 'A' && atom <= 'F') ||
	  (atom >= 'a' && atom <= 'f') ){
    hex <<= 4;
    if ( atom > '9' )
      hex += ( (int64_t)atom & 0xdf ) - '0' - 7;
    else
      hex += (int64_t)atom - '0';

    GetAtom();
    ++i;
  }

  if ( !i ){
    Error(EXPR_ERR,"");
    return EXPR_ERR;
  }

  if ( (i > 16) ){
    *value = 0;
    Error(TOOBIG_ERR,"");
    return EXPR_ERROR;
  }
  *value = hex;
  return EXPR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x152ae(%rip), %rax     # 0x20f20
cmpl $0x30, (%rax)
jl 0xbc88
movb $0x1, %al
leaq 0x152a0(%rip), %rcx     # 0x20f20
cmpl $0x39, (%rcx)
movb %al, -0x1d(%rbp)
jle 0xbccc
leaq 0x15291(%rip), %rax     # 0x20f20
cmpl $0x41, (%rax)
jl 0xbca5
movb $0x1, %al
leaq 0x15283(%rip), %rcx     # 0x20f20
cmpl $0x46, (%rcx)
movb %al, -0x1d(%rbp)
jle 0xbccc
xorl %eax, %eax
leaq 0x15272(%rip), %rcx     # 0x20f20
cmpl $0x61, (%rcx)
movb %al, -0x1e(%rbp)
jl 0xbcc6
leaq 0x15263(%rip), %rax     # 0x20f20
cmpl $0x66, (%rax)
setle %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xbcd5
jmp 0xbd38
movq -0x18(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x18(%rbp)
leaq 0x15238(%rip), %rax     # 0x20f20
cmpl $0x39, (%rax)
jle 0xbd0f
leaq 0x1522c(%rip), %rax     # 0x20f20
movslq (%rax), %rax
andq $0xdf, %rax
subq $0x30, %rax
subq $0x7, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbd25
leaq 0x1520a(%rip), %rax     # 0x20f20
movslq (%rax), %rax
subq $0x30, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x59e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbc6b
cmpl $0x0, -0x1c(%rbp)
jne 0xbd58
movl $0x11, %edi
leaq 0x5313(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x11, -0x4(%rbp)
jmp 0xbd95
cmpl $0x10, -0x1c(%rbp)
jle 0xbd83
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x10, %edi
leaq 0x52e8(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x1, -0x4(%rbp)
jmp 0xbd95
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/expression.c
// Function: getbin
int getbin(int64_t *value)
{
  int64_t bin = 0;
  int i = 0;
  while ( atom == '1' || atom == '0' ){
    bin <<= 1;
    bin += (int64_t)atom - '0';
    GetAtom();
    ++i;
  }

  if ( !i ){
    Error(EXPR_ERR,"");
    return EXPR_ERR;
  }

  if ( i > 64 ){
    Error(TOOBIG_ERR,"");
    return EXPR_ERROR;
  }
  *value = bin;
  return EXPR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x1, %al
leaq 0x1515c(%rip), %rcx     # 0x20f20
cmpl $0x31, (%rcx)
movb %al, -0x1d(%rbp)
je 0xbddc
leaq 0x1514d(%rip), %rax     # 0x20f20
cmpl $0x30, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xbde5
jmp 0xbe16
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
leaq 0x15129(%rip), %rax     # 0x20f20
movslq (%rax), %rax
subq $0x30, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x59e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbdbb
cmpl $0x0, -0x1c(%rbp)
jne 0xbe36
movl $0x11, %edi
leaq 0x5235(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x11, -0x4(%rbp)
jmp 0xbe68
cmpl $0x40, -0x1c(%rbp)
jle 0xbe56
movl $0x10, %edi
leaq 0x5215(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x1, -0x4(%rbp)
jmp 0xbe68
movq -0x18(%rbp), %rcx
movq -0x10(%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/expression.c
// Function: getlabel
int getlabel(int64_t *value)
{
  int32_t lv = 0;
  int dummy;

  if ( GetLabel( &expr_label) ) return EXPR_ERROR;

  expr_label.type &= ~UNSURE;

  // printf("Type %02x\n",expr_label.type);

  if ( FindLabel( &expr_label, &lv ) ){
    if (expr_label.type & CODELABEL){
      ++Current.needsReloc;
//->      printf("Reloc: %s Line %4d %04x: %04x\n",file_list[Current.File].name,Current.Line,Global.pc,lv);
    }
    *value = (int64_t)lv;
    return EXPR_OK;
  }

  if ( expr_label.type & UNSOLVED ){
    unknownLabel = DefineLabel( &expr_label, &dummy);
  } else {
    expr_label.type |= UNSOLVED;
    unknownLabel = DefineLabel( &expr_label, &dummy);
  }

  *value = 0;
  ExprFailed = 1;
  return EXPR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x15e16(%rip), %rdi     # 0x21cb0
callq 0x5de0
cmpl $0x0, %eax
je 0xbeb0
movl $0x1, -0x4(%rbp)
jmp 0xbf8d
movl 0x15dfe(%rip), %eax     # 0x21cb4
andl $-0x21, %eax
movl %eax, 0x15df5(%rip)     # 0x21cb4
leaq 0x15dea(%rip), %rdi     # 0x21cb0
leaq -0x14(%rbp), %rsi
callq 0x6f20
cmpq $0x0, %rax
je 0xbf14
movl 0x15dd9(%rip), %eax     # 0x21cb4
andl $0x0, %eax
cmpl $0x0, %eax
je 0xbf00
leaq 0xc70e(%rip), %rax      # 0x185f8
movl 0x1bc(%rax), %ecx
addl $0x1, %ecx
leaq 0xc6fe(%rip), %rax      # 0x185f8
movl %ecx, 0x1bc(%rax)
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xbf8d
movl 0x15d9a(%rip), %eax     # 0x21cb4
andl $0x80, %eax
cmpl $0x0, %eax
je 0xbf43
leaq 0x15d85(%rip), %rdi     # 0x21cb0
leaq -0x18(%rbp), %rsi
callq 0x6810
movq %rax, %rcx
leaq 0x14da2(%rip), %rax     # 0x20ce0
movq %rcx, (%rax)
jmp 0xbf71
movl 0x15d6b(%rip), %eax     # 0x21cb4
orl $0x80, %eax
movl %eax, 0x15d60(%rip)     # 0x21cb4
leaq 0x15d55(%rip), %rdi     # 0x21cb0
leaq -0x18(%rbp), %rsi
callq 0x6810
movq %rax, %rcx
leaq 0x14d72(%rip), %rax     # 0x20ce0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x1, 0x15d8a(%rip)     # 0x21d10
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/expression.c
// Function: sum
int sum(int64_t *value)
{
  int err;
  int64_t a,b;

  err = product( &a );

  if ( err ) return err;

  KillSpace();

  while ( (atom == '+') ||
	  (atom == '-') ||
	  (atom == '^') ||
	  (atom == '|') ){

    char save = atom;

    need_ch();

    err = product( &b );

    if ( err ) return err;

    switch ( save ){
    case '+' : a += b; break;
    case '-' : a -= b; break;
    case '^' : a ^= b; break;
    case '|' : a |= b; break;
    }
  }

  *value = a;
  return EXPR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc4f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xc3b9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc4d8
movb $0x0, %al
callq 0x5ad0
movb $0x1, %al
leaq 0x14b57(%rip), %rcx     # 0x20f20
cmpl $0x2b, (%rcx)
movb %al, -0x2a(%rbp)
je 0xc403
movb $0x1, %al
leaq 0x14b46(%rip), %rcx     # 0x20f20
cmpl $0x2d, (%rcx)
movb %al, -0x2a(%rbp)
je 0xc403
movb $0x1, %al
leaq 0x14b35(%rip), %rcx     # 0x20f20
cmpl $0x5e, (%rcx)
movb %al, -0x2a(%rbp)
je 0xc403
leaq 0x14b26(%rip), %rax     # 0x20f20
cmpl $0x7c, (%rax)
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0xc40f
jmp 0xc4c6
leaq 0x14b0a(%rip), %rax     # 0x20f20
movl (%rax), %eax
movb %al, -0x29(%rbp)
callq 0x59e0
cmpl $0x0, %eax
jne 0xc442
movl $0x11, %edi
leaq 0x4c2c(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x11, -0x4(%rbp)
jmp 0xc4d8
leaq -0x28(%rbp), %rdi
callq 0xc4f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xc45c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc4d8
movsbl -0x29(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x2b, %eax
je 0xc488
jmp 0xc46a
movl -0x30(%rbp), %eax
subl $0x2d, %eax
je 0xc496
jmp 0xc474
movl -0x30(%rbp), %eax
subl $0x5e, %eax
je 0xc4a7
jmp 0xc47e
movl -0x30(%rbp), %eax
subl $0x7c, %eax
je 0xc4b5
jmp 0xc4c1
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xc4c1
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xc4c1
movq -0x28(%rbp), %rax
xorq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xc4c1
movq -0x28(%rbp), %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xc3c0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/expression.c
// Function: Expression
int Expression(int32_t * pvalue)
{
  int err;
  int64_t value;

  *pvalue = 0;

  err = Expression64(&value);

  if ( err != EXPR_OK ){
    return err;
  }

  if ( (value > 0xffffffffLL) || (value < (int64_t)INT32_MIN) ){
    return Error(TOOBIG_ERR, 0);
  }

  *pvalue = (int32_t)value;

  return EXPR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq -0x20(%rbp), %rdi
callq 0xc6e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xc950
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc98b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x20(%rbp)
jg 0xc965
cmpq $-0x80000000, -0x20(%rbp) # imm = 0x80000000
jge 0xc978
movl $0x10, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xc98b
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%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/expression.c
// Function: NeedConst
int NeedConst( int32_t * value, const char * op)
{
  int err;

  err = Expression(value);

  if ( err == EXPR_UNSOLVED ) {
    return Error(NEEDCONST_ERR,op);
  }

  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0xca25
movq -0x18(%rbp), %rsi
movl $0x13, %edi
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xca2b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/macro.c
// Function: DefineMacro
int DefineMacro(char *s)
{

  if ( recur ){
    ++recur;
    if ( recur > 2 ){
      Error(MACRONESTED_ERR,"");
      return 1;
    }
    return 0;
  }

  ++recur;

  macroName.len = (int)strlen(s);
  strcpy(macroName.name,s);
  macroName.line = Current.Line;
  macroName.file = Current.File;
  macroName.value = 0;//(long) Current.SrcPtr;
  macroName.macro = Current.SrcPtr;
  macroName.type = MACRO;
  Current.Macro.Define=1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x152cd(%rip)     # 0x21d20
je 0xca96
movl 0x152c5(%rip), %eax     # 0x21d20
addl $0x1, %eax
movl %eax, 0x152bc(%rip)     # 0x21d20
cmpl $0x2, 0x152b5(%rip)     # 0x21d20
jle 0xca8a
movl $0x19, %edi
leaq 0x45e4(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0x1, -0x4(%rbp)
jmp 0xcb22
movl $0x0, -0x4(%rbp)
jmp 0xcb22
movl 0x15284(%rip), %eax     # 0x21d20
addl $0x1, %eax
movl %eax, 0x1527b(%rip)     # 0x21d20
movq -0x10(%rbp), %rdi
callq 0x30a0
movl %eax, 0x15274(%rip)     # 0x21d28
movq -0x10(%rbp), %rsi
leaq 0x152a1(%rip), %rdi     # 0x21d60
callq 0x3060
leaq 0xbb2d(%rip), %rax      # 0x185f8
movl (%rax), %eax
movl %eax, 0x15265(%rip)     # 0x21d38
leaq 0xbb1e(%rip), %rax      # 0x185f8
movl 0x4(%rax), %eax
movl %eax, 0x15259(%rip)     # 0x21d3c
movq $0x0, 0x15242(%rip) # 0x21d30
leaq 0xbb03(%rip), %rax      # 0x185f8
movq 0x198(%rax), %rax
movq %rax, 0x15245(%rip)     # 0x21d48
movl $0x4, 0x1521f(%rip)     # 0x21d2c
leaq 0xbae4(%rip), %rax      # 0x185f8
movl $0x1, 0xc(%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/macro.c
// Function: EndDefineMacro
int EndDefineMacro(){

  int dummy;

  if ( --recur ){
    return 0;
  }
  Current.Macro.Define = 0;

  if ( ! DefineLabel(&macroName, &dummy) ){
    return 1;
  }
  if ( dummy ) return Error(SYNTAX_ERR,"");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x151e2(%rip), %eax     # 0x21d20
addl $-0x1, %eax
movl %eax, 0x151d9(%rip)     # 0x21d20
cmpl $0x0, %eax
je 0xcb55
movl $0x0, -0x4(%rbp)
jmp 0xcba5
leaq 0xba9c(%rip), %rax      # 0x185f8
movl $0x0, 0xc(%rax)
leaq 0x151be(%rip), %rdi     # 0x21d28
leaq -0x8(%rbp), %rsi
callq 0x6810
cmpq $0x0, %rax
jne 0xcb82
movl $0x1, -0x4(%rbp)
jmp 0xcba5
cmpl $0x0, -0x8(%rbp)
je 0xcb9e
movl $0x12, %edi
leaq 0x44c9(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xcba5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop