LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xbac3(%rip), %r15      # 0x147d8
movq (%r15), %rax
movl (%rax), %r12d
callq 0x4f53
movl $0x28, %edi
callq 0x4fa3
testl %eax, %eax
je 0x8dc3
leaq 0x4(%rsp), %rdi
callq 0x9e70
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x8e90
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jae 0x8de9
movl %eax, %ebp
movl $0x2c, %edi
callq 0x4fa3
testl %eax, %eax
je 0x8d89
movl $0x78, %edi
movl $0x58, %esi
callq 0x5083
testl %eax, %eax
je 0x8e16
movl %ebx, %r13d
orl $0x30, %r13d
jmp 0x8d90
movl %ebx, %r13d
orl $0x20, %r13d
movl $0x29, %edi
callq 0x4fa3
testl %eax, %eax
je 0x8e16
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x5037
leaq 0x14181(%rip), %rax     # 0x1cf30
cmpl $0x0, (%rax)
movq (%r15), %rax
je 0x8e6b
movl %r12d, (%rax)
callq 0x4f65
leaq 0x4(%rsp), %rdi
callq 0x9e70
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x8e90
movl %eax, %ebp
movl 0x4(%rsp), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x8df7
leaq 0x41a2(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
jmp 0x8e22
cmpl $0x2, %ebp
jne 0x8e2c
movq (%r15), %rax
addl $0x3, (%rax)
movsbl %bl, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
jmp 0x8e86
leaq 0x4175(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
movl %eax, %r14d
jmp 0x8e90
leaq 0xb57d(%rip), %rcx      # 0x143b0
movl (%rcx), %ecx
subl %eax, %ecx
addl $0x7e, %ecx
cmpl $0xff, %ecx
ja 0x8e4e
leaq 0x465b(%rip), %rdi      # 0xd4a4
callq 0xa900
movq (%r15), %rax
addl $0x3, (%rax)
movsbl %bl, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
xorl %r14d, %r14d
jmp 0x8e81
addl $0x6, (%rax)
movsbl %r13b, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
cmpl $0x2, %ebp
jne 0x8e90
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa204
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e70
movl %eax, %ebx
movl $0x1, %eax
cmpl $0x11, %ebx
je 0x8f08
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x8eda
leaq 0x40c4(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
callq 0xa2c8
jmp 0x8f08
movsbl %bpl, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
cmpl $0x2, %ebx
jne 0x8ef9
xorl %eax, %eax
callq 0xa204
leaq 0xb8d8(%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_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %r14d
leaq 0xc(%rsp), %rdi
callq 0x9e70
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x8f72
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
jb 0x8f4d
leaq 0x4053(%rip), %rsi      # 0xcf92
movl $0x1a, %edi
callq 0xa2c8
movl %eax, %ebp
jmp 0x8f72
movl %eax, %ebx
movsbl %r14b, %edi
callq 0x3348
movsbl 0xc(%rsp), %edi
callq 0x33fe
xorl %ebp, %ebp
cmpl $0x2, %ebx
jne 0x8f72
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xa204
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebp
xorl %eax, %eax
callq 0x5037
leaq 0x13f9c(%rip), %rax     # 0x1cf30
movl (%rax), %r15d
leaq 0x4(%rsp), %rdi
callq 0x9e70
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x90c8
movl %eax, %ebx
cmpl $0x28, %r15d
jne 0x8fd0
leaq 0x13f75(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x8fd0
leaq 0x4455(%rip), %rdi      # 0xd420
callq 0xa900
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x8fe8
leaq 0x3fb1(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
jmp 0x902c
movl $0x2c, %edi
callq 0x4fa3
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
setge %cl
cmpl $0x2, %ebx
sete %dl
orb %cl, %dl
leaq 0xb5fc(%rip), %rcx      # 0x14608
cmpl $0x0, 0xe4(%rcx)
setne %cl
orb %dl, %cl
testl %eax, %eax
je 0x9039
testb %cl, %cl
je 0x9067
leaq 0x3f6b(%rip), %rsi      # 0xcf92
movl $0x1a, %edi
callq 0xa2c8
movl %eax, %r14d
jmp 0x90c8
leaq 0xb798(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %edx
testb %cl, %cl
je 0x909e
addl $0x4, %edx
movl %edx, (%rax)
orb $0x8, %bpl
movsbl %bpl, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
jmp 0x90b6
movl $0x79, %edi
movl $0x59, %esi
callq 0x5083
testl %eax, %eax
jne 0x908b
leaq 0x3f11(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
leaq 0xb746(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
orb $0x10, %bpl
jmp 0x90a3
addl $0x3, %edx
movl %edx, (%rax)
movsbl %bpl, %edi
callq 0x3348
movsbl 0x4(%rsp), %edi
callq 0x33fe
xorl %r14d, %r14d
cmpl $0x2, %ebx
jne 0x90c8
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa204
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebp
xorl %eax, %eax
callq 0x5037
leaq 0x13e43(%rip), %rax     # 0x1cf30
movl (%rax), %r15d
leaq 0x4(%rsp), %rdi
callq 0x9e70
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x9221
movl %eax, %ebx
cmpl $0x28, %r15d
jne 0x9129
leaq 0x13e1c(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x9129
leaq 0x4319(%rip), %rdi      # 0xd43d
callq 0xa900
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x9141
leaq 0x3e58(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
jmp 0x9185
movl $0x2c, %edi
callq 0x4fa3
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
setge %cl
cmpl $0x2, %ebx
sete %dl
orb %cl, %dl
leaq 0xb4a3(%rip), %rcx      # 0x14608
cmpl $0x0, 0xe4(%rcx)
setne %cl
orb %dl, %cl
testl %eax, %eax
je 0x9192
testb %cl, %cl
je 0x91c0
leaq 0x3e12(%rip), %rsi      # 0xcf92
movl $0x1a, %edi
callq 0xa2c8
movl %eax, %r14d
jmp 0x9221
leaq 0xb63f(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %edx
testb %cl, %cl
je 0x91f7
addl $0x4, %edx
movl %edx, (%rax)
orb $0x8, %bpl
movsbl %bpl, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
jmp 0x920f
movl $0x78, %edi
movl $0x58, %esi
callq 0x5083
testl %eax, %eax
jne 0x91e4
leaq 0x3db8(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
leaq 0xb5ed(%rip), %rax      # 0x147d8
movq (%rax), %rax
addl $0x4, (%rax)
orb $0x10, %bpl
jmp 0x91fc
addl $0x3, %edx
movl %edx, (%rax)
movsbl %bpl, %edi
callq 0x3348
movsbl 0x4(%rsp), %edi
callq 0x33fe
xorl %r14d, %r14d
cmpl $0x2, %ebx
jne 0x9221
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa204
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5037
leaq 0x13cea(%rip), %rax     # 0x1cf30
movl (%rax), %r15d
leaq 0x4(%rsp), %rdi
callq 0x9e70
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x93a1
movl %eax, %ebx
cmpl $0x28, %r15d
jne 0x9282
leaq 0x13cc3(%rip), %rax     # 0x1cf34
cmpl $0x29, (%rax)
jne 0x9282
leaq 0x4186(%rip), %rdi      # 0xd403
callq 0xa900
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jb 0x92a5
leaq 0x3cff(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
callq 0xa2c8
movl %eax, %r14d
jmp 0x93a1
movl $0x2c, %edi
callq 0x4fa3
testl %eax, %eax
je 0x930f
movl $0x78, %edi
movl $0x58, %esi
callq 0x5083
testl %eax, %eax
jne 0x92d7
leaq 0x3cc5(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
cmpl $0x2, %ebx
je 0x934c
cmpl $0xff, 0x4(%rsp)
jg 0x934c
leaq 0xb31b(%rip), %rax      # 0x14608
cmpl $0x0, 0xe4(%rax)
jne 0x934c
orb $0x70, %bpl
movsbl %bpl, %edi
callq 0x3348
movsbl 0x4(%rsp), %edi
callq 0x33fe
jmp 0x9381
cmpl $0x2, %ebx
je 0x936a
cmpl $0xff, 0x4(%rsp)
jg 0x936a
leaq 0xb2e3(%rip), %rax      # 0x14608
cmpl $0x0, 0xe4(%rax)
jne 0x936a
orb $0x60, %bpl
movsbl %bpl, %edi
callq 0x3348
movsbl 0x4(%rsp), %edi
callq 0x33fe
movl $0x3, %eax
jmp 0x9386
orb $-0x66, %bpl
movsbl %bpl, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
movl $0x5, %eax
jmp 0x9386
orb $-0x68, %bpl
movsbl %bpl, %edi
callq 0x3348
movswl 0x4(%rsp), %edi
callq 0x353c
movl $0x4, %eax
leaq 0xb44b(%rip), %rcx      # 0x147d8
movq (%rcx), %rcx
addl %eax, (%rcx)
xorl %r14d, %r14d
cmpl $0x2, %ebx
jne 0x93a1
xorl %eax, %eax
callq 0xa204
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebp
leaq 0xc(%rsp), %rdi
callq 0x9e70
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x9467
movl 0xc(%rsp), %edx
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x93f4
leaq 0x3bad(%rip), %rsi      # 0xcf92
movl $0x1b, %edi
callq 0xa2c8
movl %eax, %r14d
jmp 0x9467
movl %eax, %ebx
leaq 0xb3db(%rip), %rax      # 0x147d8
movq (%rax), %rax
movl (%rax), %ecx
cmpl $0x2, %ebx
je 0x9439
cmpl $0xff, %edx
jg 0x9439
leaq 0xb1f2(%rip), %rdx      # 0x14608
cmpl $0x0, 0xe4(%rdx)
jne 0x9439
addl $0x5, %ecx
movl %ecx, (%rax)
movsbl %bpl, %edi
callq 0x3348
movsbl 0xc(%rsp), %edi
callq 0x33fe
jmp 0x9455
addl $0x6, %ecx
movl %ecx, (%rax)
orb $0x8, %bpl
movsbl %bpl, %edi
callq 0x3348
movswl 0xc(%rsp), %edi
callq 0x353c
xorl %r14d, %r14d
cmpl $0x2, %ebx
jne 0x9467
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xa204
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb175(%rip), %rax      # 0x14608
xorl %ebx, %ebx
cmpl $0x0, 0xf8(%rax)
je 0x94f8
cmpl $0x0, 0x188(%rax)
je 0x94f8
movq %rdi, %rsi
leaq 0xb13f(%rip), %rax      # 0x145f0
cmpl $0x1, (%rax)
jne 0x94bf
leaq 0x84c3(%rip), %rdi      # 0x11980
jmp 0x94c6
leaq 0x915a(%rip), %rdi      # 0x12620
callq 0x66c4
testl %eax, %eax
js 0x94f3
callq 0x5b63
testl %eax, %eax
je 0x94f8
leaq 0x13a41(%rip), %rax     # 0x1cf20
movq (%rax), %rsi
movl $0x18, %edi
callq 0xa2c8
movl $0x1, %ebx
jmp 0x94f8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x31e0
movq %rax, %r14
movq (%rax), %rcx
leaq 0x13a16(%rip), %r13     # 0x1cf30
movslq (%r13), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x952d
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x9555
xorl %r12d, %r12d
xorl %r15d, %r15d
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,2), %r15
addq $-0x30, %r15
callq 0x4f15
incl %r12d
movq (%r14), %rcx
movslq (%r13), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x9533
testl %r12d, %r12d
je 0x9589
testq %r15, %r15
setns %al
cmpl $0x15, %r12d
setb %cl
testb %cl, %al
jne 0x95a1
movl $0x0, (%rbx)
leaq 0x3a1a(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa2c8
movl $0x1, %ebx
jmp 0x95a6
leaq 0x3a02(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa2c8
jmp 0x95a6
movl %r15d, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x31e0
movq %rax, %r14
movq (%rax), %rcx
leaq 0x13960(%rip), %r13     # 0x1cf30
movslq (%r13), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x95e3
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x960b
xorl %r12d, %r12d
xorl %r15d, %r15d
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,2), %r15
addq $-0x30, %r15
callq 0x4f15
incl %r12d
movq (%r14), %rcx
movslq (%r13), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x95e9
testl %r12d, %r12d
je 0x9640
testq %r15, %r15
setns %al
cmpl $0x15, %r12d
setb %cl
testb %cl, %al
jne 0x9658
movq $0x0, (%rbx)
leaq 0x3963(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa2c8
movl $0x1, %ebx
jmp 0x965d
leaq 0x394b(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa2c8
jmp 0x965d
movq %r15, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x138b2(%rip), %r15     # 0x1cf30
movabsq $0x3f0000003f, %r12     # imm = 0x3F0000003F
xorl %ebp, %ebp
movl (%r15), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x96a3
leal -0x41(%rax), %ecx
cmpl $0x25, %ecx
ja 0x96cd
btq %rcx, %r12
jae 0x96cd
shlq $0x4, %r14
movl %eax, %ecx
andl $0xdf, %ecx
addq $-0x37, %rcx
movslq %eax, %rdx
addq $-0x30, %rdx
cmpl $0x3a, %eax
cmovgeq %rcx, %rdx
addq %rdx, %r14
callq 0x4f15
incl %ebp
jmp 0x968a
testl %ebp, %ebp
je 0x96f5
cmpl $0x11, %ebp
jb 0x970d
movq $0x0, (%rbx)
leaq 0x38ae(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa2c8
movl $0x1, %ebx
jmp 0x9712
leaq 0x3896(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa2c8
jmp 0x9712
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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13801(%rip), %r12     # 0x1cf30
movl (%r12), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x30, %ecx
jne 0x9765
xorl %r15d, %r15d
xorl %r14d, %r14d
movl %eax, %eax
leaq (%rax,%r14,2), %r14
addq $-0x30, %r14
callq 0x4f15
incl %r15d
movl (%r12), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x30, %ecx
je 0x9743
jmp 0x976b
xorl %r14d, %r14d
xorl %r15d, %r15d
testl %r15d, %r15d
je 0x978e
cmpl $0x41, %r15d
jb 0x97a6
leaq 0x3815(%rip), %rsi      # 0xcf92
movl $0x10, %edi
callq 0xa2c8
movl $0x1, %ebx
jmp 0x97ab
leaq 0x37fd(%rip), %rsi      # 0xcf92
movl $0x11, %ebx
movl $0x11, %edi
callq 0xa2c8
jmp 0x97ab
movq %r14, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x144f0(%rip), %rdi     # 0x1dcc0
callq 0x53a9
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x984a
leaq 0x144d9(%rip), %rdi     # 0x1dcc0
andb $-0x21, 0x144d6(%rip)   # 0x1dcc4
leaq 0x8(%rsp), %rsi
callq 0x6140
testq %rax, %rax
je 0x9807
movslq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x9848
movl 0x144b7(%rip), %eax     # 0x1dcc4
testb %al, %al
js 0x981c
orl $0x80, %eax
movl %eax, 0x144a8(%rip)     # 0x1dcc4
leaq 0x1449d(%rip), %rdi     # 0x1dcc0
leaq 0xc(%rsp), %rsi
callq 0x5d4f
leaq 0x134bc(%rip), %rcx     # 0x1ccf0
movq %rax, (%rcx)
movq $0x0, (%rbx)
movl $0x1, 0x144d8(%rip)     # 0x1dd20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rsp), %rdi
callq 0x9bad
movl %eax, %ebp
testl %eax, %eax
jne 0x9b9c
movq %rbx, 0x10(%rsp)
xorl %eax, %eax
callq 0x5037
movq 0x8(%rsp), %r12
leaq 0x13441(%rip), %r13     # 0x1cf30
movq %rsp, %r15
movabsq $0x8000000000005, %rbx  # imm = 0x8000000000005
movl (%r13), %r14d
leal -0x2b(%r14), %eax
cmpl $0x33, %eax
ja 0x9b0f
btq %rax, %rbx
jb 0x9b15
cmpl $0x7c, %r14d
jne 0x9b8d
callq 0x4f15
testl %eax, %eax
je 0x9b30
movq %r15, %rdi
callq 0x9bad
testl %eax, %eax
je 0x9b4e
xorl %ecx, %ecx
movl %eax, %ebp
jmp 0x9b48
movl $0x11, %ebp
movl $0x11, %edi
leaq 0x3451(%rip), %rsi      # 0xcf92
callq 0xa2c8
xorl %ecx, %ecx
testb %cl, %cl
jne 0x9afc
jmp 0x9b86
movb $0x1, %cl
cmpl $0x5d, %r14d
jg 0x9b68
cmpl $0x2b, %r14d
je 0x9b7a
cmpl $0x2d, %r14d
jne 0x9b48
subq (%rsp), %r12
jmp 0x9b48
cmpl $0x5e, %r14d
je 0x9b80
cmpl $0x7c, %r14d
jne 0x9b48
orq (%rsp), %r12
jmp 0x9b48
addq (%rsp), %r12
jmp 0x9b48
xorq (%rsp), %r12
jmp 0x9b48
movq %r12, 0x8(%rsp)
jmp 0x9b9c
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %r12, (%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rsp), %rdi
callq 0x9850
movl %eax, %ebp
testl %eax, %eax
jne 0x9cff
movq %rbx, 0x10(%rsp)
xorl %eax, %eax
callq 0x5037
movq 0x8(%rsp), %r14
leaq 0x13346(%rip), %r13     # 0x1cf30
movabsq $0x844000000000, %rbx   # imm = 0x844000000000
movl (%r13), %r15d
cmpq $0x2f, %r15
ja 0x9c56
btq %r15, %rbx
jae 0x9c56
callq 0x4f15
testl %eax, %eax
je 0x9c3e
movsbl %r15b, %r12d
andl $0xfd, %r15d
cmpl $0x3c, %r15d
jne 0x9c29
cmpl %r12d, (%r13)
jne 0x9ca2
callq 0x4f15
movq %rsp, %rdi
callq 0x9850
testl %eax, %eax
je 0x9c82
xorl %ecx, %ecx
movl %eax, %ebp
jmp 0x9cf2
movl $0x11, %ebp
movl $0x11, %edi
leaq 0x3343(%rip), %rsi      # 0xcf92
callq 0xa2c8
jmp 0x9cb8
movl %r15d, %ecx
xorl $0x3c, %ecx
leaq 0x132d5(%rip), %rax     # 0x1cf38
movl (%rax), %eax
movl %eax, %edx
xorl $0x3c, %edx
orl %ecx, %edx
je 0x9c04
cmpl $0x3e, %r15d
jne 0x9d10
cmpl $0x3e, %eax
je 0x9c04
jmp 0x9d10
cmpl $0x2e, %r12d
jle 0x9cbc
cmpl $0x2f, %r12d
je 0x9ccf
cmpl $0x3c, %r12d
je 0x9cdd
cmpl $0x3e, %r12d
jne 0x9ce9
movb (%rsp), %cl
sarq %cl, %r14
jmp 0x9ce9
movl $0x11, %edi
leaq 0x32e4(%rip), %rsi      # 0xcf92
callq 0xa2c8
movl $0x1, %ebp
xorl %ecx, %ecx
jmp 0x9cf2
cmpl $0x26, %r12d
je 0x9ce5
cmpl $0x2a, %r12d
jne 0x9ce9
imulq (%rsp), %r14
jmp 0x9ce9
movq %r14, %rax
cqto
idivq (%rsp)
movq %rax, %r14
jmp 0x9ce9
movb (%rsp), %cl
shlq %cl, %r14
jmp 0x9ce9
andq (%rsp), %r14
xorl %eax, %eax
callq 0x5037
movb $0x1, %cl
testb %cl, %cl
jne 0x9bf4
movq %r14, 0x8(%rsp)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %r14, (%rax)
xorl %ebp, %ebp
jmp 0x9cff
// File: /workspace/github_c_makefile_star2_O1/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, 0x13fe5(%rip)     # 0x1dd20
leaq 0x10(%rsp), %rdi
callq 0x9ab2
testl %eax, %eax
jne 0x9e51
xorl %eax, %eax
callq 0x5037
leaq 0x131d5(%rip), %rax     # 0x1cf30
movl (%rax), %eax
cmpl $0x3c, %eax
je 0x9dda
cmpl $0x3e, %eax
je 0x9d9b
cmpl $0x3d, %eax
jne 0x9e32
callq 0x4f15
leaq 0x8(%rsp), %rdi
callq 0x9ab2
testl %eax, %eax
jne 0x9e51
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
cmpq 0x8(%rsp), %rax
sete %cl
jmp 0x9e37
callq 0x4f15
movl $0x3d, %edi
callq 0x4fa3
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x9ab2
testl %eax, %eax
jne 0x9e51
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x9e58
cmpq %rdx, %rax
setge %cl
jmp 0x9e37
callq 0x4f15
movl $0x3d, %edi
callq 0x4fa3
movl $0x1, %ebp
testl %eax, %eax
jne 0x9e06
movl $0x3e, %edi
callq 0x4fa3
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
addl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x9ab2
testl %eax, %eax
jne 0x9e51
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
cmpl $0x2, %ebp
je 0x9e60
cmpl $0x1, %ebp
jne 0x9e68
cmpq %rdx, %rax
setle %cl
jmp 0x9e37
movq 0x10(%rsp), %rcx
movq %rcx, (%rbx)
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x0, 0x13edb(%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 0x9e37
cmpq %rdx, %rax
setne %cl
jmp 0x9e37
cmpq %rdx, %rax
setl %cl
jmp 0x9e37
// File: /workspace/github_c_makefile_star2_O1/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 0x9d21
testl %eax, %eax
jne 0x9ec2
movq 0x8(%rsp), %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
movabsq $-0x180000001, %rdx     # imm = 0xFFFFFFFE7FFFFFFF
cmpq %rdx, %rcx
ja 0x9ebe
movl $0x10, %edi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
jmp 0xa2c8
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13e23(%rip), %ecx     # 0x1dd30
testl %ecx, %ecx
je 0x9f39
leal 0x1(%rcx), %eax
movl %eax, 0x13e16(%rip)     # 0x1dd30
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0x9f9a
leaq 0x306a(%rip), %rsi      # 0xcf92
movl $0x19, %edi
callq 0xa2c8
movl $0x1, %eax
jmp 0x9f9a
movq %rdi, %rbx
movl $0x1, %ebp
movl %ebp, 0x13de9(%rip)     # 0x1dd30
callq 0x30b0
movl %eax, 0x13de6(%rip)     # 0x1dd38
leaq 0x13e17(%rip), %rdi     # 0x1dd70
movq %rbx, %rsi
callq 0x3070
leaq 0xa6a0(%rip), %rax      # 0x14608
movq (%rax), %rcx
movq 0x198(%rax), %rdx
movq %rcx, 0x13dcf(%rip)     # 0x1dd48
movq $0x0, 0x13dbc(%rip) # 0x1dd40
movq %rdx, 0x13dcd(%rip)     # 0x1dd58
movl $0x4, 0x13da7(%rip)     # 0x1dd3c
movl %ebp, 0xc(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13d82(%rip)           # 0x1dd30
je 0x9fb8
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xa649(%rip), %rax      # 0x14608
movl $0x0, 0xc(%rax)
leaq 0x13d6b(%rip), %rdi     # 0x1dd38
leaq 0xc(%rsp), %rsi
callq 0x5d4f
testq %rax, %rax
je 0x9ff8
cmpl $0x0, 0xc(%rsp)
je 0x9fb0
leaq 0x2fa8(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
movl %eax, %ebx
jmp 0x9fb0
movl $0x1, %ebx
jmp 0x9fb0
// File: /workspace/github_c_makefile_star2_O1/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 0x5037
testl %eax, %eax
sete %cl
leaq 0x12f11(%rip), %r15     # 0x1cf30
movl (%r15), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
movq %rbx, %r14
je 0xa043
movb $0x0, (%r14)
xorl %eax, %eax
cmpq %rbx, %r14
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
xorl %r12d, %r12d
cmpl $0x3a, %eax
jg 0xa05f
cmpl $0x20, %eax
je 0xa07b
cmpl $0x22, %eax
je 0xa089
cmpl $0x2c, %eax
je 0xa072
jmp 0xa08d
cmpl $0x3b, %eax
je 0xa072
cmpl $0x7b, %eax
je 0xa0a1
cmpl $0x7d, %eax
jne 0xa08d
decl %ebp
jmp 0xa093
movl %r12d, %ecx
orl %ebp, %ecx
jne 0xa08d
jmp 0xa02e
movl %r12d, %ecx
orl %ebp, %ecx
jne 0xa08d
xorl %r12d, %r12d
xorl %ebp, %ebp
jmp 0xa093
xorl $0x1, %r12d
movb %al, (%r14)
incq %r14
callq 0x4f15
movl (%r15), %eax
testl %eax, %eax
jne 0xa049
jmp 0xa02e
incl %ebp
jmp 0xa093
// File: /workspace/github_c_makefile_star2_O1/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 0xa54b(%rip), %rax      # 0x14608
xorl %ebp, %ebp
cmpl $0x0, 0xf8(%rax)
je 0xa1ee
cmpl $0x0, 0x188(%rax)
je 0xa1ee
movq %rdi, %r14
leaq 0x12e4d(%rip), %r15     # 0x1cf30
movl (%r15), %r12d
leaq 0xa51b(%rip), %rbx      # 0x14608
leaq 0x8(%rsp), %rdi
movl $0x1c0, %edx            # imm = 0x1C0
movq %rbx, %rsi
callq 0x3150
movq %rsp, %rsi
movq %r14, %rdi
callq 0x61fe
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xa1ee
movq (%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%rsp), %rax
movl 0x10(%rax), %ecx
movl %ecx, (%rbx)
movl 0x14(%rax), %ecx
movl %ecx, 0x4(%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 0x13c42(%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 0x9fff
testl %eax, %eax
setne %al
cmpl $0x2c, (%r15)
sete %cl
orb %al, %cl
movzbl %cl, %ebp
addl %r13d, %ebp
movl $0x2c, %edi
callq 0x4fa3
testl %eax, %eax
je 0xa1ba
cmpl $0x11, %ebp
jb 0xa16f
movl %ebp, 0x20(%rbx)
incl 0x8(%rbx)
xorl %eax, %eax
callq 0x624d
leaq 0xa1ca(%rip), %rax      # 0x14398
incl (%rax)
xorl %edi, %edi
callq 0x42cd
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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x12c11(%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 0xa3d2(%rip), %rax      # 0x14608
movl (%rax), %ecx
decl %ecx
movl %ecx, 0x14(%rbx)
movl 0x4(%rax), %ecx
movl %ecx, 0x18(%rbx)
movl 0x10(%rax), %ecx
movl %ecx, 0x1c(%rbx)
movl 0x14(%rax), %ecx
movl %ecx, 0x20(%rbx)
movl 0x24(%rax), %ecx
movl %ecx, 0x24(%rbx)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rbx)
leaq 0xa14e(%rip), %rax      # 0x143b0
movl 0x4(%rax), %eax
movl %eax, 0x10(%rbx)
leaq 0xa361(%rip), %rax      # 0x145d0
movq 0x18(%rax), %rax
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x12a6c(%rip), %rax     # 0x1ccf0
movq (%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0xa35e(%rip), %rax      # 0x145f0
movl (%rax), %eax
movl %eax, 0x30(%rbx)
cmpq $0x0, 0x18b01(%rip)     # 0x22da0
je 0xa2ae
movq 0x18b00(%rip), %rax     # 0x22da8
movq %rax, 0x8(%rbx)
jmp 0xa2b5
leaq 0x18aeb(%rip), %rax     # 0x22da0
movq %rbx, (%rax)
movq %rbx, 0x18ae9(%rip)     # 0x22da8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x9a8d(%rip), %rax      # 0x14394
incl (%rax)
leaq 0x9a68(%rip), %rax      # 0x14378
cmpl $0x0, (%rax)
setne %dl
leaq 0x9ceb(%rip), %rax      # 0x14608
movl 0x4(%rax), %ecx
testl %ecx, %ecx
setns %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xa999
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 0x9cab(%rip), %rdi      # 0x145f8
movq (%rdi), %rdi
leaq (%rsi,%rdx,4), %rdx
leaq 0x9e85(%rip), %rsi      # 0x147e0
addq %rsi, %rdx
addq $0x4, %rdx
testl %r8d, %r8d
je 0xa99a
movslq 0x14(%rax), %rax
movq %rax, %r9
shlq $0x9, %r9
leaq (%r9,%rax,4), %rax
leaq (%rsi,%rax), %r9
addq $0x4, %r9
leaq 0x1249b(%rip), %rax     # 0x1ce20
movq %rax, (%rsp)
leaq 0x3175(%rip), %rsi      # 0xdb05
xorl %eax, %eax
callq 0x3130
jmp 0xa9af
retq
leaq 0x318e(%rip), %rsi      # 0xdb2f
leaq 0x12478(%rip), %r8      # 0x1ce20
xorl %eax, %eax
callq 0x3130
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3080
// File: /workspace/github_c_makefile_star2_O1/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 0xac2c
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0xaeb6
cmpl $0x40, %ebx
jne 0xae88
movl $0xfc20, %ebx           # imm = 0xFC20
jmp 0xae8b
shll $0xa, %ebx
orl 0xc(%rsp), %ebx
movl %ebx, %eax
shrl $0xa, %eax
andl $0x3f, %eax
movl %eax, 0x9283(%rip)      # 0x14120
leaq 0x950c(%rip), %rax      # 0x143b0
movl (%rax), %eax
movl %eax, 0x9278(%rip)      # 0x14124
movswl %bx, %edi
callq 0x35ae
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rdi
callq 0xa9dc
movl $0x1, %ebx
testl %eax, %eax
je 0xaedb
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x2c, %edi
callq 0x4fa3
testl %eax, %eax
je 0xaf24
leaq 0x4(%rsp), %rdi
callq 0xac2c
testl %eax, %eax
jne 0xaed2
movl (%rsp), %eax
movl %eax, %ecx
xorl $0x40, %ecx
movl %ebp, %edx
xorl $0x22, %edx
xorl %ebx, %ebx
orl %ecx, %edx
sete %cl
cmovel %ebx, %eax
movl %eax, (%rsp)
cmpl $0x20, %eax
jl 0xaf3b
leaq 0x2075(%rip), %rsi      # 0xcf92
movl $0x2c, %edi
jmp 0xaf30
leaq 0x2067(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa2c8
shll $0xa, %ebp
testb %cl, %cl
movl $0xcc00, %ecx           # imm = 0xCC00
cmovel %ebp, %ecx
shll $0x5, %eax
orl %ecx, %eax
orl 0x4(%rsp), %eax
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movl %ecx, 0x91c1(%rip)      # 0x14120
leaq 0x944a(%rip), %rcx      # 0x143b0
movl (%rcx), %ecx
movl %ecx, 0x91b6(%rip)      # 0x14124
movswl %ax, %edi
callq 0x35ae
jmp 0xaed2
// File: /workspace/github_c_makefile_star2_O1/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 0x4fa3
testl %eax, %eax
je 0xb046
movq %rsp, %rdi
callq 0x9e70
movl $0x1, %ebp
cmpl $0x11, %eax
je 0xb070
cmpl $0x2, %eax
jne 0xafbb
xorl %eax, %eax
callq 0xa204
movl $0x1, (%rsp)
movl (%rsp), %eax
addl $-0x21, %eax
cmpl $-0x21, %eax
ja 0xafd7
leaq 0x2b79(%rip), %rsi      # 0xdb46
movl $0x2b, %edi
callq 0xa2c8
cmpl $0x18, %ebx
jne 0xafe7
movl $0x20, %eax
subl (%rsp), %eax
movl %eax, (%rsp)
cmpl $0x20, (%rsp)
jne 0xaff4
movl $0x0, (%rsp)
movl $0x2c, %edi
callq 0x4fa3
testl %eax, %eax
je 0xb05d
leaq 0x4(%rsp), %rdi
callq 0xac2c
testl %eax, %eax
jne 0xb070
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, 0x90f2(%rip)      # 0x14120
leaq 0x937b(%rip), %rax      # 0x143b0
movl (%rax), %eax
movl %eax, 0x90e7(%rip)      # 0x14124
callq 0x35ae
xorl %ebp, %ebp
jmp 0xb070
leaq 0x1f45(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa2c8
leaq 0x1f2e(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4fa3
testl %eax, %eax
je 0xb11b
movq %rsp, %rdi
callq 0x9e70
movl $0x1, %ebp
cmpl $0x11, %eax
je 0xb145
cmpl $0x2, %eax
jne 0xb0b2
xorl %eax, %eax
callq 0xa204
cmpl $0x20, (%rsp)
jb 0xb0c9
leaq 0x2a90(%rip), %rsi      # 0xdb4f
movl $0x2b, %edi
callq 0xa2c8
movl $0x2c, %edi
callq 0x4fa3
testl %eax, %eax
je 0xb132
leaq 0x4(%rsp), %rdi
callq 0xac2c
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 0x35ae
xorl %ebp, %ebp
jmp 0xb145
leaq 0x1e70(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa2c8
leaq 0x1e59(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4fa3
testl %eax, %eax
je 0xb1f9
movq %rsp, %rdi
callq 0x9e70
movl $0x1, %ebp
cmpl $0x11, %eax
je 0xb223
cmpl $0x2, %eax
jne 0xb187
xorl %eax, %eax
callq 0xa204
movl (%rsp), %eax
addl $-0x10, %eax
cmpl $-0x21, %eax
ja 0xb1a3
leaq 0x29bf(%rip), %rsi      # 0xdb58
movl $0x2b, %edi
callq 0xa2c8
andl $0x1f, (%rsp)
movl $0x2c, %edi
callq 0x4fa3
testl %eax, %eax
je 0xb210
leaq 0x4(%rsp), %rdi
callq 0xac2c
testl %eax, %eax
jne 0xb223
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, 0x8f3f(%rip)      # 0x14120
leaq 0x91c8(%rip), %rax      # 0x143b0
movl (%rax), %eax
movl %eax, 0x8f34(%rip)      # 0x14124
callq 0x35ae
xorl %ebp, %ebp
jmp 0xb223
leaq 0x1d92(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa2c8
leaq 0x1d7b(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa2c8
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq