LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
movsbl %bl, %edi
callq 0x3323
leaq 0xc72b(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %edx
leal 0x2(%rdx), %ecx
movl %ecx, (%rax)
cmpl $0x8, %ebx
je 0x80ef
cmpl $0x28, %ebx
je 0x8117
cmpl $0x40, %ebx
je 0x8126
cmpl $0x48, %ebx
je 0x80ef
cmpl $0x5a, %ebx
je 0x80ef
cmpl $0x66, %ebx
je 0x8126
cmpl $0x68, %ebx
je 0x8117
cmpl $0x7a, %ebx
je 0x8117
cmpl $0xfa, %ebx
je 0x8117
cmpl $0xda, %ebx
jne 0x812b
addl $0x3, %edx
movl %edx, (%rax)
cmpl $0x28, %ebx
je 0x8115
cmpl $0x40, %ebx
je 0x8111
cmpl $0x66, %ebx
je 0x8111
cmpl $0x7a, %ebx
je 0x8115
movl %edx, %ecx
cmpl $0x68, %ebx
je 0x8117
jmp 0x812b
movl %edx, %ecx
jmp 0x8126
movl %edx, %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
cmpl $0x66, %ebx
je 0x8126
cmpl $0x40, %ebx
jne 0x812b
addl $0x6, %ecx
movl %ecx, (%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/42Bastian[P]lyxass/mnemonics.c
// Function: op9
int op9(int op)
{
  int err;
  int32_t l;
  int flag = 0;
  int brace = 0;

  if ( TestAtom('#') ){

    if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
    if ( l < -128 || l > 255 ) return Error(BYTE_ERR,"");
    CYCLES += 2;
    writeConstByte(op);
    writeByte((char)l);
  } else {
    brace = atom == '(';
    if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
    if ( brace && last_atom == ')' ){
      Warning("LDX (n) translates to LDX n\n");
    }

    if ( l < 0 || l > 65535 ) return Error(WORD_ERR,"");
    CYCLES += 3;
    op |= 0x04;
    if ( l > 255 || err == EXPR_UNSOLVED || Current.pass2 ){
      op |= 0x08;
      flag = 1;
      ++CYCLES;
    }
    if ( TestAtom(',') ){
      if ( !TestAtomOR('y','Y') ) return Error(SYNTAX_ERR,"");
      op |= 0x10;
      ++CYCLES;
    }

    writeConstByte(op);
    if ( flag ){
      writeWordLittle((short)l);
    } else {
      writeByte((char)l);
    }
  }
  if ( err == EXPR_UNSOLVED ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
pushq $0x23
popq %rdi
callq 0x4da7
testl %eax, %eax
je 0x8170
leaq 0x4(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
je 0x8189
movl %eax, %ebx
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
addl 0x4(%rsp), %eax
cmpl $0xfffffe7f, %eax       # imm = 0xFFFFFE7F
ja 0x81d1
leaq 0x3e26(%rip), %rsi      # 0xbf92
pushq $0x1a
jmp 0x81c4
leaq 0x14db9(%rip), %rax     # 0x1cf30
movl (%rax), %r14d
leaq 0x4(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
jne 0x8191
pushq $0x1
popq %rbp
jmp 0x8293
movl %eax, %ebx
cmpl $0x28, %r14d
jne 0x81b1
leaq 0x14d94(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x81b1
leaq 0x42db(%rip), %rdi      # 0xc487
callq 0x9cd8
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x820a
leaq 0x3dd0(%rip), %rsi      # 0xbf92
pushq $0x1b
popq %rdi
callq 0x96cc
movl %eax, %ebp
jmp 0x8293
leaq 0xc600(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x2, (%rax)
movsbl %bpl, %edi
callq 0x3323
movsbl 0x4(%rsp), %edi
callq 0x33cf
xorl %ebp, %ebp
cmpl $0x2, %ebx
jne 0x8293
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x960c
jmp 0x8293
leaq 0xc5c7(%rip), %r15      # 0x147d8
movq (%r15), %rax
movl (%rax), %ecx
leal 0x3(%rcx), %edx
movl %edx, (%rax)
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
setl %dl
cmpl $0x2, %ebx
setne %sil
andb %dl, %sil
leaq 0xc3d1(%rip), %rdx      # 0x14608
cmpl $0x0, 0xe4(%rdx)
sete %r14b
andb %sil, %r14b
je 0x824c
orl $0x4, %ebp
jmp 0x8254
orl $0xc, %ebp
addl $0x4, %ecx
movl %ecx, (%rax)
pushq $0x2c
popq %rdi
callq 0x4da7
testl %eax, %eax
je 0x8277
pushq $0x79
popq %rdi
pushq $0x59
popq %rsi
callq 0x4dd8
testl %eax, %eax
je 0x82ad
orl $0x10, %ebp
movq (%r15), %rax
incl (%rax)
movsbl %bpl, %edi
callq 0x3323
movl 0x4(%rsp), %eax
testb %r14b, %r14b
je 0x82a0
movsbl %al, %edi
callq 0x33cf
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movswl %ax, %edi
callq 0x34fb
jmp 0x81f1
leaq 0x3cde(%rip), %rsi      # 0xbf92
pushq $0x12
jmp 0x81c4
// File: /workspace/github_c_makefile_star2_O2/42Bastian[P]lyxass/mnemonics.c
// Function: opc
int opc(int op)
{
  int err;
  int32_t l;
  int saveCYCLES;
  int saveOp;

  saveOp = op;
  saveCYCLES = CYCLES;
  SavePosition();

  if ( TestAtom('(') ){
    if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
    if ( l < 0 || l > 65535 ) return Error(WORD_ERR,"");
    op |= 0x20;
    if ( TestAtom(',') ){
      if ( !TestAtomOR('x','X') ) return Error(SYNTAX_ERR,"");
      op |= 0x10;
    }
    if ( !TestAtom(')') ) return Error(SYNTAX_ERR,"");
    KillSpace();
    if ( atom == 0 ){
      CYCLES += 6;
      writeConstByte(op);
      writeWordLittle((short)l);
      if ( err == EXPR_UNSOLVED ) saveCurrentLine();
      return 0;
    } else {
      // Possible not indirect but expression with braces
      op = saveOp;
      CYCLES = saveCYCLES;
      RestorePosition();
    }
  }
  if ( (err = Expression( &l )) == EXPR_ERROR ) return 1;
  if ( l < 0 || l > 65535 ) return Error(WORD_ERR,"");
  if ( err != EXPR_UNSOLVED ){
    int dist = Global.pc - l - 2;
    if ( dist >= -128 && dist <= 127 ) Warning("JMP can be changed into BRA !\n");
  }
  CYCLES += 3;

  writeConstByte(op);
  writeWordLittle((short)l);
  if ( err == EXPR_UNSOLVED ) saveCurrentLine();
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xc509(%rip), %r15      # 0x147d8
movq (%r15), %rax
movl (%rax), %r12d
callq 0x4d82
pushq $0x28
popq %rdi
callq 0x4da7
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x8366
leaq 0x4(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
je 0x83bf
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jae 0x8381
movl %eax, %r14d
pushq $0x2c
popq %rdi
callq 0x4da7
testl %eax, %eax
je 0x8331
pushq $0x78
popq %rdi
pushq $0x58
popq %rsi
callq 0x4dd8
testl %eax, %eax
je 0x83ae
movl %ebx, %r13d
orl $0x30, %r13d
jmp 0x8338
movl %ebx, %r13d
orl $0x20, %r13d
pushq $0x29
popq %rdi
callq 0x4da7
testl %eax, %eax
je 0x83ae
xorl %eax, %eax
callq 0x4dc3
leaq 0x14bde(%rip), %rax     # 0x1cf30
cmpl $0x0, (%rax)
movq (%r15), %rax
je 0x840d
movl %r12d, (%rax)
callq 0x4d94
leaq 0x4(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
je 0x83bf
movl 0x4(%rsp), %ecx
cmpl $0x10000, %ecx          # imm = 0x10000
jb 0x838c
leaq 0x3c0a(%rip), %rsi      # 0xbf92
pushq $0x1b
jmp 0x83b7
cmpl $0x2, %eax
jne 0x83d0
movq (%r15), %rax
addl $0x3, (%rax)
movsbl %bl, %edi
callq 0x3323
movswl 0x4(%rsp), %edi
callq 0x34fb
jmp 0x842e
leaq 0x3bdd(%rip), %rsi      # 0xbf92
pushq $0x12
popq %rdi
callq 0x96cc
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbfd9(%rip), %rax      # 0x143b0
movl (%rax), %eax
subl %ecx, %eax
addl $0x7e, %eax
cmpl $0xff, %eax
ja 0x83f1
leaq 0x40b8(%rip), %rdi      # 0xc4a4
callq 0x9cd8
movq (%r15), %rax
addl $0x3, (%rax)
movsbl %bl, %edi
callq 0x3323
movswl 0x4(%rsp), %edi
callq 0x34fb
xorl %ebp, %ebp
jmp 0x83bf
addl $0x6, (%rax)
movsbl %r13b, %edi
callq 0x3323
movswl 0x4(%rsp), %edi
callq 0x34fb
movl $0x0, %ebp
cmpl $0x2, %r14d
jne 0x83bf
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x960c
jmp 0x83bf
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x4(%rsp), %rdi
callq 0x929a
cmpl $0x11, %eax
jne 0x8452
pushq $0x1
popq %rax
jmp 0x849d
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x846d
leaq 0x3b2f(%rip), %rsi      # 0xbf92
pushq $0x1b
popq %rdi
callq 0x96cc
jmp 0x849d
movl %eax, %ebx
movsbl %bpl, %edi
callq 0x3323
movswl 0x4(%rsp), %edi
callq 0x34fb
cmpl $0x2, %ebx
jne 0x848e
xorl %eax, %eax
callq 0x960c
leaq 0xc343(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x6, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x4(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
jne 0x84bd
pushq $0x1
popq %rbp
jmp 0x84ff
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
jb 0x84da
leaq 0x3ac4(%rip), %rsi      # 0xbf92
pushq $0x1a
popq %rdi
callq 0x96cc
movl %eax, %ebp
jmp 0x84ff
movl %eax, %ebx
movsbl %bpl, %edi
callq 0x3323
movsbl 0x4(%rsp), %edi
callq 0x33cf
xorl %ebp, %ebp
cmpl $0x2, %ebx
jne 0x84ff
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x960c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorl %eax, %eax
callq 0x4dc3
leaq 0x14a10(%rip), %rax     # 0x1cf30
movl (%rax), %r14d
leaq 0xc(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
jne 0x853a
pushq $0x1
popq %rbx
jmp 0x8640
movl %eax, %ebp
cmpl $0x28, %r14d
jne 0x855a
leaq 0x149eb(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x855a
leaq 0x3ecb(%rip), %rdi      # 0xc420
callq 0x9cd8
cmpl $0x10000, 0xc(%rsp)     # imm = 0x10000
jb 0x856f
leaq 0x3a27(%rip), %rsi      # 0xbf92
pushq $0x1b
jmp 0x85ae
pushq $0x2c
popq %rdi
callq 0x4da7
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
setge %cl
cmpl $0x2, %ebp
sete %dl
orb %cl, %dl
leaq 0xc077(%rip), %rcx      # 0x14608
cmpl $0x0, 0xe4(%rcx)
setne %cl
orb %dl, %cl
testl %eax, %eax
je 0x85bb
testb %cl, %cl
je 0x85f7
leaq 0x39e6(%rip), %rsi      # 0xbf92
pushq $0x1a
popq %rdi
callq 0x96cc
movl %eax, %ebx
jmp 0x8640
leaq 0xc216(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %edx
testb %cl, %cl
je 0x8627
addl $0x4, %edx
movl %edx, (%rax)
orb $0x8, %bl
movsbl %bl, %edi
callq 0x3323
movswl 0xc(%rsp), %edi
callq 0x34fb
xorl %ebx, %ebx
cmpl $0x2, %ebp
jne 0x8640
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x960c
jmp 0x8640
pushq $0x79
popq %rdi
pushq $0x59
popq %rsi
callq 0x4dd8
testl %eax, %eax
jne 0x8615
leaq 0x3985(%rip), %rsi      # 0xbf92
pushq $0x12
popq %rdi
callq 0x96cc
leaq 0xc1bc(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
orb $0x10, %bl
jmp 0x862c
addl $0x3, %edx
movl %edx, (%rax)
movsbl %bl, %edi
callq 0x3323
movsbl 0xc(%rsp), %edi
callq 0x33cf
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorl %eax, %eax
callq 0x4dc3
leaq 0x148cd(%rip), %rax     # 0x1cf30
movl (%rax), %r14d
leaq 0xc(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
jne 0x867d
pushq $0x1
popq %rbx
jmp 0x8783
movl %eax, %ebp
cmpl $0x28, %r14d
jne 0x869d
leaq 0x148a8(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x869d
leaq 0x3da5(%rip), %rdi      # 0xc43d
callq 0x9cd8
cmpl $0x10000, 0xc(%rsp)     # imm = 0x10000
jb 0x86b2
leaq 0x38e4(%rip), %rsi      # 0xbf92
pushq $0x1b
jmp 0x86f1
pushq $0x2c
popq %rdi
callq 0x4da7
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
setge %cl
cmpl $0x2, %ebp
sete %dl
orb %cl, %dl
leaq 0xbf34(%rip), %rcx      # 0x14608
cmpl $0x0, 0xe4(%rcx)
setne %cl
orb %dl, %cl
testl %eax, %eax
je 0x86fe
testb %cl, %cl
je 0x873a
leaq 0x38a3(%rip), %rsi      # 0xbf92
pushq $0x1a
popq %rdi
callq 0x96cc
movl %eax, %ebx
jmp 0x8783
leaq 0xc0d3(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %edx
testb %cl, %cl
je 0x876a
addl $0x4, %edx
movl %edx, (%rax)
orb $0x8, %bl
movsbl %bl, %edi
callq 0x3323
movswl 0xc(%rsp), %edi
callq 0x34fb
xorl %ebx, %ebx
cmpl $0x2, %ebp
jne 0x8783
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x960c
jmp 0x8783
pushq $0x78
popq %rdi
pushq $0x58
popq %rsi
callq 0x4dd8
testl %eax, %eax
jne 0x8758
leaq 0x3842(%rip), %rsi      # 0xbf92
pushq $0x12
popq %rdi
callq 0x96cc
leaq 0xc079(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
orb $0x10, %bl
jmp 0x876f
addl $0x3, %edx
movl %edx, (%rax)
movsbl %bl, %edi
callq 0x3323
movsbl 0xc(%rsp), %edi
callq 0x33cf
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
xorl %eax, %eax
callq 0x4dc3
leaq 0x1478a(%rip), %rax     # 0x1cf30
movl (%rax), %r14d
leaq 0xc(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
jne 0x87c0
pushq $0x1
popq %rbx
jmp 0x8917
movl %eax, %ebx
cmpl $0x28, %r14d
jne 0x87e0
leaq 0x14765(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x87e0
leaq 0x3c28(%rip), %rdi      # 0xc403
callq 0x9cd8
cmpl $0x10000, 0xc(%rsp)     # imm = 0x10000
jb 0x8800
leaq 0x37a1(%rip), %rsi      # 0xbf92
pushq $0x1b
popq %rdi
callq 0x96cc
movl %eax, %ebx
jmp 0x8917
pushq $0x2c
popq %rdi
callq 0x4da7
testl %eax, %eax
je 0x8876
pushq $0x78
popq %rdi
pushq $0x58
popq %rsi
callq 0x4dd8
testl %eax, %eax
jne 0x882a
leaq 0x3770(%rip), %rsi      # 0xbf92
pushq $0x12
popq %rdi
callq 0x96cc
cmpl $0x2, %ebx
je 0x88bb
cmpl $0xff, 0xc(%rsp)
jg 0x88bb
leaq 0xbdc4(%rip), %rax      # 0x14608
cmpl $0x0, 0xe4(%rax)
jne 0x88bb
orb $0x70, %bpl
movsbl %bpl, %edi
callq 0x3323
movsbl 0xc(%rsp), %edi
callq 0x33cf
leaq 0xbf6d(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
jmp 0x8915
cmpl $0x2, %ebx
je 0x88e1
cmpl $0xff, 0xc(%rsp)
jg 0x88e1
leaq 0xbd7c(%rip), %rax      # 0x14608
cmpl $0x0, 0xe4(%rax)
jne 0x88e1
orb $0x60, %bpl
movsbl %bpl, %edi
callq 0x3323
movsbl 0xc(%rsp), %edi
callq 0x33cf
leaq 0xbf25(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x3, (%rax)
jmp 0x8915
orb $-0x66, %bpl
movsbl %bpl, %edi
callq 0x3323
movswl 0xc(%rsp), %edi
callq 0x34fb
leaq 0xbeff(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x5, (%rax)
jmp 0x8905
orb $-0x68, %bpl
movsbl %bpl, %edi
callq 0x3323
movswl 0xc(%rsp), %edi
callq 0x34fb
leaq 0xbed9(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
cmpl $0x2, %ebx
jne 0x8915
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x960c
jmp 0x8917
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4(%rsp), %rdi
callq 0x929a
cmpl $0x1, %eax
jne 0x893e
pushq $0x1
popq %rbx
jmp 0x89cd
movl 0x4(%rsp), %edx
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x895d
leaq 0x3641(%rip), %rsi      # 0xbf92
pushq $0x1b
popq %rdi
callq 0x96cc
movl %eax, %ebx
jmp 0x89cd
movl %eax, %ebp
leaq 0xbe72(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %ecx
cmpl $0x2, %ebp
je 0x89a3
cmpl $0xff, %edx
ja 0x89a3
leaq 0xbc89(%rip), %rdx      # 0x14608
cmpl $0x0, 0xe4(%rdx)
jne 0x89a3
addl $0x5, %ecx
movl %ecx, (%rax)
movsbl %bl, %edi
callq 0x3323
movsbl 0x4(%rsp), %edi
callq 0x33cf
xorl %ebx, %ebx
jmp 0x89cd
addl $0x6, %ecx
movl %ecx, (%rax)
orb $0x8, %bl
movsbl %bl, %edi
callq 0x3323
movswl 0x4(%rsp), %edi
callq 0x34fb
xorl %ebx, %ebx
cmpl $0x2, %ebp
jne 0x89cd
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x960c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbc12(%rip), %rax      # 0x14608
xorl %ebx, %ebx
cmpl $0x0, 0xf8(%rax)
je 0x8a54
cmpl $0x0, 0x188(%rax)
je 0x8a54
movq %rdi, %rsi
leaq 0xbbdc(%rip), %rax      # 0x145f0
cmpl $0x1, (%rax)
jne 0x8a22
leaq 0x8f50(%rip), %rdi      # 0x11970
jmp 0x8a29
leaq 0x9be7(%rip), %rdi      # 0x12610
callq 0x5ed0
testl %eax, %eax
js 0x8a51
callq 0x546c
testl %eax, %eax
je 0x8a54
leaq 0x144de(%rip), %rax     # 0x1cf20
movq (%rax), %rsi
pushq $0x18
popq %rdi
callq 0x96cc
pushq $0x1
jmp 0x8a53
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r15d, %r15d
callq 0x31e0
movq %rax, %r14
leaq 0x144bb(%rip), %r12     # 0x1cf30
xorl %ebp, %ebp
movq (%r14), %rcx
movslq (%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
je 0x8a9a
imulq $0xa, %r15, %rcx
leaq (%rcx,%rax), %r15
addq $-0x30, %r15
callq 0x4d44
incl %ebp
jmp 0x8a77
testl %ebp, %ebp
je 0x8ac8
testq %r15, %r15
sets %al
cmpl $0x15, %ebp
setae %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x8adb
andl $0x0, (%rbx)
leaq 0x34d7(%rip), %rsi      # 0xbf92
pushq $0x10
popq %rdi
callq 0x96cc
pushq $0x1
popq %rbx
jmp 0x8ae0
leaq 0x34c3(%rip), %rsi      # 0xbf92
pushq $0x11
popq %rbx
movl %ebx, %edi
callq 0x96cc
jmp 0x8ae0
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_O2/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
xorl %r15d, %r15d
callq 0x31e0
movq %rax, %r14
leaq 0x14428(%rip), %r12     # 0x1cf30
xorl %ebp, %ebp
movq (%r14), %rcx
movslq (%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
je 0x8b2d
imulq $0xa, %r15, %rcx
leaq (%rcx,%rax), %r15
addq $-0x30, %r15
callq 0x4d44
incl %ebp
jmp 0x8b0a
testl %ebp, %ebp
je 0x8b5c
testq %r15, %r15
sets %al
cmpl $0x15, %ebp
setae %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x8b6f
andq $0x0, (%rbx)
leaq 0x3443(%rip), %rsi      # 0xbf92
pushq $0x10
popq %rdi
callq 0x96cc
pushq $0x1
popq %rbx
jmp 0x8b74
leaq 0x342f(%rip), %rsi      # 0xbf92
pushq $0x11
popq %rbx
movl %ebx, %edi
callq 0x96cc
jmp 0x8b74
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_O2/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 0x1439c(%rip), %r15     # 0x1cf30
movabsq $0x3f0000003f, %r12     # imm = 0x3F0000003F
xorl %ebp, %ebp
movl (%r15), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x8bb9
leal -0x41(%rax), %ecx
cmpl $0x25, %ecx
ja 0x8be2
btq %rcx, %r12
jae 0x8be2
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 0x4d44
incl %ebp
jmp 0x8ba0
testl %ebp, %ebp
je 0x8c03
cmpl $0x11, %ebp
jb 0x8c16
andq $0x0, (%rbx)
leaq 0x339c(%rip), %rsi      # 0xbf92
pushq $0x10
popq %rdi
callq 0x96cc
pushq $0x1
popq %rbx
jmp 0x8c1b
leaq 0x3388(%rip), %rsi      # 0xbf92
pushq $0x11
popq %rbx
movl %ebx, %edi
callq 0x96cc
jmp 0x8c1b
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_O2/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
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x142f6(%rip), %r15     # 0x1cf30
xorl %ebp, %ebp
movl (%r15), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x30, %ecx
jne 0x8c5a
leaq (%rax,%r14,2), %r14
addq $-0x30, %r14
callq 0x4d44
incl %ebp
jmp 0x8c3c
testl %ebp, %ebp
je 0x8c77
cmpl $0x41, %ebp
jb 0x8c8a
leaq 0x3328(%rip), %rsi      # 0xbf92
pushq $0x10
popq %rdi
callq 0x96cc
pushq $0x1
popq %rbx
jmp 0x8c8f
leaq 0x3314(%rip), %rsi      # 0xbf92
pushq $0x11
popq %rbx
movl %ebx, %edi
callq 0x96cc
jmp 0x8c8f
movq %r14, (%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_O2/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
andl $0x0, 0x8(%rsp)
leaq 0x15010(%rip), %rdi     # 0x1dcc0
callq 0x4fa0
testl %eax, %eax
je 0x8cbe
pushq $0x1
popq %rax
jmp 0x8d25
leaq 0x14ffb(%rip), %rdi     # 0x1dcc0
andb $-0x21, 0x14ff8(%rip)   # 0x1dcc4
leaq 0x8(%rsp), %rsi
callq 0x59a0
testq %rax, %rax
je 0x8ce5
movslq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x8d23
movl 0x14fd9(%rip), %eax     # 0x1dcc4
testb %al, %al
js 0x8cfa
orl $0x80, %eax
movl %eax, 0x14fca(%rip)     # 0x1dcc4
leaq 0x14fbf(%rip), %rdi     # 0x1dcc0
leaq 0xc(%rsp), %rsi
callq 0x55fd
leaq 0x13fde(%rip), %rcx     # 0x1ccf0
movq %rax, (%rcx)
andq $0x0, (%rbx)
movl $0x1, 0x14ffd(%rip)     # 0x1dd20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9018
testl %eax, %eax
je 0x8f76
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 0x4dc3
movq 0x10(%rsp), %r15
leaq 0x13fa2(%rip), %r12     # 0x1cf30
movq %rsp, %r14
movabsq $0x8000000000005, %r13  # imm = 0x8000000000005
movl (%r12), %ebx
leal -0x2b(%rbx), %eax
cmpl $0x33, %eax
ja 0x8fad
btq %rax, %r13
jb 0x8fb2
cmpl $0x7c, %ebx
jne 0x9009
callq 0x4d44
testl %eax, %eax
je 0x8ff3
movq %r14, %rdi
callq 0x9018
testl %eax, %eax
jne 0x8f63
cmpl $0x7c, %ebx
je 0x8fe1
cmpl $0x2d, %ebx
je 0x8fe7
cmpl $0x5e, %ebx
je 0x8fed
cmpl $0x2b, %ebx
jne 0x8f9b
addq (%rsp), %r15
jmp 0x8f9b
orq (%rsp), %r15
jmp 0x8f9b
subq (%rsp), %r15
jmp 0x8f9b
xorq (%rsp), %r15
jmp 0x8f9b
leaq 0x2f98(%rip), %rsi      # 0xbf92
pushq $0x11
popq %rbp
movl %ebp, %edi
callq 0x96cc
jmp 0x8f65
movq 0x8(%rsp), %rax
movq %r15, (%rax)
xorl %ebp, %ebp
jmp 0x8f65
// File: /workspace/github_c_makefile_star2_O2/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 0x8d2b
testl %eax, %eax
je 0x904a
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 0x4dc3
movq 0x10(%rsp), %r14
leaq 0x13ece(%rip), %r12     # 0x1cf30
movq %rsp, %r15
movabsq $0x844000000000, %r13   # imm = 0x844000000000
movl (%r12), %ebx
cmpq $0x2f, %rbx
ja 0x90d3
btq %rbx, %r13
jae 0x90d3
callq 0x4d44
testl %eax, %eax
je 0x9124
movl %ebx, %eax
andl $0xfd, %eax
cmpl $0x3c, %eax
jne 0x90a7
cmpl %ebx, (%r12)
jne 0x913a
callq 0x4d44
movq %r15, %rdi
callq 0x8d2b
testl %eax, %eax
jne 0x9037
cmpl $0x26, %ebx
je 0x9114
cmpl $0x3e, %ebx
je 0x90f6
cmpl $0x2f, %ebx
je 0x9106
cmpl $0x3c, %ebx
je 0x90fe
cmpl $0x2a, %ebx
jne 0x9118
imulq (%rsp), %r14
jmp 0x9118
movl %ebx, %ecx
xorl $0x3c, %ecx
leaq 0x13e59(%rip), %rax     # 0x1cf38
movl (%rax), %eax
movl %eax, %edx
xorl $0x3c, %edx
orl %ecx, %edx
je 0x907f
cmpl $0x3e, %ebx
jne 0x9151
cmpl $0x3e, %eax
je 0x907f
jmp 0x9151
movb (%rsp), %cl
sarq %cl, %r14
jmp 0x9118
movb (%rsp), %cl
shlq %cl, %r14
jmp 0x9118
movq %r14, %rax
cqto
idivq (%rsp)
movq %rax, %r14
jmp 0x9118
andq (%rsp), %r14
xorl %eax, %eax
callq 0x4dc3
jmp 0x906f
leaq 0x2e67(%rip), %rsi      # 0xbf92
pushq $0x11
popq %rbp
movl %ebp, %edi
callq 0x96cc
jmp 0x9039
leaq 0x2e51(%rip), %rsi      # 0xbf92
pushq $0x11
popq %rdi
callq 0x96cc
pushq $0x1
popq %rbp
jmp 0x9039
movq 0x8(%rsp), %rax
movq %r14, (%rax)
xorl %ebp, %ebp
jmp 0x9039
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdi)
andl $0x0, 0x14bac(%rip)     # 0x1dd20
leaq 0x10(%rsp), %rdi
callq 0x8f44
testl %eax, %eax
jne 0x925d
xorl %eax, %eax
callq 0x4dc3
leaq 0x13d9c(%rip), %rax     # 0x1cf30
movl (%rax), %eax
cmpl $0x3c, %eax
je 0x9206
cmpl $0x3e, %eax
je 0x91cd
cmpl $0x3d, %eax
jne 0x921c
callq 0x4d44
leaq 0x8(%rsp), %rdi
callq 0x8f44
testl %eax, %eax
jne 0x925d
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
cmpq 0x8(%rsp), %rax
sete %cl
jmp 0x9221
callq 0x4d44
pushq $0x3d
popq %rdi
callq 0x4da7
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x8f44
testl %eax, %eax
jne 0x925d
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x9282
cmpq %rdx, %rax
setge %cl
jmp 0x9221
callq 0x4d44
pushq $0x3d
popq %rdi
callq 0x4da7
testl %eax, %eax
je 0x923d
pushq $0x1
popq %rbp
jmp 0x924f
movq 0x10(%rsp), %rcx
movq %rcx, (%rbx)
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x0, 0x14af1(%rip)     # 0x1dd20
setne %al
cmoveq %rcx, %rdx
movq %rdx, (%rbx)
addl %eax, %eax
jmp 0x925d
pushq $0x3e
popq %rdi
callq 0x4da7
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
addl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x8f44
testl %eax, %eax
je 0x9264
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
cmpl $0x2, %ebp
je 0x928a
cmpl $0x1, %ebp
jne 0x9292
cmpq %rdx, %rax
setle %cl
jmp 0x9221
cmpq %rdx, %rax
setg %cl
jmp 0x9221
cmpq %rdx, %rax
setne %cl
jmp 0x9221
cmpq %rdx, %rax
setl %cl
jmp 0x9221
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rdi)
leaq 0x8(%rsp), %rdi
callq 0x9160
testl %eax, %eax
jne 0x92e7
movq 0x8(%rsp), %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
movabsq $-0x180000001, %rdx     # imm = 0xFFFFFFFE7FFFFFFF
cmpq %rdx, %rcx
ja 0x92e3
pushq $0x10
popq %rdi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
jmp 0x96cc
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x149ff(%rip), %ecx     # 0x1dd30
testl %ecx, %ecx
je 0x9359
leal 0x1(%rcx), %eax
movl %eax, 0x149f2(%rip)     # 0x1dd30
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0x93b5
leaq 0x2c46(%rip), %rsi      # 0xbf92
pushq $0x19
popq %rdi
callq 0x96cc
pushq $0x1
popq %rax
jmp 0x93b5
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, 0x149cb(%rip)     # 0x1dd30
callq 0x30b0
movl %eax, 0x149c8(%rip)     # 0x1dd38
leaq 0x149f9(%rip), %rdi     # 0x1dd70
movq %rbx, %rsi
callq 0x3070
leaq 0xb282(%rip), %rax      # 0x14608
movq (%rax), %rcx
movq 0x198(%rax), %rdx
movq %rcx, 0x149b1(%rip)     # 0x1dd48
andq $0x0, 0x149a1(%rip)     # 0x1dd40
movq %rdx, 0x149b2(%rip)     # 0x1dd58
movl $0x4, 0x1498c(%rip)     # 0x1dd3c
movl %ebp, 0xc(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14967(%rip)           # 0x1dd30
je 0x93d3
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb22e(%rip), %rax      # 0x14608
andl $0x0, 0xc(%rax)
leaq 0x14953(%rip), %rdi     # 0x1dd38
leaq 0xc(%rsp), %rsi
callq 0x55fd
testq %rax, %rax
je 0x940e
cmpl $0x0, 0xc(%rsp)
je 0x93cb
leaq 0x2b90(%rip), %rsi      # 0xbf92
pushq $0x12
popq %rdi
callq 0x96cc
movl %eax, %ebx
jmp 0x93cb
pushq $0x1
popq %rbx
jmp 0x93cb
// File: /workspace/github_c_makefile_star2_O2/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 0x4dc3
movq %rbx, %r14
testl %eax, %eax
je 0x9495
leaq 0x13afb(%rip), %r15     # 0x1cf30
xorl %r12d, %r12d
movq %rbx, %r14
movl (%r15), %eax
cmpl $0x20, %eax
je 0x947a
cmpl $0x22, %eax
je 0x9475
cmpl $0x2c, %eax
je 0x9462
cmpl $0x3b, %eax
je 0x9462
cmpl $0x7b, %eax
je 0x946b
cmpl $0x7d, %eax
je 0x9470
testl %eax, %eax
jne 0x9481
jmp 0x9495
movl %ebp, %ecx
orl %r12d, %ecx
jne 0x9481
jmp 0x9495
incl %r12d
jmp 0x9487
decl %r12d
jmp 0x9487
xorl $0x1, %ebp
jmp 0x9481
movl %ebp, %ecx
orl %r12d, %ecx
je 0x948e
movb %al, (%r14)
incq %r14
callq 0x4d44
jmp 0x943b
xorl %ebp, %ebp
xorl %r12d, %r12d
jmp 0x9487
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_O2/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 $0x1d8, %rsp            # imm = 0x1D8
leaq 0xb146(%rip), %rax      # 0x14608
xorl %ebp, %ebp
cmpl $0x0, 0xf8(%rax)
je 0x95f8
cmpl $0x0, 0x188(%rax)
je 0x95f8
movq %rdi, %r14
leaq 0x13a48(%rip), %r15     # 0x1cf30
movl (%r15), %ebp
leaq 0xb116(%rip), %rbx      # 0x14608
leaq 0x18(%rsp), %rdi
movl $0x1c0, %edx            # imm = 0x1C0
movq %rbx, %rsi
callq 0x3150
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x5a34
testl %eax, %eax
je 0x951d
pushq $-0x1
popq %rbp
jmp 0x95f8
movl %ebp, 0xc(%rsp)
movq (%rbx), %rax
movq %rax, 0x10(%rbx)
movq 0x10(%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
imulq $0x500, %rax, %rdi      # imm = 0x500
leaq 0x1483c(%rip), %r14     # 0x1dda0
addq %r14, %rdi
xorl %r13d, %r13d
movl $0x500, %edx            # imm = 0x500
xorl %esi, %esi
callq 0x30d0
pushq $0x2c
popq %rbp
movl %r13d, %r12d
movslq 0x8(%rbx), %rax
movl %r13d, %ecx
imulq $0x500, %rax, %rax      # imm = 0x500
imulq $0x50, %rcx, %rdi
addq %r14, %rdi
addq %rax, %rdi
callq 0x9413
testl %eax, %eax
setne %al
cmpl $0x2c, (%r15)
sete %cl
orb %al, %cl
movzbl %cl, %r13d
addl %r12d, %r13d
movl %ebp, %edi
callq 0x4da7
testl %eax, %eax
je 0x95bf
cmpl $0x11, %r13d
jb 0x9579
movl %r13d, 0x20(%rbx)
incl 0x8(%rbx)
xorl %eax, %eax
callq 0x5a7f
leaq 0xadc4(%rip), %rax      # 0x14398
incl (%rax)
xorl %edi, %edi
callq 0x41f5
movl %eax, %ebp
leaq 0x18(%rsp), %rsi
movl $0x1c0, %edx            # imm = 0x1C0
movq %rbx, %rdi
callq 0x3150
movl 0xc(%rsp), %eax
movl %eax, (%r15)
movl %ebp, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13809(%rip), %r14     # 0x1ce20
movq %r14, %rdi
callq 0x30b0
leaq 0x51(%rax), %rdi
callq 0x32ec
movq %rax, %rbx
leaq 0x48(%rax), %rdi
movq %r14, %rsi
callq 0x3070
leaq 0xafca(%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 0xad4a(%rip), %rax      # 0x143b0
movl 0x4(%rax), %eax
movl %eax, 0x10(%rbx)
leaq 0xaf5d(%rip), %rax      # 0x145d0
movq 0x18(%rax), %rax
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x13668(%rip), %rax     # 0x1ccf0
movq (%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0xaf5a(%rip), %rax      # 0x145f0
movl (%rax), %eax
movl %eax, 0x30(%rbx)
cmpq $0x0, 0x196fd(%rip)     # 0x22da0
je 0x96b2
movq 0x196fc(%rip), %rax     # 0x22da8
movq %rax, 0x8(%rbx)
jmp 0x96b9
leaq 0x196e7(%rip), %rax     # 0x22da0
movq %rbx, (%rax)
movq %rbx, 0x196e5(%rip)     # 0x22da8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xa6b5(%rip), %rax      # 0x14394
incl (%rax)
leaq 0xa690(%rip), %rax      # 0x14378
cmpl $0x0, (%rax)
setne %dl
leaq 0xa913(%rip), %rax      # 0x14608
movl 0x4(%rax), %ecx
testl %ecx, %ecx
setns %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x9d69
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %ecx, %edx
movl (%rax), %ecx
movl 0x10(%rax), %r8d
imulq $0x204, %rdx, %rdx      # imm = 0x204
leaq 0xa8d3(%rip), %rsi      # 0x145f8
movq (%rsi), %rdi
leaq 0xaab1(%rip), %rsi      # 0x147e0
addq %rsi, %rdx
addq $0x4, %rdx
testl %r8d, %r8d
je 0x9d6a
movslq 0x14(%rax), %rax
imulq $0x204, %rax, %rax      # imm = 0x204
leaq (%rsi,%rax), %r9
addq $0x4, %r9
leaq 0x130cb(%rip), %rax     # 0x1ce20
movq %rax, (%rsp)
leaq 0x2da5(%rip), %rsi      # 0xcb05
xorl %eax, %eax
callq 0x3130
jmp 0x9d7f
retq
leaq 0x2dbe(%rip), %rsi      # 0xcb2f
leaq 0x130a8(%rip), %r8      # 0x1ce20
xorl %eax, %eax
callq 0x3130
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3080
// File: /workspace/github_c_makefile_star2_O2/42Bastian[P]lyxass/jaguar.c
// Function: GetRegister
int GetRegister(int *reg)
{
  label_t regL;
  label_t *regL2;
  int32_t solved;
  char *p;

  *reg = -1;

  KillSpace();

  if ( (atom == 'r' || atom == 'R') && isdigit(next_atom) ){
    int32_t l;
    GetAtom();
    if ( getdec32(&l) == EXPR_ERR ) return Error(REG_ERR,"");
    if ( l > 31 ) return Error(REG_ERR,"");
    *reg = (int)l;
    return 0;
  }

  p = srcLinePtr - 1;

  if ( GetLabel(&regL) ) return 1;

  if ( (regL2 = FindLabel(&regL, &solved)) == NULL ){
#if 0 /* allow pass 2 resolving */
    return -1;
#else
    return Error(REG_ERR,"");
#endif
  }

  if (regL2->type != REGISTER ) return -1;

  if (regL2->value == -1 ) return Error(REG_ERR,"");

  if ( regL2->len > 2 ){
    *p++ = 'r';
    *p++ = (char)(regL2->value / 10 + '0');
    *p++ = (char)(regL2->value % 10 + '0');
    *p++ = atom;
    memmove(p,srcLinePtr,strlen(srcLinePtr)+1);
  } else {
    memmove(p+4,srcLinePtr,strlen(srcLinePtr)+1);
    *p++ = 'r';
    *p++ = (char)(regL2->value / 10 + '0');
    *p++ = (char)(regL2->value % 10 + '0');
    *p++ = atom;
  }
  srcLinePtr = p;
  next_atom = *p;

  *reg = (int)regL2->value;

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
orl $-0x1, (%rdi)
xorl %eax, %eax
callq 0x4dc3
leaq 0x12f83(%rip), %r12     # 0x1cf30
movl (%r12), %eax
andl $-0x21, %eax
cmpl $0x52, %eax
jne 0x9fd6
callq 0x31e0
movq (%rax), %rax
leaq 0x12f70(%rip), %rcx     # 0x1cf38
movslq (%rcx), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0xa07f
leaq 0x12f43(%rip), %rbp     # 0x1cf20
movq (%rbp), %r14
leaq 0x18(%rsp), %rdi
callq 0x4fa0
testl %eax, %eax
je 0x9ff7
pushq $0x1
popq %rax
jmp 0xa12a
leaq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x59a0
testq %rax, %rax
je 0xa0a0
movq %rax, %r15
cmpl $0x40, 0x4(%rax)
jne 0xa0b1
cmpq $-0x1, 0x8(%r15)
je 0xa0a0
cmpl $0x3, (%r15)
jl 0xa0b8
movb $0x72, -0x1(%r14)
movq 0x8(%r15), %rax
pushq $0xa
popq %rcx
cqto
idivq %rcx
addb $0x30, %al
movb %al, (%r14)
movq 0x8(%r15), %rax
cqto
idivq %rcx
addb $0x30, %dl
movb %dl, 0x1(%r14)
movb (%r12), %al
movb %al, 0x2(%r14)
addq $0x3, %r14
movq (%rbp), %r12
movq %r12, %rdi
callq 0x30b0
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3180
jmp 0xa111
callq 0x4d44
leaq 0x18(%rsp), %rdi
callq 0x8a58
cmpl $0x11, %eax
je 0xa0a0
movl 0x18(%rsp), %eax
cmpl $0x20, %eax
jl 0xa126
leaq 0x1eeb(%rip), %rsi      # 0xbf92
pushq $0x2c
popq %rdi
callq 0x96cc
jmp 0xa12a
pushq $-0x1
jmp 0x9ff1
leaq 0x3(%r14), %rax
movq %rax, 0x8(%rsp)
movq (%rbp), %r13
movq %r13, %rdi
callq 0x30b0
leaq 0x1(%rax), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3180
movb $0x72, -0x1(%r14)
movq 0x8(%r15), %rax
pushq $0xa
popq %rcx
cqto
idivq %rcx
addb $0x30, %al
movb %al, (%r14)
movq 0x8(%r15), %rax
cqto
idivq %rcx
addb $0x30, %dl
movb %dl, 0x1(%r14)
movb (%r12), %al
movb %al, 0x2(%r14)
movq 0x8(%rsp), %r14
movq %r14, (%rbp)
movsbl (%r14), %eax
leaq 0x12e18(%rip), %rcx     # 0x1cf38
movl %eax, (%rcx)
movl 0x8(%r15), %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9f8b
testl %eax, %eax
je 0xa163
pushq $0x1
popq %rax
jmp 0xa180
cmpl $0x40, %ebx
jne 0xa16f
movl $0xfc20, %ebx           # imm = 0xFC20
jmp 0xa172
shll $0xa, %ebx
orl 0xc(%rsp), %ebx
movswl %bx, %edi
callq 0x9d8c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq