LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/lua/src/loadlib.c
// Function: ll_get_accessed_files
static int ll_get_accessed_files(lua_State *L) {
	lua_pushlightuserdata(L, &lf_callback_key);
	lua_gettable(L, LUA_REGISTRYINDEX);
  if (lua_isnil(L, -1))
  {
    lua_pop(L, 1);
    lua_newtable(L);
  }
	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa439b(%rip), %rsi     # 0xc37c0
callq 0x1891f
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x18957
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x18318
testl %eax, %eax
jne 0x1f45d
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x180d8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x18a30
pushq $0x1
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/lua/src/ltable.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (t->node != dummynode)
    luaM_freearray(L, t->node, (lua_Number)sizenode(t), Node);
  luaM_freearray(L, t->array, t->sizearray, TValue);
  luaM_free(L, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
leaq 0xae01(%rip), %rax      # 0x2f518
cmpq %rax, %rsi
je 0x24734
movb 0xb(%rbx), %cl
pushq $0x1
popq %rax
shll %cl, %eax
cltq
imulq $0x28, %rax, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1e70e
movq 0x18(%rbx), %rsi
movslq 0x38(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1e70e
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e70e
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/lua/src/lvm.c
// Function: luaV_settable
void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
  int loop;
  for (loop = 0; loop < MAXTAGLOOP; loop++) {
    const TValue *tm;
    if (ttistable(t)) {  /* `t' is a table? */
      Table *h = hvalue(t);
      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
      if (!ttisnil(oldval) ||  /* result is no nil? */
          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
        setobj2t(L, oldval, val);
        luaC_barriert(L, h, val);
        return;
      }
      /* else will try the tag method */
    }
    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
      luaG_typeerror(L, t, "index");
    if (ttisfunction(tm)) {
      callTM(L, tm, t, key, val);
      return;
    }
    t = tm;  /* else repeat with `tm' */ 
  }
  luaG_runerror(L, "loop in settable");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x65
popq %r15
decl %r15d
je 0x26079
movq %r12, %r14
cmpl $0x5, 0x8(%r12)
jne 0x25f7d
movq (%r14), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0x248d9
movq %rax, %rbp
cmpl $0x0, 0x8(%rax)
jne 0x26043
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x26043
testb $0x2, 0xa(%rdi)
jne 0x26043
movq 0x20(%rbx), %rax
movq 0x130(%rax), %rdx
pushq $0x1
popq %rsi
callq 0x25676
movq %rax, %r12
testq %rax, %rax
jne 0x25fa6
jmp 0x26043
movq %rbx, %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
callq 0x2569f
movq %rax, %r12
cmpl $0x0, 0x8(%rax)
jne 0x25fa6
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x945c(%rip), %rdx      # 0x2f3fd
callq 0x1addb
cmpl $0x6, 0x8(%r12)
jne 0x25f12
movq 0x10(%rbx), %rax
movq (%r12), %rcx
movq %rcx, (%rax)
movl 0x8(%r12), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%r14), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rax
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x20(%rax)
movl 0x8(%rdx), %ecx
movl %ecx, 0x28(%rax)
movq 0x10(%rbx), %rax
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x30(%rax)
movl 0x8(%rdx), %ecx
movl %ecx, 0x38(%rax)
movq 0x10(%rbx), %rsi
movq 0x38(%rbx), %rax
subq %rsi, %rax
cmpq $0x40, %rax
jg 0x26023
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x1b5ba
movq 0x10(%rbx), %rsi
leaq 0x40(%rsi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1bbb9
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movq %rax, (%rbp)
movl 0x8(%rcx), %eax
movl %eax, 0x8(%rbp)
cmpl $0x4, %eax
jl 0x2606a
movq (%rcx), %rax
testb $0x3, 0x9(%rax)
je 0x2606a
testb $0x4, 0x9(%r13)
jne 0x26098
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9791(%rip), %rsi      # 0x2f811
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1afed
movq %rbx, %rdi
movq %r13, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1cfbf
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: check_getw
int check_getw( result )
    dword   *result;
{
    int             ch;

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result = ch;
    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += ch << 8;
    return( FALSE );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xece6
pushq $0x1
popq %rbp
cmpl $-0x1, %eax
je 0x93fc
cltq
movq %rax, (%rbx)
callq 0xece6
cmpl $-0x1, %eax
je 0x93fc
shll $0x8, %eax
cltq
addq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: check_getl
int check_getl( result )
    dword   *result;
{
    int             ch;

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result = (dword)((uchar)ch);

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += (dword)((uchar)ch) << 8;

    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += (dword)((uchar)ch) << 16;
    ch = buff_getc();
    if ( ch == EOF ) {
        return( TRUE );
    }
    *result += (dword)((uchar)ch) << 24;

    return( FALSE );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xece6
pushq $0x1
popq %rbx
cmpl $-0x1, %eax
je 0x9457
movzbl %al, %eax
movq %rax, (%r14)
callq 0xece6
cmpl $-0x1, %eax
je 0x9457
shll $0x8, %eax
movzwl %ax, %eax
addq %rax, (%r14)
callq 0xece6
cmpl $-0x1, %eax
je 0x9457
movzbl %al, %eax
shll $0x10, %eax
addq %rax, (%r14)
callq 0xece6
cmpl $-0x1, %eax
je 0x9457
shll $0x18, %eax
addq %rax, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: instr_opcode
void instr_opcode( text )
    char    *text;
{
    if ( pass == 3 ) {
        out_opcode( text );
    }
    tab_offset = 0;
    inst_init();            /* Reset for next instruction */
}

// Assembly:
pushq %rax
leaq 0x12acf(%rip), %rax     # 0x1bf68
cmpl $0x3, (%rax)
jne 0x94a3
callq 0xc497
leaq 0x12a4a(%rip), %rax     # 0x1bef4
andl $0x0, (%rax)
popq %rax
jmp 0x92fc
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: in_out
int in_out( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             dir;
    int             size;
    char            temp[50];

    dir  = ( byte & 0x02 ) >> 1;
    size = ( byte & 0x01 );

    if ( size == 1 && size_large ) {
        size = 2;
    }
    instr_opcode(text);

    if ( dir == 0 ) {
        sprintf( temp, "%s,dx", regs[size][0] );
    } else {
        sprintf( temp, "dx,%s", regs[size][0] );
    }
    instr_operand(temp);

    class = class;              /* Prevent unused variable warnings */

    return(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebx
movl %edi, %ebp
andl $0x1, %ebp
movl 0x129a7(%rip), %r14d    # 0x1be84
movq %rsi, %rdi
callq 0x9491
testl %r14d, %r14d
pushq $0x2
popq %rax
cmovel %ebp, %eax
testb $0x1, %bl
cmovel %ebp, %eax
shll $0x6, %eax
testb $0x2, %bl
leaq 0xec0f(%rip), %rcx      # 0x18110
movq (%rax,%rcx), %rdx
leaq 0x8d14(%rip), %rax      # 0x12220
leaq 0x8d13(%rip), %rsi      # 0x12226
cmoveq %rax, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x91b0
movq %rbx, %rdi
callq 0x94b3
pushq $0x1
popq %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: two_byte
int two_byte( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    dword   offset;
    char            line[50];
    char            temp[50];

    if ( get_checkc( &offset ) ) {
        return( 0 );
    }

    reg_format( class, line, text, "%s\t", "%s\t%s," );

    out_hexize( offset, temp, 1 );      /* Convert 1 byte into hex */
    strcat( line, temp );

    instr_opcode( line );

    byte = byte;                   /* Prevent unused varaible warnings */

    return(2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x946e
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x96ea
leaq 0x8b9f(%rip), %rcx      # 0x12245
leaq 0x8b9c(%rip), %r8       # 0x12249
leaq 0x50(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9337
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xc5b5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x91a0
movq %r14, %rdi
callq 0x9491
pushq $0x2
popq %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: two_ubyte
int two_ubyte( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    dword   offset;
    char            line[50];

    if ( get_checkc( &offset ) ) {
        return( 0 );
    }

    if ( offset <= 127L ) {
        sprintf( line, "%s+0%02lXh", text, offset );
    } else {
        sprintf( line, "%s-0%02lXh", text, 0x0100L - offset );
    }
    instr_opcode( line );

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    return(2);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x946e
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x975a
movq 0x8(%rsp), %rcx
cmpq $0x7f, %rcx
ja 0x972c
leaq 0x8b2e(%rip), %rsi      # 0x12250
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
jmp 0x9746
movl $0x100, %eax            # imm = 0x100
subq %rcx, %rax
leaq 0x8b20(%rip), %rsi      # 0x1225b
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x91b0
leaq 0x10(%rsp), %rdi
callq 0x9491
pushq $0x2
popq %rax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: one_a
int one_a( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    char            line[50];

    if ( size_large ) {
        reg_format( class, line, text, "%s\teax", "%s\teax,%s" );
    } else {
        reg_format( class, line, text, "%s\tax", "%s\tax,%s" );
    }

    instr_opcode(line);

    byte = byte;                   /* Prevent unused varaible warnings */

    return(1);
}

// Assembly:
subq $0x38, %rsp
movl %edx, %edi
movq %rsi, %rdx
cmpl $0x0, 0x12496(%rip)     # 0x1be84
je 0x9a00
leaq 0x887a(%rip), %rcx      # 0x12271
leaq 0x887a(%rip), %r8       # 0x12278
jmp 0x9a0e
leaq 0x887b(%rip), %rcx      # 0x12282
leaq 0x887a(%rip), %r8       # 0x12288
movq %rsp, %rsi
callq 0x9337
movq %rsp, %rdi
callq 0x9491
pushq $0x1
popq %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: two_a
int two_a( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             size;
    dword   offset;
    char            line[50];

    size = (byte & 0x01);

    if ( check_getc( &offset ) ) {
        return( 0 );
    }

    if ( size == 0 ) {
        sprintf( line, "0%02lXh,al", offset );
    } else {
        sprintf( line, "0%02lXh,ax", offset );
    }
    instr_opcode( text );
    instr_operand(line);

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    return(2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
callq 0x93b4
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x9a82
testb $0x1, %bpl
movq 0x8(%rsp), %rdx
leaq 0x883c(%rip), %rax      # 0x12291
leaq 0x8840(%rip), %rsi      # 0x1229c
cmoveq %rax, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
movq %rbx, %rdi
callq 0x9491
movq %r14, %rdi
callq 0x94b3
pushq $0x2
popq %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: enter
int enter( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    dword   num_bytes;
    dword   nest_level;
    char            line[50];

    switch( data_check(1) ) {
        case BAD:
        case LABEL:
        case FIXUP:
            return( 0 );
        case NORMAL:
            if ( check_getw(&num_bytes) ) {
                return( 0 );
            }
            if ( check_getc(&nest_level) ) {
                return( 0 );
            }
            sprintf( line, "0%04lXh,0%02lXh", num_bytes, nest_level );
            break;
    }
    instr_opcode( text );
    instr_operand( line );

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    return(4);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
pushq $0x1
popq %rdi
callq 0xc74e
xorl %ebp, %ebp
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0x9d7b
testl %eax, %eax
jne 0x9d66
leaq 0x8(%rsp), %rdi
callq 0x93d0
testl %eax, %eax
jne 0x9d7b
movq %rsp, %rdi
callq 0x93b4
testl %eax, %eax
jne 0x9d7b
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x8563(%rip), %rsi      # 0x122bd
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x91b0
movq %rbx, %rdi
callq 0x9491
leaq 0x10(%rsp), %rdi
callq 0x94b3
pushq $0x4
popq %rbp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: prefix
int prefix( byte, text, class )
    uchar   byte;
    char            *text;
    int             class;
{
    int             valid;

    valid = check_forward( instr, 0 );

    byte = byte;               /* Prevent unused variable warnings */
    class = class;              /* Prevent unused variable warnings */

    if ( valid ) {
        instr_opcode( text );
        tab_offset = 1;
        hex_finish = FALSE;
        return( 1 );
    } else {
        return( 0 );
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xebee(%rip), %rdi      # 0x18b60
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x9d84
testl %eax, %eax
je 0x9fa1
movq %rbx, %rdi
callq 0x9491
leaq 0x11f66(%rip), %rax     # 0x1bef4
movl $0x1, (%rax)
leaq 0x12215(%rip), %rax     # 0x1c1b0
andl $0x0, (%rax)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: mod1
int mod1( ref_mode, sib_offset, sib_text, text, r_m )
    int             ref_mode;
    int             sib_offset;
    char            *sib_text;
    char            *text;
    uchar   r_m;
{
    char            temp[50];
    dword   offset;
    int             result;
    uchar   zero_rm;

    if ( check_getc( &offset ) ) {
        result = -1;
    } else {
        if ( addr_large ) {
            /*
            ** Assembler should have optimized
            */
            zero_rm = 5;
            strcpy( text, addr_386m[r_m] );
        } else {
            /*
            ** Assembler should have optimized
            */
            zero_rm = 6;
            strcpy( text, addr_mode[r_m] );
        }
        if ( strlen(sib_text) ) {
            strcat( text, "+" );
            strcat( text, sib_text );
        }
        if ( offset >= 0x80 ) {
            sprintf( temp, "-0%02lXh", 0x0100L-offset );
        } else {
            if ( offset == 0L ) {
                if ( r_m == zero_rm ) {
                    temp[0] = '\0';
                } else {
                    return( -1 );
                }
            } else {
                sprintf( temp, "+0%02lXh", offset );
            }
        }
        if ( compatibility == 2 ) {
            strcat( text, "]" );
            strcat( text, temp );
        } else {
            strcat( text, temp );
            strcat( text, "]" );
        }
        result = 1 + sib_offset;
    }
    return( result );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebx
leaq 0x8(%rsp), %rdi
callq 0x93b4
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0xa760
xorl %r13d, %r13d
cmpl $0x0, 0x117f8(%rip)     # 0x1be88
sete 0x7(%rsp)
leaq 0xdc94(%rip), %rax      # 0x18330
leaq 0xdccd(%rip), %rcx      # 0x18370
cmoveq %rax, %rcx
movzbl %r12b, %r12d
movq (%rcx,%r12,8), %rsi
movq %r14, %rdi
callq 0x9070
cmpb $0x0, (%r15)
je 0xa6d7
movq %r14, %rdi
callq 0x90b0
movw $0x2b, (%r14,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x91a0
movq 0x8(%rsp), %rdx
cmpq $0x80, %rdx
jb 0xa6fe
movl $0x100, %eax            # imm = 0x100
subq %rdx, %rax
leaq 0x7b69(%rip), %rsi      # 0x1225d
leaq 0x10(%rsp), %rdi
movq %rax, %rdx
jmp 0xa70f
testq %rdx, %rdx
je 0xa771
leaq 0x7b48(%rip), %rsi      # 0x12252
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x117db(%rip), %rax     # 0x1bef8
cmpl $0x2, (%rax)
jne 0xa740
movq %r14, %rdi
callq 0x90b0
movw $0x5d, (%r14,%rax)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x91a0
jmp 0xa75c
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x91a0
movq %r14, %rdi
callq 0x90b0
movw $0x5d, (%r14,%rax)
incl %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x7(%rsp), %al
movb %al, %r13b
addl $0x5, %r13d
cmpl %r12d, %r13d
jne 0xa760
movb $0x0, 0x10(%rsp)
jmp 0xa716
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: do_sib
int do_sib( text, base )
    char            *text;
    uchar   *base;
{
    dword   sib_byte;
    int             ss;
    int             idx;

    switch( data_check(2) ) {
        case LABEL:
            return( -1 );
        case FIXUP:
            return( -1 );
        case BAD:
        case NORMAL:
            if ( check_getc( &sib_byte ) ) {
                return( -1 );
            }
            ss    = (int)(sib_byte & 0xC0L) >> 6;
            idx   = (int)(sib_byte & 0x38L) >> 3;
            *base = (uchar)(sib_byte & 0x07L);
            if ( idx == 0x04 ) {            /* For special [ESP] */
                if ( ss != 0 ) {
                    return( -1 );
                } else {
                    strcpy( text, "" );
                }
            } else {
                strcat( text, regs[2][idx] );
                strcat( text, sib_scale[ss] );
            }
            return( 1 );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2
popq %rdi
callq 0xc74e
pushq $-0x1
popq %rbp
cmpl $0x3, %eax
je 0xaa6e
testl %eax, %eax
jne 0xaad8
movq %rsp, %rdi
callq 0x93b4
testl %eax, %eax
jne 0xaad8
movq (%rsp), %rcx
movl %ecx, %r15d
shrl $0x6, %r15d
andl $0x3, %r15d
movl %ecx, %eax
shrl $0x3, %eax
andl $0x7, %eax
andb $0x7, %cl
movb %cl, (%r14)
cmpl $0x4, %eax
jne 0xaaa6
testl %r15d, %r15d
jne 0xaad8
movb $0x0, (%rbx)
jmp 0xaad5
movl %eax, %eax
leaq 0xd661(%rip), %rcx      # 0x18110
movq 0x80(%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x91a0
movl %r15d, %eax
leaq 0xd8e7(%rip), %rcx      # 0x183b0
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x91a0
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: byte_immed
int byte_immed( text, additional, sign )
    char            *text;
    int             additional;
    int             sign;
{
    int             dcheck;
    dword   offset;

    dcheck = data_check( additional+2 );

    switch( dcheck ) {
        case LABEL:     return( 1 );
        case FIXUP:     return( 1 );
        case BAD:
        case NORMAL:
            if ( check_getc( &offset ) ) {
                return( 1 );
            }
            if ( sign ) {
                if ( offset <= 0x7F ) {
                    sprintf( text, "+0%02lXh", offset );
                } else {
                    sprintf( text, "-0%02lXh", 0x0100L-offset );
                }
            } else {
                out_hexize( offset, text, 1 );
            }
            break;
    }
    return( 0 );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leal 0x2(%rsi), %edi
callq 0xc74e
pushq $0x1
popq %r14
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xad2c
cmpl $0x3, %eax
je 0xacd4
testl %eax, %eax
jne 0xad29
leaq 0x8(%rsp), %rdi
callq 0x93b4
testl %eax, %eax
jne 0xad2c
movq 0x8(%rsp), %rax
testl %ebp, %ebp
je 0xad00
cmpq $0x7f, %rax
ja 0xad10
leaq 0x755a(%rip), %rsi      # 0x12252
movq %rbx, %rdi
movq %rax, %rdx
jmp 0xad22
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc5b5
jmp 0xad29
movl $0x100, %edx            # imm = 0x100
subq %rax, %rdx
leaq 0x753e(%rip), %rsi      # 0x1225d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x91b0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/odisasm.c
// Function: word_immed
int word_immed( text, additional )
    char            *text;
    int             additional;
{
    int             dcheck;
    int             dummy;
    dword   offset;

    dcheck = data_check( additional+2 );

    switch( dcheck ) {
        case LABEL:
            return( 1 );
        case FIXUP:
            if ( fix_rec->word_sized && fix_rec->extended == addr_large ) {
                get_fix( text, 2, TRUE, size_bytes, NEAR, FALSE, &dummy, DS );
            } else {
                return( 1 );
            }
            break;
        case BAD:
            return( 1 );
        case NORMAL:
            if ( check_getv( &offset, size_large ) ) {
                return( 1 );
            }
            if ( size_large ) {
                out_hexize( offset, text, 4 );
            } else {
                out_hexize( offset, text, 2 );
            }
            break;
    }
    return( 0 );
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leal 0x2(%rsi), %edi
callq 0xc74e
cmpl $0x3, %eax
ja 0xadd9
pushq $0x1
popq %rbp
movl %eax, %eax
leaq 0x72e6(%rip), %rcx      # 0x12044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x11117(%rip), %esi     # 0x1be84
leaq 0x8(%rsp), %rdi
callq 0x9461
testl %eax, %eax
jne 0xaddb
cmpl $0x0, 0x11102(%rip)     # 0x1be84
movq 0x8(%rsp), %rdi
je 0xadce
pushq $0x4
jmp 0xadd0
leaq 0x11384(%rip), %rax     # 0x1c118
movq (%rax), %rax
cmpl $0x0, 0x3c(%rax)
je 0xaddb
movl 0x38(%rax), %eax
cmpl 0x110e2(%rip), %eax     # 0x1be88
jne 0xaddb
movl 0xdcde(%rip), %ecx      # 0x18a8c
leaq 0x14(%rsp), %rax
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %edx, %r8d
xorl %r9d, %r9d
pushq $0x14
pushq %rax
callq 0xfad9
popq %rcx
popq %rdx
jmp 0xadd9
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0xc5b5
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oextra.c
// Function: hint_insert
void hint_insert( int seg_idx, dword offset, int hint_type, dword length )
{
    HINT_T          *hint_rec;

    hint_rec = (HINT_T *)o_malloc( sizeof(HINT_T) );
    hint_rec->seg_idx   = seg_idx;
    hint_rec->offset    = offset;
    hint_rec->hint_type = hint_type;
    hint_rec->length    = length;
    insert( (char *)hint_rec, hint_tree, TC hint_compare );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r15d
pushq $0x18
popq %rdi
callq 0x11f10
movl %r15d, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x4(%rax)
movq %rbx, 0x10(%rax)
leaq 0x10995(%rip), %rcx     # 0x1bfd8
movq (%rcx), %rsi
leaq -0x59(%rip), %rdx       # 0xb5f4
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11c41
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/ooutput.c
// Function: tab_count
void tab_count( text )
    char    *text;
{
    int     count;

    count = strlen( text );
    while ( count  ) {
        if ( *text == '\t' ) {
            col_cnt = (col_cnt | 0x07) + 1;
        } else {
            col_cnt++;
        }
        text++;
        --count;
    }
    tab_at = (col_cnt >> 3) + 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x90b0
xorl %ecx, %ecx
movl 0xfdff(%rip), %edx      # 0x1c1b8
cmpl %ecx, %eax
je 0xc3d8
movl %edx, %esi
orl $0x7, %esi
cmpb $0x9, (%rbx,%rcx)
cmovnel %edx, %esi
incl %esi
movl %esi, 0xfde7(%rip)      # 0x1c1b8
incq %rcx
movl %esi, %edx
jmp 0xc3b9
sarl $0x3, %edx
incl %edx
movl %edx, 0xfdd1(%rip)      # 0x1c1b4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/ooutput.c
// Function: tab_seek
void tab_seek( tab_count )
    int     tab_count;
{
    if ( tab_count <= tab_at ) {
        putc( '\n', stdout );
        tab_count -= tab_offset;
        tab_offset = 0;
        tab_at = 0;
        col_cnt = 0;
    }
    if ( tab_at == 0 ) {
        tab_at = 1;
    }

    while( tab_at < tab_count ) {
        putc( '\t', stdout );
        tab_at++;
        col_cnt = (tab_at - 1) << 3;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0xfdc3(%rip), %eax      # 0x1c1b4
cmpl %edi, %eax
jge 0xc3fb
testl %eax, %eax
jne 0xc42d
jmp 0xc420
movq 0xbbce(%rip), %rax      # 0x17fd0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x9130
leaq 0xfae0(%rip), %rax      # 0x1bef4
subl (%rax), %ebx
andl $0x0, (%rax)
andl $0x0, 0xfd98(%rip)      # 0x1c1b8
movl $0x1, 0xfd8a(%rip)      # 0x1c1b4
pushq $0x1
popq %rax
movq 0xbb9c(%rip), %r14      # 0x17fd0
pushq $0x9
popq %rbp
cmpl %ebx, %eax
jge 0xc45f
movq (%r14), %rsi
movl %ebp, %edi
callq 0x9130
movl 0xfd69(%rip), %ecx      # 0x1c1b4
leal 0x1(%rcx), %eax
movl %eax, 0xfd60(%rip)      # 0x1c1b4
shll $0x3, %ecx
movl %ecx, 0xfd5b(%rip)      # 0x1c1b8
jmp 0xc437
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/ooutput.c
// Function: out_operand
void out_operand( operand )
    char    *operand;
{
    if ( strcmp(operand,"") ) {
        tab_next();                 /* Indent to next tab stop */
        printf( "%s", operand );
        tab_count( operand );
    }
}

// Assembly:
cmpb $0x0, (%rdi)
je 0xc4ee
pushq %rbx
movq %rdi, %rbx
callq 0xc464
leaq 0x5d67(%rip), %rdi      # 0x12242
movq %rbx, %rsi
xorl %eax, %eax
callq 0x90d0
movq %rbx, %rdi
popq %rbx
jmp 0xc3a8
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/ooutput.c
// Function: out_comment
void out_comment( comment )
    char    *comment;
{
    if ( strcmp(comment,"") ) {
        tab_seek( 7 );          /* Indent to next tab stop */
        printf( "; %s", comment );
        col_cnt += 2;
        tab_count( comment );
    }
}

// Assembly:
cmpb $0x0, (%rdi)
je 0xc521
pushq %rbx
movq %rdi, %rbx
pushq $0x7
popq %rdi
callq 0xc3e5
leaq 0x6706(%rip), %rdi      # 0x12c0d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x90d0
addl $0x2, 0xfca0(%rip)      # 0x1c1b8
movq %rbx, %rdi
popq %rbx
jmp 0xc3a8
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/ooutput.c
// Function: out_endline
void out_endline()
{
    putc( '\n', stdout );
    tab_offset = 0;
    tab_at = 0;
    col_cnt = 0;
}

// Assembly:
pushq %rax
movq 0xbaa6(%rip), %rax      # 0x17fd0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x9130
leaq 0xf9b8(%rip), %rax      # 0x1bef4
andl $0x0, (%rax)
andl $0x0, 0xfc6e(%rip)      # 0x1c1b4
andl $0x0, 0xfc6b(%rip)      # 0x1c1b8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/ooutput.c
// Function: out_directive
void out_directive( direct )
    char    *direct;
{
    tab_next();
    if ( tab_at < 2 ) {
        tab_next();
    }
    printf( "%s", direct );
    tab_count( direct );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xc464
cmpl $0x1, 0xfc50(%rip)      # 0x1c1b4
jg 0xc56b
callq 0xc464
leaq 0x5cd0(%rip), %rdi      # 0x12242
movq %rbx, %rsi
xorl %eax, %eax
callq 0x90d0
movq %rbx, %rdi
popq %rbx
jmp 0xc3a8
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/ooutput.c
// Function: out_line
void out_line( label, opcode, operand, comment )
    char    *label;
    char    *opcode;
    char    *operand;
    char    *comment;
{
    out_label( label );
    out_directive( opcode );
    out_operand( operand );
    out_comment( comment );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0xc471
movq %r15, %rdi
callq 0xc554
movq %r14, %rdi
callq 0xc4c6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc4ef
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oprocess.c
// Function: lone_public
void lone_public()
{
    char    operand[80];
    long    relative;

    if ( pass == 3 ) {
        out_label( pub_rec->name );
        out_directive( "=" );
        if ( segment == 0 ) {
            sprintf( operand, "0%04Xh", pub_rec->offset );
        } else {
            relative = (long)pub_rec->offset - inst_offset;
            if ( relative < 0L ) {
                sprintf( operand, "$ - 0%04lXh", -relative );
            } else {
                sprintf( operand, "$ + 0%04lXh", relative );
            }
        }
        out_operand( operand );
        out_endline();
    }
}

// Assembly:
leaq 0xf89b(%rip), %rax      # 0x1bf68
cmpl $0x3, (%rax)
jne 0xc74d
pushq %rbx
subq $0x50, %rsp
leaq 0xf9aa(%rip), %rbx      # 0x1c088
movq (%rbx), %rdi
addq $0x10, %rdi
callq 0xc471
leaq 0x5f09(%rip), %rdi      # 0x125fa
callq 0xc554
leaq 0xfa93(%rip), %rax      # 0x1c190
cmpl $0x0, (%rax)
movq (%rbx), %rax
movq 0x8(%rax), %rdx
je 0xc71e
leaq 0xfa88(%rip), %rax      # 0x1c198
subq (%rax), %rdx
js 0xc727
leaq 0x655c(%rip), %rsi      # 0x12c78
jmp 0xc731
leaq 0x6592(%rip), %rsi      # 0x12cb7
jmp 0xc731
negq %rdx
leaq 0x653b(%rip), %rsi      # 0x12c6c
movq %rsp, %rdi
xorl %eax, %eax
callq 0x91b0
movq %rsp, %rdi
callq 0xc4c6
callq 0xc522
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oprocess.c
// Function: data_byte
void data_byte( size )
    int     size;
{
    char    *opcode;
    int     out_count;
    int     times;
    char    operand[50];
    char    rev_buff[10];
    char    temp[4];

    if ( last_pub_rec && pass == 3 ) {
        if ( last_pub_rec->type == FAR ) {
            out_directive("=");
            out_operand("$");
        }
        if ( last_pub_rec->type == NEAR ) {
            out_endline();
        }
    }

    opcode = size_to_opcode( size, &times );

    while ( times ) {
        out_count = 0;
        strcpy( operand, "0" );
        while ( out_count < size ) {
            rev_buff[ out_count ] = (uchar)buff_regetc();
            out_count++;
        }
        out_count = size;
        while ( out_count ) {
            --out_count;
            sprintf( temp, "%02X", (uchar)rev_buff[out_count] );
            strcat( operand, temp );
        }
        strcat( operand, "h" );
        if ( pass == 3 ) {
            out_directive( opcode );
            out_operand( operand );
            out_endline();
        }
        --times;
    }
    last_pub_rec = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edi, %r15d
leaq 0xf7a8(%rip), %rbx      # 0x1c090
movq (%rbx), %rax
testq %rax, %rax
je 0xc92c
leaq 0xf671(%rip), %rcx      # 0x1bf68
cmpl $0x3, (%rcx)
jne 0xc92c
movl 0x38(%rax), %eax
cmpl $0x2, %eax
jne 0xc922
leaq 0x5cef(%rip), %rdi      # 0x125fa
callq 0xc554
leaq 0x636d(%rip), %rdi      # 0x12c84
callq 0xc4c6
movq (%rbx), %rax
movl 0x38(%rax), %eax
cmpl $0x1, %eax
jne 0xc92c
callq 0xc522
leaq 0x4(%rsp), %r14
movl %r15d, %edi
movq %r14, %rsi
callq 0xef12
movq %rax, 0x8(%rsp)
movl (%r14), %eax
testl %r15d, %r15d
movl $0x0, %ebp
cmovgl %r15d, %ebp
movslq %r15d, %r13
leaq 0x20(%rsp), %r14
leaq 0x6f3c(%rip), %r15      # 0x1389b
leaq 0x12(%rsp), %r12
testl %eax, %eax
je 0xc9f7
movw $0x30, 0x20(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0xc988
callq 0xec15
movb %al, 0x16(%rsp,%rbx)
incq %rbx
jmp 0xc975
movq %r13, %rax
movq %r13, %rbx
subq $0x1, %rbx
jb 0xc9b6
movzbl 0x15(%rsp,%rax), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x91b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x91a0
movq %rbx, %rax
jmp 0xc98e
movq %r14, %rdi
callq 0x90b0
movw $0x68, 0x20(%rsp,%rax)
leaq 0xf59c(%rip), %rax      # 0x1bf68
cmpl $0x3, (%rax)
jne 0xc9e8
movq 0x8(%rsp), %rdi
callq 0xc554
movq %r14, %rdi
callq 0xc4c6
callq 0xc522
movl 0x4(%rsp), %eax
decl %eax
movl %eax, 0x4(%rsp)
jmp 0xc964
leaq 0xf692(%rip), %rax      # 0x1c090
andq $0x0, (%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oprocess.c
// Function: proc_fixup
int proc_fixup()
{
    int     fix_size;
    int     fix_form;
    int     fix_extended;
    char    operand[100];
    int     dummy;

    fix_form     = fix_rec->form;
    fix_extended = fix_rec->extended;

    if ( fix_form == POINTER ) {
        fix_size = get_fix( operand, 2, FALSE, segment_bytes,
                                                    FAR, FALSE, &dummy, DS );
    } else {
        fix_size = get_fix( operand, 2, FALSE, segment_bytes,
                                                    NEAR, FALSE, &dummy, DS );
    }

    if ( pass == 3 ) {
        if ( fix_form == OFFSET && fix_extended ) {
            out_directive( "dd" );
        } else {
            if ( fix_form == POINTER && fix_extended ) {
                out_directive( "df" );
            } else {
                out_directive( fix_type[fix_form].form );
            }
        }
    }
    inst_offset += fix_size;

    if ( pass == 3 ) {
        out_operand( operand );
        out_endline();
    }
    buff_empty();
    if ( last_pub_rec ) {
        last_pub_rec->type = size_to_type(fix_size);
        last_pub_rec = NULL;
    }
    return( fix_size );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0xef68(%rip), %rax      # 0x1c118
movq (%rax), %rax
movslq 0x18(%rax), %r14
xorl %r8d, %r8d
cmpq $0x3, %r14
sete %r8b
movl 0x38(%rax), %ebp
leaq 0xefd8(%rip), %rax      # 0x1c1a4
movl (%rax), %ecx
incl %r8d
leaq 0xc(%rsp), %rax
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rsi
xorl %edx, %edx
xorl %r9d, %r9d
pushq $0x14
pushq %rax
callq 0xfad9
popq %rcx
popq %rdx
movl %eax, %ebx
leaq 0xed72(%rip), %r15      # 0x1bf68
cmpl $0x3, (%r15)
jne 0xd218
cmpl $0x1, %r14d
sete %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xd227
leaq 0x5348(%rip), %rdi      # 0x1255e
jmp 0xd253
movslq %ebx, %rax
leaq 0xef76(%rip), %rcx      # 0x1c198
addq %rax, (%rcx)
jmp 0xd27c
testl %ebp, %ebp
setne %al
cmpl $0x3, %r14d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xd243
leaq 0x5a85(%rip), %rdi      # 0x12cc6
jmp 0xd253
imulq $0x18, %r14, %rax
leaq 0xeb12(%rip), %rcx      # 0x1bd60
movq 0x8(%rcx,%rax), %rdi
callq 0xc554
movl (%r15), %eax
movslq %ebx, %rcx
leaq 0xef33(%rip), %rdx      # 0x1c198
addq %rcx, (%rdx)
cmpl $0x3, %eax
jne 0xd27c
leaq 0x10(%rsp), %rdi
callq 0xc4c6
callq 0xc522
callq 0xed09
leaq 0xee08(%rip), %r14      # 0x1c090
cmpq $0x0, (%r14)
je 0xd29f
movl %ebx, %edi
callq 0xeeb8
movq (%r14), %rcx
movl %eax, 0x38(%rcx)
andq $0x0, (%r14)
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oprocess.c
// Function: proc_drec
void proc_drec(DAT_T *data_rec, DAT_T *next_rec, int inst_proc)
{
    int     orgable;

#ifdef DEBUG
    printf("DIS-ASSEMBLY offset %04X\n", data_rec->offset );
#endif
    if ( pass == 3 ) {
        out_newline();
    }
    /*
    ** Do we need an ORG statement or dup(?)'s ?
    */
    if ( inst_offset != data_rec->offset+record_overused ) {
        pub_search.seg_idx = segment;
        pub_search.offset = data_rec->offset+record_overused;
        orgable = TRUE;
        while ( pub_node != public_tree 
                && pub_compare(&pub_search,pub_rec) == LEFT ) {
            pre_dups( pub_rec->offset - inst_offset, orgable );
            proc_label();
            orgable = FALSE;
        }
        pre_dups( data_rec->offset+record_overused - inst_offset, orgable );
    }
    data_offset = data_rec->offset;

    switch( data_rec->type ) {
        case ENUMERATED:
            enumerated( data_rec, next_rec, inst_proc );
            break;
        case ITERATED:
            iterated( data_rec, next_rec );
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe2c7(%rip), %rax      # 0x1bf68
cmpl $0x3, (%rax)
jne 0xdcab
callq 0xc54f
leaq 0xe4e6(%rip), %r13      # 0x1c198
movl 0x4(%r15), %ecx
movl 0xe8e4(%rip), %eax      # 0x1c5a0
addl %ecx, %eax
cmpq %rax, (%r13)
je 0xdd66
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl %ebx, 0x4(%rsp)
leaq 0xe4b3(%rip), %rcx      # 0x1c190
movl (%rcx), %ecx
leaq 0xe3b2(%rip), %r12      # 0x1c098
movl %ecx, (%r12)
movq %rax, 0x8(%r12)
pushq $0x1
popq %rbp
leaq 0xe387(%rip), %rbx      # 0x1c080
leaq 0xe2a8(%rip), %r14      # 0x1bfa8
leaq 0xe381(%rip), %r15      # 0x1c088
movq (%rbx), %rax
cmpq (%r14), %rax
je 0xdd3c
movq (%r15), %rsi
movq %r12, %rdi
callq 0x113c0
movq (%r13), %rcx
testl %eax, %eax
jne 0xdd40
movq (%r15), %rax
movq 0x8(%rax), %rdi
subq %rcx, %rdi
movl %ebp, %esi
callq 0xca11
callq 0xd050
xorl %ebp, %ebp
jmp 0xdd07
movq (%r13), %rcx
movl 0xe85a(%rip), %edi      # 0x1c5a0
movq 0x8(%rsp), %r15
addl 0x4(%r15), %edi
subq %rcx, %rdi
movl %ebp, %esi
callq 0xca11
movl 0x4(%r15), %ecx
movl 0x4(%rsp), %ebx
movq 0x10(%rsp), %r14
movl %ecx, %eax
leaq 0xf921(%rip), %rcx      # 0x1d690
movq %rax, (%rcx)
movl 0x8(%r15), %eax
cmpl $0x1, %eax
je 0xdd9a
testl %eax, %eax
jne 0xddb0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdb29
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd8eb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oprocess.c
// Function: list_sex
NODE_T *list_sex(NODE_T *node, int seg_num)
{
    SEX_T   *sex_rec;
    EXT_T   *ext_rec;

    sex_rec = (SEX_T *)node->data;
    while ( node != sex_tree && sex_rec->seg_index < seg_num ) {
        node = traverse( node, RIGHT );
        sex_rec = (SEX_T *)node->data;
    }
    out_newline();
    while ( node != sex_tree && sex_rec->seg_index == seg_num ) {
        ext_rec = sex_rec->ext_rec;
        if ( ext_rec->used == seg_num ) {       /* Still in this segment? */
            print_ext( sex_rec->ext_rec );
        }
        node = traverse( node, RIGHT );
        sex_rec = (SEX_T *)node->data;
    }
    return( node );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xe1e5(%rip), %r15      # 0x1bfb8
pushq $0x1
popq %rbp
movq 0x20(%r14), %r12
cmpq (%r15), %r14
je 0xddf4
cmpl %ebx, (%r12)
jge 0xddf4
movq %r14, %rdi
movl %ebp, %esi
callq 0x11ebc
movq %rax, %r14
jmp 0xddd6
callq 0xc54f
pushq $0x1
popq %rbp
cmpq (%r15), %r14
je 0xde29
cmpl %ebx, (%r12)
jne 0xde29
movq 0x8(%r12), %rdi
cmpl %ebx, 0x48(%rdi)
jne 0xde16
callq 0xe4a0
movq %r14, %rdi
movl %ebp, %esi
callq 0x11ebc
movq %rax, %r14
movq 0x20(%rax), %r12
jmp 0xddfc
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oreport.c
// Function: list_ext
void list_ext()
{
    NODE_T          *seg_node;
    NODE_T          *ext_node;
    EXT_T           *ext_rec;
    int             data_index;

    data_index = 0;
    seg_node = start( segment_tree, RIGHT );
    while ( seg_node != segment_tree ) {
        seg_rec = (SEG_T *)seg_node->data;
        if ( stricmp(seg_rec->class->name, "DATA") == 0 ) {
            data_index = seg_rec->index;
            break;
        }
        seg_node = traverse( seg_node, RIGHT );
    }

    out_newline();
    ext_node = start( extern_tree, LEFT );
    while ( ext_node != extern_tree ) {
        ext_rec = (EXT_T *)ext_node->data;
        if ( ext_rec->used == 0 || ext_rec->used == -1 ) {
            if ( compatibility == 2 && data_index != 0 ) {
                if ( ext_rec->type == 2 || ext_rec->type == 3 ||
                     ext_rec->type == 4 || ext_rec->type == 5 ) {
                    if ( ext_rec->used == 0 ) {
                        sex_insert( data_index, ext_rec );
                        ext_rec->used = data_index;
                    }
                } else {
                    print_ext( ext_rec );
                }
            } else {
                print_ext( ext_rec );
            }
        }
        ext_node = traverse( ext_node, LEFT );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xd996(%rip), %r12      # 0x1bf98
movq (%r12), %rdi
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x11e9b
movq %rax, %r15
leaq 0xd9d6(%rip), %r13      # 0x1bff0
leaq 0x3f5e(%rip), %r14      # 0x1257f
cmpq (%r12), %r15
je 0xe652
movq 0x20(%r15), %rbp
movq %rbp, (%r13)
movq 0x8(%rbp), %rdi
addq $0x4, %rdi
movq %r14, %rsi
callq 0x9050
testl %eax, %eax
je 0xe656
movq %r15, %rdi
movl %ebx, %esi
callq 0x11ebc
movq %rax, %r15
jmp 0xe621
xorl %ebx, %ebx
jmp 0xe659
movl (%rbp), %ebx
callq 0xc54f
leaq 0xd94b(%rip), %r12      # 0x1bfb0
movq (%r12), %rdi
xorl %esi, %esi
callq 0x11e9b
movq %rax, %r14
leaq 0xd87e(%rip), %r13      # 0x1bef8
cmpq (%r12), %r14
je 0xe6d2
movq 0x20(%r14), %r15
movl 0x48(%r15), %eax
leal 0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0xe6c3
cmpl $0x2, (%r13)
jne 0xe6bb
testl %ebx, %ebx
je 0xe6bb
movl 0x2c(%r15), %ecx
addl $-0x2, %ecx
cmpl $0x3, %ecx
ja 0xe6bb
testl %eax, %eax
jne 0xe6c3
movl %ebx, %edi
movq %r15, %rsi
callq 0xee83
movl %ebx, 0x48(%r15)
jmp 0xe6c3
movq %r15, %rdi
callq 0xe4a0
movq %r14, %rdi
xorl %esi, %esi
callq 0x11ebc
movq %rax, %r14
jmp 0xe67a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oreport.c
// Function: list_pub
void list_pub()
{
    NODE_T          *pub_node;
    PUB_T           *pub_rec;
    char            comment[50];
    char            *label;

    out_newline();
    pub_node = start( public_tree, RIGHT );
    while ( pub_node != public_tree ) {
        pub_rec = (PUB_T *)pub_node->data;
        if ( pub_rec->scope ) {
            label = "";
        } else {
            label = ";Static";
        }
        if ( pub_rec->domain == PUBLIC ) {
            sprintf( comment, "Located at %d:%04lXh Type = %d", pub_rec->seg_idx, pub_rec->offset, pub_rec->type );
            out_label( label );
            out_opcode( "PUBLIC" );
            tab_seek(3);
            out_operand( pub_rec->name );
            out_comment( comment );
        } else {
#ifdef DEBUG
            sprintf( comment, "Located at %d:%04lXh Type = %d", pub_rec->seg_idx, pub_rec->offset, pub_rec->type );
            out_label( label );
            out_opcode( "PRIV" );
            tab_seek(3);
            out_operand( pub_rec->name );
            out_comment( comment );
#endif
        }
        pub_node = traverse( pub_node, RIGHT );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0xc54f
leaq 0xd8ad(%rip), %rbp      # 0x1bfa8
movq (%rbp), %rdi
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x11e9b
movq %rax, %r15
movq %rsp, %r12
cmpq (%rbp), %r15
je 0xe799
movq 0x20(%r15), %r14
cmpl $0x1, 0x3c(%r14)
jne 0xe787
cmpl $0x0, 0x40(%r14)
leaq 0x49dc(%rip), %r13      # 0x1310c
leaq 0x4800(%rip), %rax      # 0x12f37
cmoveq %rax, %r13
movl (%r14), %edx
movq 0x8(%r14), %rcx
movl 0x38(%r14), %r8d
movq %r12, %rdi
leaq 0x4832(%rip), %rsi      # 0x12f82
xorl %eax, %eax
callq 0x91b0
movq %r13, %rdi
callq 0xc471
leaq 0x483b(%rip), %rdi      # 0x12fa1
callq 0xc497
pushq $0x3
popq %rdi
callq 0xc3e5
addq $0x10, %r14
movq %r14, %rdi
callq 0xc4c6
movq %r12, %rdi
callq 0xc4ef
movq %r15, %rdi
movl %ebx, %esi
callq 0x11ebc
movq %rax, %r15
jmp 0xe70f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oreport.c
// Function: list_fix
void list_fix()
{
    NODE_T          *fix_node;
    FIX_T           *fix_rec;
    char            comment[50];

    out_newline();
    fix_node = start( fix_tree, RIGHT );
    while ( fix_node != fix_tree ) {
        fix_rec = (FIX_T *)fix_node->data;
        sprintf( comment, "Fixup at 0%02Xh:0%04Xh:0%04Xh", fix_rec->seg_idx,
                fix_rec->dat_offset, fix_rec->offset );
        out_line( "", ";", comment, "" );
        fix_node = traverse( fix_node, RIGHT );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0xc54f
leaq 0xd68e(%rip), %rax      # 0x1bfd0
movq (%rax), %rdi
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x11e9b
movq %rax, %r12
leaq 0x4666(%rip), %r14      # 0x12fbf
movq %rsp, %r15
leaq 0x4569(%rip), %r13      # 0x12ecc
leaq 0x47a2(%rip), %rbp      # 0x1310c
leaq 0xd65f(%rip), %rax      # 0x1bfd0
cmpq (%rax), %r12
je 0xe9b2
movq 0x20(%r12), %rax
movl (%rax), %edx
movq 0x8(%rax), %rcx
movl 0x10(%rax), %r8d
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x91b0
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0xc585
movq %r12, %rdi
movl %ebx, %esi
callq 0x11ebc
movq %rax, %r12
jmp 0xe96a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oubuff.c
// Function: buff_regetc
int buff_regetc()
{
    int     result;

    if ( buff_beg == buff_end ) {                          /* Buffer empty? */
        result = EOF;
    } else {
        result = *buff_beg++;
        buff_cur = buff_beg;
    }
    return( result );
}

// Assembly:
movq 0xe9b4(%rip), %rax      # 0x1d5d0
cmpq 0xe9bd(%rip), %rax      # 0x1d5e0
je 0xec3b
leaq 0x1(%rax), %rcx
movq %rcx, 0xe9a0(%rip)      # 0x1d5d0
movsbl (%rax), %eax
movq %rcx, 0xe99e(%rip)      # 0x1d5d8
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/Nico01[P]obj2asm/oubuff.c
// Function: buff_init
int buff_init( length )
    int     length;
{
    if ( length > BUFFSIZE ) fmt_error("Record too large");
    buff_beg = &buff[0];
    buff_cur = buff_beg;
    length = fread( buff_beg, sizeof(char), length, o_file );
    buff_end = buff_beg + length;  /* Last character will be at buff[length-1] */
    return( length );
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x1011, %edi           # imm = 0x1011
jl 0xec56
leaq 0x439f(%rip), %rdi      # 0x12ff0
callq 0x11eec
leaq 0xd963(%rip), %rdi      # 0x1c5c0
movq %rdi, 0xe96c(%rip)      # 0x1d5d0
movq %rdi, 0xe96d(%rip)      # 0x1d5d8
movslq %ebx, %rdx
leaq 0xd2e3(%rip), %rax      # 0x1bf58
movq (%rax), %rcx
pushq $0x1
popq %rsi
callq 0x9090
cltq
movq 0xe947(%rip), %rcx      # 0x1d5d0
addq %rax, %rcx
movq %rcx, 0xe94d(%rip)      # 0x1d5e0
popq %rbx
retq