LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %eax, %eax
callq 0x4ff7
leaq 0x1403e(%rip), %rax     # 0x1cf30
movl (%rax), %r15d
leaq 0x4(%rsp), %rdi
callq 0x9d6c
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x9025
movl %eax, %ebp
cmpl $0x28, %r15d
jne 0x8f2e
leaq 0x14017(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x8f2e
leaq 0x4560(%rip), %rdi      # 0xd489
callq 0xa81b
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x8f46
leaq 0x4053(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
jmp 0x8f8a
movl $0x2c, %edi
callq 0x4fa8
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
setge %cl
cmpl $0x2, %ebp
sete %dl
orb %cl, %dl
leaq 0xb69e(%rip), %rcx      # 0x14608
cmpl $0x0, 0xe4(%rcx)
setne %cl
orb %dl, %cl
testl %eax, %eax
je 0x8f97
testb %cl, %cl
je 0x8fd5
leaq 0x400d(%rip), %rsi      # 0xcf92
movl $0x1a, %edi
callq 0xa1d8
movl %eax, %r14d
jmp 0x9025
leaq 0xb83a(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %edx
testb %cl, %cl
je 0x900b
addl $0x4, %edx
movl %edx, (%rax)
orb $0x8, %bl
movsbl %bl, %edi
callq 0x3355
movswl 0x4(%rsp), %edi
callq 0x355d
xorl %r14d, %r14d
cmpl $0x2, %ebp
jne 0x9025
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa118
jmp 0x9025
movl $0x79, %edi
movl $0x59, %esi
callq 0x504d
testl %eax, %eax
jne 0x8ff9
leaq 0x3fa3(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
leaq 0xb7d8(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
orb $0x10, %bl
jmp 0x9010
addl $0x3, %edx
movl %edx, (%rax)
movsbl %bl, %edi
callq 0x3355
movsbl 0x4(%rsp), %edi
callq 0x340b
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %eax, %eax
callq 0x4ff7
leaq 0x13ee6(%rip), %rax     # 0x1cf30
movl (%rax), %r15d
leaq 0x4(%rsp), %rdi
callq 0x9d6c
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x917d
movl %eax, %ebp
cmpl $0x28, %r15d
jne 0x9086
leaq 0x13ebf(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x9086
leaq 0x4425(%rip), %rdi      # 0xd4a6
callq 0xa81b
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x909e
leaq 0x3efb(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
jmp 0x90e2
movl $0x2c, %edi
callq 0x4fa8
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
setge %cl
cmpl $0x2, %ebp
sete %dl
orb %cl, %dl
leaq 0xb546(%rip), %rcx      # 0x14608
cmpl $0x0, 0xe4(%rcx)
setne %cl
orb %dl, %cl
testl %eax, %eax
je 0x90ef
testb %cl, %cl
je 0x912d
leaq 0x3eb5(%rip), %rsi      # 0xcf92
movl $0x1a, %edi
callq 0xa1d8
movl %eax, %r14d
jmp 0x917d
leaq 0xb6e2(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %edx
testb %cl, %cl
je 0x9163
addl $0x4, %edx
movl %edx, (%rax)
orb $0x8, %bl
movsbl %bl, %edi
callq 0x3355
movswl 0x4(%rsp), %edi
callq 0x355d
xorl %r14d, %r14d
cmpl $0x2, %ebp
jne 0x917d
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa118
jmp 0x917d
movl $0x78, %edi
movl $0x58, %esi
callq 0x504d
testl %eax, %eax
jne 0x9151
leaq 0x3e4b(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
leaq 0xb680(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
orb $0x10, %bl
jmp 0x9168
addl $0x3, %edx
movl %edx, (%rax)
movsbl %bl, %edi
callq 0x3355
movsbl 0x4(%rsp), %edi
callq 0x340b
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/mnemonics.c
// Function: op5
int op5(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("STZ (n) translates to STZ n\n");
  }

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

  if ( TestAtom(',') ) {

    if ( !TestAtomOR('x','X') ) Error(SYNTAX_ERR,"");

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
xorl %eax, %eax
callq 0x4ff7
leaq 0x13d8e(%rip), %rax     # 0x1cf30
movl (%rax), %r15d
leaq 0x4(%rsp), %rdi
callq 0x9d6c
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x9322
movl %eax, %ebx
cmpl $0x28, %r15d
jne 0x91de
leaq 0x13d67(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x91de
leaq 0x4293(%rip), %rdi      # 0xd46c
callq 0xa81b
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x9201
leaq 0x3da3(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
callq 0xa1d8
movl %eax, %r14d
jmp 0x9322
movl $0x2c, %edi
callq 0x4fa8
testl %eax, %eax
je 0x927f
movl $0x78, %edi
movl $0x58, %esi
callq 0x504d
testl %eax, %eax
jne 0x9233
leaq 0x3d69(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
cmpl $0x2, %ebx
je 0x92c4
cmpl $0xff, 0x4(%rsp)
jg 0x92c4
leaq 0xb3bb(%rip), %rax      # 0x14608
cmpl $0x0, 0xe4(%rax)
jne 0x92c4
orb $0x70, %bpl
movsbl %bpl, %edi
callq 0x3355
movsbl 0x4(%rsp), %edi
callq 0x340b
leaq 0xb564(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
jmp 0x931f
cmpl $0x2, %ebx
je 0x92ea
cmpl $0xff, 0x4(%rsp)
jg 0x92ea
leaq 0xb373(%rip), %rax      # 0x14608
cmpl $0x0, 0xe4(%rax)
jne 0x92ea
orb $0x60, %bpl
movsbl %bpl, %edi
callq 0x3355
movsbl 0x4(%rsp), %edi
callq 0x340b
leaq 0xb51c(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x3, (%rax)
jmp 0x931f
orb $-0x66, %bpl
movsbl %bpl, %edi
callq 0x3355
movswl 0x4(%rsp), %edi
callq 0x355d
leaq 0xb4f6(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x5, (%rax)
jmp 0x930e
orb $-0x68, %bpl
movsbl %bpl, %edi
callq 0x3355
movswl 0x4(%rsp), %edi
callq 0x355d
leaq 0xb4d0(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
cmpl $0x2, %ebx
jne 0x931f
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa118
jmp 0x9322
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdi
callq 0x9d6c
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x93e8
movl 0xc(%rsp), %edx
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x9375
leaq 0x3c2c(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
callq 0xa1d8
movl %eax, %r14d
jmp 0x93e8
movl %eax, %ebp
leaq 0xb45a(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %ecx
cmpl $0x2, %ebp
je 0x93bc
cmpl $0xff, %edx
ja 0x93bc
leaq 0xb271(%rip), %rdx      # 0x14608
cmpl $0x0, 0xe4(%rdx)
jne 0x93bc
addl $0x5, %ecx
movl %ecx, (%rax)
movsbl %bl, %edi
callq 0x3355
movsbl 0xc(%rsp), %edi
callq 0x340b
xorl %r14d, %r14d
jmp 0x93e8
addl $0x6, %ecx
movl %ecx, (%rax)
orb $0x8, %bl
movsbl %bl, %edi
callq 0x3355
movswl 0xc(%rsp), %edi
callq 0x355d
xorl %r14d, %r14d
cmpl $0x2, %ebp
jne 0x93e8
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa118
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0xb1f4(%rip), %rax      # 0x14608
xorl %ebx, %ebx
cmpl $0x0, 0xf8(%rax)
je 0x9479
cmpl $0x0, 0x188(%rax)
je 0x9479
movq %rdi, %rsi
leaq 0xb1be(%rip), %rax      # 0x145f0
cmpl $0x1, (%rax)
jne 0x9440
leaq 0x8542(%rip), %rdi      # 0x11980
jmp 0x9447
leaq 0x91d9(%rip), %rdi      # 0x12620
callq 0x6658
testl %eax, %eax
js 0x9474
callq 0x5a97
testl %eax, %eax
je 0x9479
leaq 0x13ac0(%rip), %rax     # 0x1cf20
movq (%rax), %rsi
movl $0x18, %edi
callq 0xa1d8
movl $0x1, %ebx
jmp 0x9479
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x31e0
movq %rax, %r14
movq (%rax), %rcx
leaq 0x13a93(%rip), %r12     # 0x1cf30
movslq (%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x94c0
leaq 0x3ae3(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa1d8
jmp 0x951c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,2), %r15
addq $-0x30, %r15
callq 0x4f1a
movq (%r14), %rcx
movslq (%r12), %rax
incl %ebp
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x94c8
testq %r15, %r15
setns %al
cmpl $0x14, %ebp
setb %cl
testb %cl, %al
jne 0x9517
movl $0x0, (%rbx)
leaq 0x3a8c(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa1d8
movl $0x1, %ebx
jmp 0x951c
movl %r15d, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x31e0
movq %rax, %r14
movq (%rax), %rcx
leaq 0x139ec(%rip), %r12     # 0x1cf30
movslq (%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x9567
leaq 0x3a3c(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa1d8
jmp 0x95c4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,2), %r15
addq $-0x30, %r15
callq 0x4f1a
movq (%r14), %rcx
movslq (%r12), %rax
incl %ebp
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x956f
testq %r15, %r15
setns %al
cmpl $0x14, %ebp
setb %cl
testb %cl, %al
jne 0x95bf
movq $0x0, (%rbx)
leaq 0x39e4(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa1d8
movl $0x1, %ebx
jmp 0x95c4
movq %r15, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x1394c(%rip), %r15     # 0x1cf30
movabsq $0x3f0000003f, %r12     # imm = 0x3F0000003F
xorl %ebp, %ebp
movl (%r15), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x9609
leal -0x41(%rax), %ecx
cmpl $0x25, %ecx
ja 0x9632
btq %rcx, %r12
jae 0x9632
shlq $0x4, %r14
movl %eax, %ecx
andl $0xdf, %ecx
addq $-0x37, %rcx
movl %eax, %edx
addq $-0x30, %rdx
cmpl $0x3a, %eax
cmovaeq %rcx, %rdx
addq %rdx, %r14
callq 0x4f1a
incl %ebp
jmp 0x95f0
testl %ebp, %ebp
je 0x965a
cmpl $0x11, %ebp
jb 0x9672
movq $0x0, (%rbx)
leaq 0x3949(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa1d8
movl $0x1, %ebx
jmp 0x9677
leaq 0x3931(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa1d8
jmp 0x9677
movq %r14, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x138a0(%rip), %r14     # 0x1cf30
movl (%r14), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x30, %ecx
jne 0x96e3
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movl %eax, %eax
leaq (%rax,%r15,2), %r15
addq $-0x30, %r15
callq 0x4f1a
movl (%r14), %eax
movl %eax, %ecx
andl $-0x2, %ecx
incl %ebp
cmpl $0x30, %ecx
je 0x96a8
cmpl $0x40, %ebp
jb 0x96fb
leaq 0x38c0(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa1d8
movl $0x1, %ebx
jmp 0x9700
leaq 0x38a8(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa1d8
jmp 0x9700
movq %r15, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, 0x8(%rsp)
leaq 0x1459c(%rip), %rdi     # 0x1dcc0
callq 0x52f1
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x979e
leaq 0x14585(%rip), %rdi     # 0x1dcc0
andb $-0x21, 0x14582(%rip)   # 0x1dcc4
leaq 0x8(%rsp), %rsi
callq 0x60dc
testq %rax, %rax
je 0x975b
movslq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x979c
movl 0x14563(%rip), %eax     # 0x1dcc4
testb %al, %al
js 0x9770
orl $0x80, %eax
movl %eax, 0x14554(%rip)     # 0x1dcc4
leaq 0x14549(%rip), %rdi     # 0x1dcc0
leaq 0xc(%rsp), %rsi
callq 0x5cf9
leaq 0x13568(%rip), %rcx     # 0x1ccf0
movq %rax, (%rcx)
movq $0x0, (%rbx)
movl $0x1, 0x14584(%rip)     # 0x1dd20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9ac3
testl %eax, %eax
je 0x9a17
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x8(%rsp)
xorl %eax, %eax
callq 0x4ff7
movq 0x10(%rsp), %r15
leaq 0x13501(%rip), %r12     # 0x1cf30
movq %rsp, %r14
movabsq $0x8000000000005, %r13  # imm = 0x8000000000005
movl (%r12), %ebx
leal -0x2b(%rbx), %eax
cmpl $0x33, %eax
ja 0x9a4e
btq %rax, %r13
jb 0x9a53
cmpl $0x7c, %ebx
jne 0x9ab4
callq 0x4f1a
testl %eax, %eax
je 0x9a99
movq %r14, %rdi
callq 0x9ac3
testl %eax, %eax
jne 0x9a04
cmpl $0x5d, %ebx
jg 0x9a7d
cmpl $0x2b, %ebx
je 0x9a8d
cmpl $0x2d, %ebx
jne 0x9a3c
subq (%rsp), %r15
jmp 0x9a3c
cmpl $0x5e, %ebx
je 0x9a93
cmpl $0x7c, %ebx
jne 0x9a3c
orq (%rsp), %r15
jmp 0x9a3c
addq (%rsp), %r15
jmp 0x9a3c
xorq (%rsp), %r15
jmp 0x9a3c
leaq 0x34f2(%rip), %rsi      # 0xcf92
movl $0x11, %ebp
movl $0x11, %edi
callq 0xa1d8
jmp 0x9a06
movq 0x8(%rsp), %rax
movq %r15, (%rax)
xorl %ebp, %ebp
jmp 0x9a06
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/expression.c
// Function: product
int product(int64_t *value)
{
  int err;
  int64_t a,b;

  err = uni( &a );

  if ( err ) return err;

  KillSpace();

  while( (atom == '*') ||
	 (atom == '/') ||
	 (atom == '&') ||
	 ((atom == '<') && next_atom == '<') ||
	 ((atom == '>') && next_atom == '>')){

    char save = atom;

    need_ch();

    if ( save == '<' || save == '>' ){
      if ( atom != save ){
	Error(EXPR_ERR,"");
	return EXPR_ERROR;
      }
      GetAtom();
    }

    err = uni( &b );

    if ( err ) return err;

    switch ( save ){
    case '*' : a *= b; break;
    case '/' : a /= b; break;
    case '&' : a &= b; break;
    case '<' : a <<=b; break;
    case '>' : a >>=b; break;
    }

    KillSpace();
  }

  *value = a;

  return EXPR_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x97a4
testl %eax, %eax
je 0x9af5
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x8(%rsp)
xorl %eax, %eax
callq 0x4ff7
movq 0x10(%rsp), %r14
leaq 0x13423(%rip), %r12     # 0x1cf30
movq %rsp, %r15
movabsq $0x844000000000, %r13   # imm = 0x844000000000
movl (%r12), %ebx
cmpq $0x2f, %rbx
ja 0x9b8b
btq %rbx, %r13
jae 0x9b8b
callq 0x4f1a
testl %eax, %eax
je 0x9bd8
movl %ebx, %eax
andl $0xfd, %eax
cmpl $0x3c, %eax
jne 0x9b52
cmpl %ebx, (%r12)
jne 0x9bf3
callq 0x4f1a
movq %r15, %rdi
callq 0x97a4
testl %eax, %eax
jne 0x9ae2
cmpl $0x2e, %ebx
jle 0x9b7a
cmpl $0x2f, %ebx
je 0x9bb2
cmpl $0x3c, %ebx
je 0x9bc0
cmpl $0x3e, %ebx
jne 0x9bcc
movb (%rsp), %cl
sarq %cl, %r14
jmp 0x9bcc
cmpl $0x26, %ebx
je 0x9bc8
cmpl $0x2a, %ebx
jne 0x9bcc
imulq (%rsp), %r14
jmp 0x9bcc
movl %ebx, %ecx
xorl $0x3c, %ecx
leaq 0x133a1(%rip), %rax     # 0x1cf38
movl (%rax), %eax
movl %eax, %edx
xorl $0x3c, %edx
orl %ecx, %edx
je 0x9b2a
cmpl $0x3e, %ebx
jne 0x9c0e
cmpl $0x3e, %eax
je 0x9b2a
jmp 0x9c0e
movq %r14, %rax
cqto
idivq (%rsp)
movq %rax, %r14
jmp 0x9bcc
movb (%rsp), %cl
shlq %cl, %r14
jmp 0x9bcc
andq (%rsp), %r14
xorl %eax, %eax
callq 0x4ff7
jmp 0x9b1a
leaq 0x33b3(%rip), %rsi      # 0xcf92
movl $0x11, %ebp
movl $0x11, %edi
callq 0xa1d8
jmp 0x9ae4
leaq 0x3398(%rip), %rsi      # 0xcf92
movl $0x11, %edi
callq 0xa1d8
movl $0x1, %ebp
jmp 0x9ae4
movq 0x8(%rsp), %rax
movq %r14, (%rax)
xorl %ebp, %ebp
jmp 0x9ae4
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/expression.c
// Function: Expression64
int Expression64(int64_t * value)
{
  int64_t v1,v2;
  int err;
  int flag = 0;
  *value = 0;
  ExprFailed = 0;

  if ( (err = sum( &v1 )) != EXPR_OK ) return err;

  KillSpace();

  switch ( atom ){
  case '=':
    GetAtom();
    if ( (err = sum( &v2 )) != EXPR_OK ) return err;
    *value = (v1 == v2);
    break;
  case '<' :
    GetAtom();
    flag = 0;
    if ( TestAtom('=') ){
      flag = 1;
    } else if ( TestAtom('>') ) {
      flag = 2;
    }
    if ( (err = sum( &v2 )) != EXPR_OK ) return err;
    switch( flag ){
    case 0 :
      *value = (v1 < v2);
      break;
    case 1 :
      *value = ( v1 <= v2);
      break;
    case 2 :
      *value = (v1 != v2);
      break;
    }
    break;
  case '>':
    flag = 0;
    GetAtom();
    if ( TestAtom('=') ){
      flag = 1;
    }
    if ( (err = sum( &v2 )) != EXPR_OK ) return err;
    if ( flag ){
      *value = (v1 >= v2);
    } else {
      *value = (v1 > v2 );
    }
    break;
  default:
    *value = v1;
  }

  if ( ExprFailed ){
    *value = 0;
    return EXPR_UNSOLVED;
  } else
    return EXPR_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x0, 0x140e9(%rip)     # 0x1dd20
leaq 0x10(%rsp), %rdi
callq 0x99e5
testl %eax, %eax
jne 0x9d4d
xorl %eax, %eax
callq 0x4ff7
leaq 0x132d9(%rip), %rax     # 0x1cf30
movl (%rax), %eax
cmpl $0x3c, %eax
je 0x9cd6
cmpl $0x3e, %eax
je 0x9c97
cmpl $0x3d, %eax
jne 0x9d2e
callq 0x4f1a
leaq 0x8(%rsp), %rdi
callq 0x99e5
testl %eax, %eax
jne 0x9d4d
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
cmpq 0x8(%rsp), %rax
sete %cl
jmp 0x9d33
callq 0x4f1a
movl $0x3d, %edi
callq 0x4fa8
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x99e5
testl %eax, %eax
jne 0x9d4d
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x9d54
cmpq %rdx, %rax
setge %cl
jmp 0x9d33
callq 0x4f1a
movl $0x3d, %edi
callq 0x4fa8
movl $0x1, %ebp
testl %eax, %eax
jne 0x9d02
movl $0x3e, %edi
callq 0x4fa8
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
addl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x99e5
testl %eax, %eax
jne 0x9d4d
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
cmpl $0x2, %ebp
je 0x9d5c
cmpl $0x1, %ebp
jne 0x9d64
cmpq %rdx, %rax
setle %cl
jmp 0x9d33
movq 0x10(%rsp), %rcx
movq %rcx, (%rbx)
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x0, 0x13fdf(%rip)     # 0x1dd20
setne %al
cmoveq %rcx, %rdx
movq %rdx, (%rbx)
addl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
cmpq %rdx, %rax
setg %cl
jmp 0x9d33
cmpq %rdx, %rax
setne %cl
jmp 0x9d33
cmpq %rdx, %rax
setl %cl
jmp 0x9d33
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, (%rdi)
leaq 0x8(%rsp), %rdi
callq 0x9c1d
testl %eax, %eax
jne 0x9dbe
movq 0x8(%rsp), %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
movabsq $-0x180000001, %rdx     # imm = 0xFFFFFFFE7FFFFFFF
cmpq %rdx, %rcx
ja 0x9dba
movl $0x10, %edi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
jmp 0xa1d8
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl 0x13f27(%rip), %ecx     # 0x1dd30
testl %ecx, %ecx
je 0x9e35
leal 0x1(%rcx), %eax
movl %eax, 0x13f1a(%rip)     # 0x1dd30
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0x9e96
leaq 0x316e(%rip), %rsi      # 0xcf92
movl $0x19, %edi
callq 0xa1d8
movl $0x1, %eax
jmp 0x9e96
movq %rdi, %rbx
movl $0x1, %ebp
movl %ebp, 0x13eed(%rip)     # 0x1dd30
callq 0x30b0
movl %eax, 0x13eea(%rip)     # 0x1dd38
leaq 0x13f1b(%rip), %rdi     # 0x1dd70
movq %rbx, %rsi
callq 0x3070
leaq 0xa7a4(%rip), %rax      # 0x14608
movq (%rax), %rcx
movq 0x198(%rax), %rdx
movq %rcx, 0x13ed3(%rip)     # 0x1dd48
movq $0x0, 0x13ec0(%rip) # 0x1dd40
movq %rdx, 0x13ed1(%rip)     # 0x1dd58
movl $0x4, 0x13eab(%rip)     # 0x1dd3c
movl %ebp, 0xc(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
decl 0x13e86(%rip)           # 0x1dd30
je 0x9eb4
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xa74d(%rip), %rax      # 0x14608
movl $0x0, 0xc(%rax)
leaq 0x13e6f(%rip), %rdi     # 0x1dd38
leaq 0xc(%rsp), %rsi
callq 0x5cf9
testq %rax, %rax
je 0x9ef4
cmpl $0x0, 0xc(%rsp)
je 0x9eac
leaq 0x30ac(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
movl %eax, %ebx
jmp 0x9eac
movl $0x1, %ebx
jmp 0x9eac
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/macro.c
// Function: GetOperand
int GetOperand(char * dst)
{
  int StringFlag = 0;
  int ParenFlag = 0;
  int exit = FALSE;
  char *ptr = dst;

  if ( KillSpace() ){
    while ( atom  && !exit ) {
      switch ( atom ){
      case  '"' :
	StringFlag ^= 1;
	*ptr++=atom;
	break;
      case '{' :
	ParenFlag ++;
	break;
      case '}':
	ParenFlag --;
	break;
      case ',':
	if  ( !StringFlag && !ParenFlag ){
	  exit = TRUE;
	  continue;
	} else
	  *ptr++ = atom;
	break;
      case ';':
	if ( !StringFlag && !ParenFlag ){
	  exit = TRUE;
	  continue;
	} else
	  *ptr++ = atom;
	break;
      case SPACE:
	if ( StringFlag || ParenFlag ){
	  *ptr++ = atom;
	}
	break;
      default:
	*ptr++ = atom;
      }
      GetAtom();
    }
  }
  *ptr=0;
  return ptr != dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4ff7
testl %eax, %eax
setne %cl
leaq 0x13015(%rip), %r15     # 0x1cf30
movl (%r15), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
movq %rbx, %r14
cmpb $0x1, %dl
jne 0x9faa
movq %rbx, %r14
xorl %r12d, %r12d
cmpl $0x3a, %eax
jg 0x9f54
cmpl $0x20, %eax
je 0x9f67
cmpl $0x22, %eax
je 0x9f86
cmpl $0x2c, %eax
jne 0x9f81
movl %r12d, %eax
orl %ebp, %eax
je 0x9faa
movb $0x2c, (%r14)
jmp 0x9f8e
cmpl $0x3b, %eax
je 0x9f74
cmpl $0x7b, %eax
je 0x9f9f
cmpl $0x7d, %eax
jne 0x9f81
decl %ebp
jmp 0x9f91
movl %r12d, %eax
orl %ebp, %eax
je 0x9fa3
movb $0x20, (%r14)
jmp 0x9f8e
movl %r12d, %eax
orl %ebp, %eax
je 0x9faa
movb $0x3b, (%r14)
jmp 0x9f8e
movb %al, (%r14)
jmp 0x9f8e
xorl $0x1, %r12d
movb $0x22, (%r14)
incq %r14
callq 0x4f1a
movl (%r15), %eax
testl %eax, %eax
jne 0x9f33
jmp 0x9faa
incl %ebp
jmp 0x9f91
xorl %r12d, %r12d
xorl %ebp, %ebp
jmp 0x9f91
movb $0x0, (%r14)
xorl %eax, %eax
cmpq %rbx, %r14
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/macro.c
// Function: CheckMacro
int CheckMacro(char * s)
{
  int err = 0;

  if ( Current.ifFlag && Current.switchFlag ){
    int OpCnt = 0;
    int save_atom = atom;
    struct current_s save_Current = Current;
    label_t *macro;

    if ( FindMacro( s , &macro) ) return -1;

//->    printf("Macro: (%s)\n",macro->name);

    Current.Macro.Line = Current.Line;
    Current.Macro.File = Current.File;
    Current.Line = macro->line;
    Current.File = macro->file;
    Current.Macro.Name = macro->name;
    Current.Macro.invoked = ++macro->count;
    Current.SrcPtr = ((char *)macro->macro);

    memset((char *)macrovars[Current.Macro.Processing],0,16*80);

    do {
      if ( GetOperand(macrovars[Current.Macro.Processing][OpCnt]) ||
	   atom == ',' ) OpCnt++;
    }while ( TestAtom(',') && OpCnt <= 16);

    //    printf("%d macro-paras\n",OpCnt);

    Current.Macro.NPara = OpCnt;
    Current.Macro.Processing++;

    undefAllMacroLocals();

    ++cntMacroExpand;
    err = mainloop(0);

    Current = save_Current;
    atom = save_atom;
  }
  return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0xa631(%rip), %rax      # 0x14608
xorl %ebp, %ebp
cmpl $0x0, 0xf8(%rax)
je 0xa104
cmpl $0x0, 0x188(%rax)
je 0xa104
movq %rdi, %r14
leaq 0x12f33(%rip), %r15     # 0x1cf30
movl (%r15), %r12d
leaq 0xa601(%rip), %rbx      # 0x14608
leaq 0x8(%rsp), %rdi
movl $0x1c0, %edx            # imm = 0x1C0
movq %rbx, %rsi
callq 0x3150
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6197
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xa104
movq (%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, (%rbx)
leaq 0x38(%rax), %rcx
movq %rcx, 0x18(%rbx)
movl 0x18(%rax), %ecx
incl %ecx
movl %ecx, 0x18(%rax)
movl %ecx, 0x24(%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x198(%rbx)
movslq 0x8(%rbx), %rax
leaq (%rax,%rax,4), %rdi
shlq $0x8, %rdi
leaq 0x13d2c(%rip), %r14     # 0x1dda0
addq %r14, %rdi
xorl %ebp, %ebp
movl $0x500, %edx            # imm = 0x500
xorl %esi, %esi
callq 0x30d0
movl %ebp, %r13d
movslq 0x8(%rbx), %rax
movl %ebp, %ecx
leaq (%rax,%rax,4), %rax
shlq $0x8, %rax
leaq (%rcx,%rcx,4), %rdi
shlq $0x4, %rdi
addq %r14, %rdi
addq %rax, %rdi
callq 0x9efb
testl %eax, %eax
setne %al
cmpl $0x2c, (%r15)
sete %cl
orb %al, %cl
movzbl %cl, %ebp
addl %r13d, %ebp
movl $0x2c, %edi
callq 0x4fa8
testl %eax, %eax
je 0xa0d0
cmpl $0x11, %ebp
jb 0xa085
movl %ebp, 0x20(%rbx)
incl 0x8(%rbx)
xorl %eax, %eax
callq 0x61e6
leaq 0xa2b4(%rip), %rax      # 0x14398
incl (%rax)
xorl %edi, %edi
callq 0x42bd
movl %eax, %ebp
leaq 0x8(%rsp), %rsi
movl $0x1c0, %edx            # imm = 0x1C0
movq %rbx, %rdi
callq 0x3150
movl %r12d, (%r15)
movl %ebp, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/ref.c
// Function: saveCurrentLine
void saveCurrentLine()
{
  REFERENCE *refPtr;
  
  refPtr = (REFERENCE *)my_malloc(sizeof(REFERENCE) + (long)strlen(srcLine) + 1UL );

  strcpy(refPtr->src,srcLine);
  refPtr->line = Current.Line-1;
  refPtr->file = Current.File;
  refPtr->macroline = Current.Macro.Line;
  refPtr->macrofile = Current.Macro.File;
  refPtr->macroinvoked = Current.Macro.invoked;
  refPtr->macro = Current.Macro.Processing;
  //  refPtr->var = Current.var;
  refPtr->pc = Global.OldPC;
  refPtr->codePtr = code.OldPtr;
  refPtr->up =
  refPtr->down = (REFERENCE *)0;
  refPtr->unknown = unknownLabel;
  refPtr->mode = sourceMode;

  if ( refFirst ){
    refPtr->down = refLast;
    refLast->up = refPtr;
  } else {
    refFirst = refPtr;
  }
  refLast = refPtr;

//->   printf("ref.c: %s (%s) = %p\n",unknownLabel->name,srcLine,refLast);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x12cfd(%rip), %r14     # 0x1ce20
movq %r14, %rdi
callq 0x30b0
leaq 0x51(%rax), %rdi
callq 0x331c
movq %rax, %rbx
leaq 0x48(%rax), %rdi
movq %r14, %rsi
callq 0x3070
leaq 0xa4be(%rip), %rax      # 0x14608
movl (%rax), %ecx
decl %ecx
movl %ecx, 0x14(%rbx)
movl 0x4(%rax), %ecx
movl %ecx, 0x18(%rbx)
movq 0x10(%rax), %rcx
movq %rcx, 0x1c(%rbx)
movl 0x24(%rax), %ecx
movl %ecx, 0x24(%rbx)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rbx)
leaq 0xa23e(%rip), %rax      # 0x143b0
movl 0x4(%rax), %eax
movl %eax, 0x10(%rbx)
leaq 0xa451(%rip), %rax      # 0x145d0
movq 0x18(%rax), %rax
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x12b5c(%rip), %rax     # 0x1ccf0
movq (%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0xa44e(%rip), %rax      # 0x145f0
movl (%rax), %eax
movl %eax, 0x30(%rbx)
cmpq $0x0, 0x18bf1(%rip)     # 0x22da0
je 0xa1be
movq 0x18bf0(%rip), %rax     # 0x22da8
movq %rax, 0x8(%rbx)
jmp 0xa1c5
leaq 0x18bdb(%rip), %rax     # 0x22da0
movq %rbx, (%rax)
movq %rbx, 0x18bd9(%rip)     # 0x22da8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/error.c
// Function: Warning
void Warning(const char *s)
{
  cntWarning++;
  if (warning && Current.File >= 0){
    if ( Current.Macro.Line ){
      fprintf(my_stderr,"WARNING: %s;%d:Macro-Line %5d:<%s>: '%s'\n",
	      file_list[Current.File].name,Current.Line,
	      Current.Macro.Line,file_list[Current.Macro.File].name,
              srcLine);
    } else {
      fprintf(my_stderr,"WARNING: %s:%5d: '%s'\n",
              file_list[Current.File].name,Current.Line, srcLine);
    }
    printf("%s\n",s);
  }
}

// Assembly:
leaq 0x9b72(%rip), %rax      # 0x14394
incl (%rax)
leaq 0x9b4d(%rip), %rax      # 0x14378
cmpl $0x0, (%rax)
setne %dl
leaq 0x9dd0(%rip), %rax      # 0x14608
movl 0x4(%rax), %ecx
testl %ecx, %ecx
setns %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xa8b4
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %ecx, %edx
movl (%rax), %ecx
movl 0x10(%rax), %r8d
movq %rdx, %rsi
shlq $0x9, %rsi
leaq 0x9d90(%rip), %rdi      # 0x145f8
movq (%rdi), %rdi
leaq (%rsi,%rdx,4), %rdx
leaq 0x9f6a(%rip), %rsi      # 0x147e0
addq %rsi, %rdx
addq $0x4, %rdx
testl %r8d, %r8d
je 0xa8b5
movslq 0x14(%rax), %rax
movq %rax, %r9
shlq $0x9, %r9
leaq (%r9,%rax,4), %rax
leaq (%rsi,%rax), %r9
addq $0x4, %r9
leaq 0x12580(%rip), %rax     # 0x1ce20
movq %rax, (%rsp)
leaq 0x32c2(%rip), %rsi      # 0xdb6d
xorl %eax, %eax
callq 0x3130
jmp 0xa8ca
retq
leaq 0x32db(%rip), %rsi      # 0xdb97
leaq 0x1255d(%rip), %r8      # 0x1ce20
xorl %eax, %eax
callq 0x3130
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3080
nop
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/jaguar.c
// Function: one_reg
int one_reg(int op)
{
  int reg;

  if ( GetRegister( &reg) ) return 1;

  // handle UNPACK specially
  if ( op == 64 ){
    op = ( 63 << 10 ) | 32 | reg;
  } else {
    op = (op << 10) | reg;
  }
  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdi
callq 0xab43
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0xadcd
cmpl $0x40, %ebx
jne 0xad9f
movl $0xfc20, %ebx           # imm = 0xFC20
jmp 0xada2
shll $0xa, %ebx
orl 0xc(%rsp), %ebx
movl %ebx, %eax
shrl $0xa, %eax
andl $0x3f, %eax
movl %eax, 0x936c(%rip)      # 0x14120
leaq 0x95f5(%rip), %rax      # 0x143b0
movl (%rax), %eax
movl %eax, 0x9361(%rip)      # 0x14124
movswl %bx, %edi
callq 0x35cf
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/jaguar.c
// Function: two_reg
int two_reg(int op)
{
  int reg1,reg2;
  if ( GetRegisterOrPC( &reg1 )) return 1;
  if ( !TestAtom(',') )return Error(SYNTAX_ERR,"");
  if ( GetRegister( &reg2 )) return 1;

  if ( reg1 == 64 && op == 34){ // special case: mov pc,rn
    op = 51;
    reg1 = 0;
  }

  if ( reg1 > 31 ) return Error(REG_ERR,"");

  op = ( op << 10 ) | ( reg1 << 5 ) | reg2;

  writeOp( op );
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x4(%rsp), %rdi
callq 0xa8f8
movl $0x1, %ebx
testl %eax, %eax
je 0xadf4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x2c, %edi
callq 0x4fa8
testl %eax, %eax
je 0xae43
movq %rsp, %rdi
callq 0xab43
testl %eax, %eax
jne 0xadeb
movl 0x4(%rsp), %edx
movl %edx, %eax
xorl $0x40, %eax
movl %ebp, %esi
xorl $0x22, %esi
xorl %ebx, %ebx
movl $0x33, %ecx
orl %eax, %esi
movl $0x0, %eax
je 0xae5a
movl %ebp, %ecx
movl %edx, %eax
cmpl $0x20, %edx
jl 0xae5a
leaq 0x2156(%rip), %rsi      # 0xcf92
movl $0x2c, %edi
jmp 0xae4f
leaq 0x2148(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa1d8
shll $0xa, %ecx
shll $0x5, %eax
orl %ecx, %eax
orl (%rsp), %eax
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movl %ecx, 0x92ad(%rip)      # 0x14120
leaq 0x9536(%rip), %rcx      # 0x143b0
movl (%rcx), %ecx
movl %ecx, 0x92a2(%rip)      # 0x14124
movswl %ax, %edi
callq 0x35cf
jmp 0xadeb
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/jaguar.c
// Function: imm_reg
int imm_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

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

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

  if ( err == EXPR_UNSOLVED ) {
    saveCurrentLine();
    imm = 1;
  }

  if ( imm < 1 || imm > 32 ) Error(IMM_ERR,"1<=x<=32");

  if ( op == 24 ) imm = 32-imm; // shlq

  if ( imm == 32 ) imm = 0;

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

  if ( GetRegister( &reg ) ) return 1;

  op = ( op << 10 ) | ( imm << 5) | reg;

  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x23, %edi
callq 0x4fa8
testl %eax, %eax
je 0xaecd
movq %rsp, %rdi
callq 0x9d6c
movl $0x1, %ebp
cmpl $0x11, %eax
je 0xaf8d
cmpl $0x2, %eax
jne 0xaee4
xorl %eax, %eax
callq 0xa118
movl $0x1, (%rsp)
jmp 0xaf00
leaq 0x20be(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa1d8
movl (%rsp), %eax
addl $-0x21, %eax
cmpl $-0x21, %eax
ja 0xaf00
leaq 0x2cb8(%rip), %rsi      # 0xdbae
movl $0x2b, %edi
callq 0xa1d8
movl (%rsp), %ecx
movl $0x20, %eax
subl %ecx, %eax
cmpl $0x18, %ebx
cmovnel %ecx, %eax
setne %cl
cmpl $0x20, %eax
setne %dl
testb %dl, %cl
jne 0xaf28
xorl %ecx, %ecx
cmpl $0x20, %eax
cmovnel %eax, %ecx
movl %ecx, (%rsp)
movl $0x2c, %edi
callq 0x4fa8
testl %eax, %eax
je 0xaf7a
leaq 0x4(%rsp), %rdi
callq 0xab43
testl %eax, %eax
jne 0xaf8d
shll $0xa, %ebx
movl (%rsp), %eax
shll $0x5, %eax
orl %ebx, %eax
orl 0x4(%rsp), %eax
movswl %ax, %edi
shrl $0xa, %eax
andl $0x3f, %eax
movl %eax, 0x91be(%rip)      # 0x14120
leaq 0x9447(%rip), %rax      # 0x143b0
movl (%rax), %eax
movl %eax, 0x91b3(%rip)      # 0x14124
callq 0x35cf
xorl %ebp, %ebp
jmp 0xaf8d
leaq 0x2011(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/jaguar.c
// Function: imm2_reg
int imm2_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

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

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

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();

  if ( imm < 0 || imm > 31 ) Error(IMM_ERR,"0<=n<=31");

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

  if ( GetRegister( &reg ) ) return 1;

  op = ( op << 10 ) | ( imm << 5) | reg;

  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x23, %edi
callq 0x4fa8
testl %eax, %eax
je 0xb038
movq %rsp, %rdi
callq 0x9d6c
movl $0x1, %ebp
cmpl $0x11, %eax
je 0xb062
cmpl $0x2, %eax
jne 0xafcf
xorl %eax, %eax
callq 0xa118
cmpl $0x20, (%rsp)
jb 0xafe6
leaq 0x2bdb(%rip), %rsi      # 0xdbb7
movl $0x2b, %edi
callq 0xa1d8
movl $0x2c, %edi
callq 0x4fa8
testl %eax, %eax
je 0xb04f
leaq 0x4(%rsp), %rdi
callq 0xab43
testl %eax, %eax
jne 0xb062
shll $0xa, %ebx
movl (%rsp), %eax
shll $0x5, %eax
orl %ebx, %eax
orl 0x4(%rsp), %eax
movswl %ax, %edi
shrl $0xa, %eax
andl $0x3f, %eax
movl %eax, 0x9100(%rip)      # 0x14120
leaq 0x9389(%rip), %rax      # 0x143b0
movl (%rax), %eax
movl %eax, 0x90f5(%rip)      # 0x14124
callq 0x35cf
xorl %ebp, %ebp
jmp 0xb062
leaq 0x1f53(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa1d8
leaq 0x1f3c(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/jaguar.c
// Function: imm3_reg
int imm3_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

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

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

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();

  if ( imm < -16 || imm > 15 ) Error(IMM_ERR,"-16<=n<=15");

  imm &= 31;

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

  if ( GetRegister( &reg ) ) return 1;

  op = ( op << 10 ) | ( imm << 5) | reg;

  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x23, %edi
callq 0x4fa8
testl %eax, %eax
je 0xb11b
movq %rsp, %rdi
callq 0x9d6c
movl $0x1, %ebp
cmpl $0x11, %eax
je 0xb145
cmpl $0x2, %eax
jne 0xb0a4
xorl %eax, %eax
callq 0xa118
movl (%rsp), %eax
leal -0x10(%rax), %ecx
cmpl $-0x21, %ecx
ja 0xb0c3
leaq 0x2b0a(%rip), %rsi      # 0xdbc0
movl $0x2b, %edi
callq 0xa1d8
movl (%rsp), %eax
andl $0x1f, %eax
movl %eax, (%rsp)
movl $0x2c, %edi
callq 0x4fa8
testl %eax, %eax
je 0xb132
leaq 0x4(%rsp), %rdi
callq 0xab43
testl %eax, %eax
jne 0xb145
shll $0xa, %ebx
movl (%rsp), %eax
shll $0x5, %eax
orl %ebx, %eax
orl 0x4(%rsp), %eax
movswl %ax, %edi
shrl $0xa, %eax
andl $0x3f, %eax
movl %eax, 0x901d(%rip)      # 0x14120
leaq 0x92a6(%rip), %rax      # 0x143b0
movl (%rax), %eax
movl %eax, 0x9012(%rip)      # 0x14124
callq 0x35cf
xorl %ebp, %ebp
jmp 0xb145
leaq 0x1e70(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa1d8
leaq 0x1e59(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/jaguar.c
// Function: imm4_reg
int imm4_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

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

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

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

  if ( GetRegister( &reg ) ) return 1;

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();

  if ( (last_op == 52 || last_op == 53) && last_pc == (Global.pc-2) ){
    Warning("MOVEI after JR/JUMP is unpredictable!");
  }

  op = ( op << 10 ) | reg;

  writeOp( op );
  writeWordBig( imm & 0xffff);
  writeWordBig( imm >> 16 );

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movl $0x23, %edi
callq 0x4fa8
testl %eax, %eax
je 0xb223
leaq 0x8(%rsp), %rdi
callq 0x9d6c
movl $0x1, %ebp
cmpl $0x11, %eax
je 0xb24f
movl %eax, %r14d
movl $0x2c, %edi
callq 0x4fa8
testl %eax, %eax
je 0xb23c
leaq 0xc(%rsp), %rdi
callq 0xab43
testl %eax, %eax
jne 0xb24f
cmpl $0x2, %r14d
jne 0xb1b6
xorl %eax, %eax
callq 0xa118
movl 0x8f64(%rip), %ecx      # 0x14120
andl $-0x2, %ecx
leaq 0x91ea(%rip), %r14      # 0x143b0
movl (%r14), %eax
cmpl $0x34, %ecx
jne 0xb1e8
leal -0x2(%rax), %ecx
cmpl %ecx, 0x8f4d(%rip)      # 0x14124
jne 0xb1e8
leaq 0x29eb(%rip), %rdi      # 0xdbcb
callq 0xa81b
movl (%r14), %eax
shll $0xa, %ebx
orl 0xc(%rsp), %ebx
movl %ebx, %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movl %ecx, 0x8f23(%rip)      # 0x14120
movl %eax, 0x8f21(%rip)      # 0x14124
movswl %bx, %edi
callq 0x35cf
movswl 0x8(%rsp), %edi
callq 0x35cf
movswl 0xa(%rsp), %edi
callq 0x35cf
xorl %ebp, %ebp
jmp 0xb24f
leaq 0x1d68(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xa1d8
leaq 0x1d4f(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/jaguar.c
// Function: GetCondition
int GetCondition(int *cond)
{
  label_t condition;
  label_t *l;
  int32_t solved;
  int i;
  char *save_srcLinePtr = srcLinePtr-1;

  *cond = 0;
  if ( GetLabel(&condition) ) return 0;

  if ( condition.type != (UNSURE|NORMAL) ){
    srcLinePtr = save_srcLinePtr;
    atom = *srcLinePtr++;
    return 0;
  }

//->  printf("Cond:%s\n",condition.name);

  if ( atom != ',' || (l = FindLabel(&condition, &solved) ) != NULL ){
    srcLinePtr = save_srcLinePtr;
    atom = *srcLinePtr++;
    return 0;
  }

  if ( condition.len > 5 )  return Error(SYNTAX_ERR,"");

  for( i = 0 ; conditions[i].cond ; ++i ){
    if ( !strcasecmp(conditions[i].ascCond,condition.name) ){
      *cond = conditions[i].cond;
      return 0;
    }
  }

  *cond = 0;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
leaq 0x11cae(%rip), %r12     # 0x1cf20
movq (%r12), %r15
movl $0x0, (%rdi)
leaq 0x8(%rsp), %rdi
callq 0x52f1
xorl %ebx, %ebx
testl %eax, %eax
jne 0xb2d6
cmpl $0x21, 0xc(%rsp)
jne 0xb2c4
leaq 0x11c96(%rip), %r13     # 0x1cf30
cmpl $0x2c, (%r13)
jne 0xb2b5
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x60dc
testq %rax, %rax
je 0xb2e7
movq %r15, (%r12)
movsbl -0x1(%r15), %eax
movl %eax, (%r13)
jmp 0xb2d6
movq %r15, (%r12)
movsbl -0x1(%r15), %eax
leaq 0x11c5c(%rip), %rcx     # 0x1cf30
movl %eax, (%rcx)
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x5, 0x8(%rsp)
jle 0xb303
leaq 0x1c9d(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
movl %eax, %ebx
jmp 0xb2d6
movl 0x8e2f(%rip), %ebp      # 0x14138
testl %ebp, %ebp
je 0xb34d
leaq 0x40(%rsp), %r15
leaq 0x8e17(%rip), %rdi      # 0x14130
movq %r15, %rsi
callq 0x3060
testl %eax, %eax
je 0xb348
leaq 0x8e10(%rip), %r12      # 0x1413c
movl 0x8(%r12), %ebp
testl %ebp, %ebp
je 0xb34d
movq %r12, %rdi
movq %r15, %rsi
callq 0x3060
addq $0xc, %r12
testl %eax, %eax
jne 0xb32c
movl %ebp, (%r14)
jmp 0xb2d6
movl $0x0, (%r14)
movl $0x1, %ebx
jmp 0xb2d6