LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %edi
addl $0x2, %edi
callq 0xe580
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0xbca4
movq -0x30(%rbp), %rax
leaq 0xb498(%rip), %rcx      # 0x170b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xbcab
movl $0x1, -0x4(%rbp)
jmp 0xbcab
leaq -0x28(%rbp), %rdi
callq 0x9460
cmpl $0x0, %eax
je 0xbc4e
movl $0x1, -0x4(%rbp)
jmp 0xbcab
cmpl $0x0, -0x18(%rbp)
je 0xbc90
cmpq $0x7f, -0x28(%rbp)
ja 0xbc73
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xb664(%rip), %rsi      # 0x172ce
movb $0x0, %al
callq 0x9190
jmp 0xbc8e
movq -0x10(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
subq -0x28(%rbp), %rdx
leaq 0xb652(%rip), %rsi      # 0x172d9
movb $0x0, %al
callq 0x9190
jmp 0xbca2
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0xe320
jmp 0xbca4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
addl $0x2, %edi
callq 0xe580
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0xbdc7
movq -0x30(%rbp), %rax
leaq 0xb3cb(%rip), %rcx      # 0x170c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xbdce
leaq 0x145d3(%rip), %rax     # 0x202e8
movq (%rax), %rax
cmpl $0x0, 0x3c(%rax)
je 0xbd65
leaq 0x145c3(%rip), %rax     # 0x202e8
movq (%rax), %rax
movl 0x38(%rax), %eax
cmpl 0x1432f(%rip), %eax     # 0x20060
jne 0xbd65
movq -0x10(%rbp), %rdi
movl 0x10d3f(%rip), %ecx     # 0x1ca7c
movl $0x2, %esi
movl $0x1, %r8d
xorl %r9d, %r9d
leaq -0x1c(%rbp), %rax
movl %r8d, %edx
movq %rax, (%rsp)
movl $0x14, 0x8(%rsp)
callq 0x13210
jmp 0xbd6e
movl $0x1, -0x4(%rbp)
jmp 0xbdce
jmp 0xbdc7
movl $0x1, -0x4(%rbp)
jmp 0xbdce
movl 0x142dd(%rip), %esi     # 0x2005c
leaq -0x28(%rbp), %rdi
callq 0x95e0
cmpl $0x0, %eax
je 0xbd96
movl $0x1, -0x4(%rbp)
jmp 0xbdce
cmpl $0x0, 0x142bf(%rip)     # 0x2005c
je 0xbdb3
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0xe320
jmp 0xbdc5
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0xe320
jmp 0xbdc7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/oextra.c
// Function: hint_compare
int hint_compare( rec_1, rec_2 )
    HINT_T  *rec_1;
    HINT_T  *rec_2;
{
    if ( rec_1->seg_idx > rec_2->seg_idx ) {
        return( LEFT );
    } else {
        if ( rec_1->seg_idx < rec_2->seg_idx ) {
            return( RIGHT );
        } else {
            if ( rec_1->offset > rec_2->offset ) {
                return( LEFT );
            } else {
                if ( rec_1->offset < rec_2->offset ) {
                    return( RIGHT );
                } else {
                    return( EQUAL );
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xcab3
movl $0x0, -0x4(%rbp)
jmp 0xcb07
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xcaca
movl $0x1, -0x4(%rbp)
jmp 0xcb07
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xcae5
movl $0x0, -0x4(%rbp)
jmp 0xcb07
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xcb00
movl $0x1, -0x4(%rbp)
jmp 0xcb07
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x18, %edi
callq 0x16e40
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
leaq 0x1363e(%rip), %rax     # 0x201a8
movq (%rax), %rsi
leaq -0xe4(%rip), %rdx       # 0xca90
callq 0x16820
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x90a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xe014
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0xdfee
movl 0x123a8(%rip), %eax     # 0x20388
orl $0x7, %eax
addl $0x1, %eax
movl %eax, 0x1239c(%rip)     # 0x20388
jmp 0xdffd
movl 0x12394(%rip), %eax     # 0x20388
addl $0x1, %eax
movl %eax, 0x1238b(%rip)     # 0x20388
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdfc8
movl 0x1236e(%rip), %eax     # 0x20388
sarl $0x3, %eax
addl $0x1, %eax
movl %eax, 0x1235e(%rip)     # 0x20384
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x12340(%rip), %eax     # 0x20384
jg 0xe08c
movq 0xdf8b(%rip), %rax      # 0x1bfd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x9110
leaq 0x12063(%rip), %rax     # 0x200c4
movl (%rax), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
leaq 0x12052(%rip), %rax     # 0x200c4
movl $0x0, (%rax)
movl $0x0, 0x12302(%rip)     # 0x20384
movl $0x0, 0x122fc(%rip)     # 0x20388
cmpl $0x0, 0x122f1(%rip)     # 0x20384
jne 0xe09f
movl $0x1, 0x122e5(%rip)     # 0x20384
jmp 0xe0a1
movl 0x122dd(%rip), %eax     # 0x20384
cmpl -0x4(%rbp), %eax
jge 0xe0e3
movq 0xdf25(%rip), %rax      # 0x1bfd8
movq (%rax), %rsi
movl $0x9, %edi
callq 0x9110
movl 0x122be(%rip), %eax     # 0x20384
addl $0x1, %eax
movl %eax, 0x122b5(%rip)     # 0x20384
movl 0x122af(%rip), %eax     # 0x20384
subl $0x1, %eax
shll $0x3, %eax
movl %eax, 0x122a7(%rip)     # 0x20388
jmp 0xe0a1
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa019(%rip), %rsi      # 0x181c0
callq 0x9100
cmpl $0x0, %eax
je 0xe1d1
callq 0xe0f0
movq -0x8(%rbp), %rsi
leaq 0x90fd(%rip), %rdi      # 0x172be
movb $0x0, %al
callq 0x90c0
movq -0x8(%rbp), %rdi
callq 0xdfb0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9fc9(%rip), %rsi      # 0x181c0
callq 0x9100
cmpl $0x0, %eax
je 0xe235
movl $0x7, %edi
callq 0xe030
movq -0x8(%rbp), %rsi
leaq 0x9a8d(%rip), %rdi      # 0x17ca3
movb $0x0, %al
callq 0x90c0
movl 0x12165(%rip), %eax     # 0x20388
addl $0x2, %eax
movl %eax, 0x1215c(%rip)     # 0x20388
movq -0x8(%rbp), %rdi
callq 0xdfb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0xdd8d(%rip), %rax      # 0x1bfd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x9110
leaq 0x11e65(%rip), %rax     # 0x200c4
movl $0x0, (%rax)
movl $0x0, 0x12115(%rip)     # 0x20384
movl $0x0, 0x1210f(%rip)     # 0x20388
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xe0f0
cmpl $0x2, 0x120dc(%rip)     # 0x20384
jge 0xe2af
callq 0xe0f0
movq -0x8(%rbp), %rsi
leaq 0x9004(%rip), %rdi      # 0x172be
movb $0x0, %al
callq 0x90c0
movq -0x8(%rbp), %rdi
callq 0xdfb0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe110
movq -0x10(%rbp), %rdi
callq 0xe290
movq -0x18(%rbp), %rdi
callq 0xe190
movq -0x20(%rbp), %rdi
callq 0xe1e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x11c79(%rip), %rax     # 0x20138
cmpl $0x3, (%rax)
jne 0xe57a
leaq 0x11d89(%rip), %rax     # 0x20258
movq (%rax), %rdi
addq $0x10, %rdi
callq 0xe110
leaq 0x90bf(%rip), %rdi      # 0x175a1
callq 0xe290
leaq 0x11e72(%rip), %rax     # 0x20360
cmpl $0x0, (%rax)
jne 0xe515
leaq -0x50(%rbp), %rdi
leaq 0x11d5a(%rip), %rax     # 0x20258
movq (%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x9849(%rip), %rsi      # 0x17d55
movb $0x0, %al
callq 0x9190
jmp 0xe56c
leaq 0x11d3c(%rip), %rax     # 0x20258
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x11e3e(%rip), %rcx     # 0x20368
subq (%rcx), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jge 0xe554
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
subq -0x58(%rbp), %rdx
leaq 0x97b5(%rip), %rsi      # 0x17d00
movb $0x0, %al
callq 0x9190
jmp 0xe56a
leaq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x97a9(%rip), %rsi      # 0x17d0c
movb $0x0, %al
callq 0x9190
jmp 0xe56c
leaq -0x50(%rbp), %rdi
callq 0xe190
callq 0xe240
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
leaq 0x11a5e(%rip), %rax     # 0x20260
cmpq $0x0, (%rax)
je 0xe853
leaq 0x11929(%rip), %rax     # 0x20138
cmpl $0x3, (%rax)
jne 0xe853
leaq 0x11a45(%rip), %rax     # 0x20260
movq (%rax), %rax
cmpl $0x2, 0x38(%rax)
jne 0xe83c
leaq 0x8d76(%rip), %rdi      # 0x175a1
callq 0xe290
leaq 0x94e1(%rip), %rdi      # 0x17d18
callq 0xe190
leaq 0x11a1d(%rip), %rax     # 0x20260
movq (%rax), %rax
cmpl $0x1, 0x38(%rax)
jne 0xe851
callq 0xe240
jmp 0xe853
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
callq 0x11fb0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xe926
movl $0x0, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x88cc(%rip), %rsi      # 0x1714b
callq 0x9060
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xe8a6
callq 0x11910
movb %al, %cl
movslq -0x14(%rbp), %rax
movb %cl, -0x5a(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe884
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xe8e5
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x5e(%rbp), %rdi
movslq -0x14(%rbp), %rax
movzbl -0x5a(%rbp,%rax), %edx
leaq 0x9ff0(%rip), %rsi      # 0x188bf
movb $0x0, %al
callq 0x9190
leaq -0x50(%rbp), %rdi
leaq -0x5e(%rbp), %rsi
callq 0x9180
jmp 0xe8ac
leaq -0x50(%rbp), %rdi
leaq 0x9794(%rip), %rsi      # 0x18084
callq 0x9180
leaq 0x1183c(%rip), %rax     # 0x20138
cmpl $0x3, (%rax)
jne 0xe918
movq -0x10(%rbp), %rdi
callq 0xe290
leaq -0x50(%rbp), %rdi
callq 0xe190
callq 0xe240
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe863
leaq 0x11933(%rip), %rax     # 0x20260
movq $0x0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10f36(%rip), %rax     # 0x202e8
movq (%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x10f26(%rip), %rax     # 0x202e8
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x3, -0x8(%rbp)
jne 0xf407
leaq -0x70(%rbp), %rdi
leaq 0x10f98(%rip), %rax     # 0x20374
movl (%rax), %ecx
movl $0x2, %r8d
xorl %r9d, %r9d
leaq -0x74(%rbp), %rax
movl %r8d, %esi
movl %r9d, %edx
movq %rax, (%rsp)
movl $0x14, 0x8(%rsp)
callq 0x13210
movl %eax, -0x4(%rbp)
jmp 0xf43d
leaq -0x70(%rbp), %rdi
leaq 0x10f62(%rip), %rax     # 0x20374
movl (%rax), %ecx
movl $0x2, %esi
xorl %r9d, %r9d
movl $0x1, %r8d
leaq -0x74(%rbp), %rax
movl %r9d, %edx
movq %rax, (%rsp)
movl $0x14, 0x8(%rsp)
callq 0x13210
movl %eax, -0x4(%rbp)
leaq 0x10cf4(%rip), %rax     # 0x20138
cmpl $0x3, (%rax)
jne 0xf49c
cmpl $0x1, -0x8(%rbp)
jne 0xf463
cmpl $0x0, -0xc(%rbp)
je 0xf463
leaq 0x80a9(%rip), %rdi      # 0x17505
callq 0xe290
jmp 0xf49a
cmpl $0x3, -0x8(%rbp)
jne 0xf47d
cmpl $0x0, -0xc(%rbp)
je 0xf47d
leaq 0x88ee(%rip), %rdi      # 0x17d64
callq 0xe290
jmp 0xf498
movslq -0x8(%rbp), %rcx
leaq 0x10a08(%rip), %rax     # 0x1fe90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0xe290
jmp 0xf49a
jmp 0xf49c
movslq -0x4(%rbp), %rcx
leaq 0x10ec1(%rip), %rax     # 0x20368
addq (%rax), %rcx
leaq 0x10eb7(%rip), %rax     # 0x20368
movq %rcx, (%rax)
leaq 0x10c7d(%rip), %rax     # 0x20138
cmpl $0x3, (%rax)
jne 0xf4ce
leaq -0x70(%rbp), %rdi
callq 0xe190
callq 0xe240
callq 0x11ab0
leaq 0x10d86(%rip), %rax     # 0x20260
cmpq $0x0, (%rax)
je 0xf505
movl -0x4(%rbp), %edi
callq 0x11de0
movl %eax, %ecx
leaq 0x10d6f(%rip), %rax     # 0x20260
movq (%rax), %rax
movl %ecx, 0x38(%rax)
leaq 0x10d62(%rip), %rax     # 0x20260
movq $0x0, (%rax)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0xfd6e(%rip), %rax      # 0x20138
cmpl $0x3, (%rax)
jne 0x103d4
callq 0xe280
leaq 0xff8d(%rip), %rax      # 0x20368
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl 0x10385(%rip), %ecx     # 0x20770
movl %ecx, %ecx
cmpq %rcx, %rax
je 0x104bf
leaq 0xff63(%rip), %rax      # 0x20360
movl (%rax), %ecx
leaq 0xfe62(%rip), %rax      # 0x20268
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl 0x1035b(%rip), %eax     # 0x20770
movl %eax, %eax
movl %eax, %ecx
leaq 0xfe48(%rip), %rax      # 0x20268
movq %rcx, 0x8(%rax)
movl $0x1, -0x18(%rbp)
leaq 0xfe1e(%rip), %rax      # 0x20250
movq (%rax), %rcx
xorl %eax, %eax
leaq 0xfd3a(%rip), %rdx      # 0x20178
cmpq (%rdx), %rcx
movb %al, -0x19(%rbp)
je 0x10465
leaq 0xfe0b(%rip), %rax      # 0x20258
movq (%rax), %rsi
leaq 0xfe11(%rip), %rdi      # 0x20268
callq 0x15a10
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1046e
jmp 0x1049c
leaq 0xfde3(%rip), %rax      # 0x20258
movq (%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xfee5(%rip), %rax      # 0x20368
subq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xe940
callq 0xf180
movl $0x0, -0x18(%rbp)
jmp 0x1042b
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl 0x102c7(%rip), %eax     # 0x20770
movl %eax, %eax
movl %eax, %edi
leaq 0xfeb4(%rip), %rax      # 0x20368
subq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xe940
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
leaq 0x11391(%rip), %rax     # 0x21860
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x104ec
jmp 0x104e2
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x104fe
jmp 0x1050b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x101e0
jmp 0x1050b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xff00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
leaq 0xfc40(%rip), %rdx      # 0x20188
cmpq (%rdx), %rcx
movb %al, -0x21(%rbp)
je 0x1055f
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x10568
jmp 0x10588
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x16d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1053b
callq 0xe280
movq -0x8(%rbp), %rcx
xorl %eax, %eax
leaq 0xfbee(%rip), %rdx      # 0x20188
cmpq (%rdx), %rcx
movb %al, -0x22(%rbp)
je 0x105b1
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x105ba
jmp 0x105ff
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x105df
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10f70
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x16d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1058d
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
callq 0xe280
leaq 0xeea4(%rip), %rax      # 0x20178
movq (%rax), %rdi
movl $0x1, %esi
callq 0x16d10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0xee88(%rip), %rcx      # 0x20178
cmpq (%rcx), %rax
je 0x113a9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x1131c
leaq 0x6eaa(%rip), %rax      # 0x181c0
movq %rax, -0x58(%rbp)
jmp 0x11327
leaq 0x6cb6(%rip), %rax      # 0x17fd9
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x3c(%rax)
jne 0x11390
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x38(%rax), %r8d
leaq 0x6cd2(%rip), %rsi      # 0x18024
movb $0x0, %al
callq 0x9190
movq -0x58(%rbp), %rdi
callq 0xe110
leaq 0x6cda(%rip), %rdi      # 0x18043
callq 0xe150
movl $0x3, %edi
callq 0xe030
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xe190
leaq -0x50(%rbp), %rdi
callq 0xe1e0
jmp 0x11392
jmp 0x11392
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x16d70
movq %rax, -0x8(%rbp)
jmp 0x112e5
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
callq 0xe280
leaq 0xebdc(%rip), %rax      # 0x201a0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x16d10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0xebc0(%rip), %rcx      # 0x201a0
cmpq (%rcx), %rax
je 0x11647
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
leaq 0x6a4f(%rip), %rsi      # 0x18061
movb $0x0, %al
callq 0x9190
leaq -0x50(%rbp), %rdx
leaq 0x6b9c(%rip), %rcx      # 0x181c0
leaq 0x6943(%rip), %rsi      # 0x17f6e
movq %rcx, %rdi
callq 0xe2d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x16d70
movq %rax, -0x8(%rbp)
jmp 0x115d5
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq 0xfe85(%rip), %rax      # 0x217a0
cmpq 0xfe8e(%rip), %rax      # 0x217b0
jne 0x1192d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11956
movq 0xfe6c(%rip), %rax      # 0x217a0
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xfe5e(%rip)      # 0x217a0
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
movq 0xfe51(%rip), %rax      # 0x217a0
movq %rax, 0xfe52(%rip)      # 0x217a8
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1010, -0x4(%rbp)     # imm = 0x1010
jle 0x11980
leaq 0x671a(%rip), %rdi      # 0x18095
callq 0x16e00
leaq 0xee09(%rip), %rax      # 0x20790
movq %rax, 0xfe12(%rip)      # 0x217a0
movq 0xfe0b(%rip), %rax      # 0x217a0
movq %rax, 0xfe0c(%rip)      # 0x217a8
movq 0xfdfd(%rip), %rdi      # 0x217a0
movslq -0x4(%rbp), %rdx
leaq 0xe77a(%rip), %rax      # 0x20128
movq (%rax), %rcx
movl $0x1, %esi
callq 0x9080
movl %eax, -0x4(%rbp)
movq 0xfddb(%rip), %rax      # 0x217a0
movslq -0x4(%rbp), %rcx
addq %rcx, %rax
movq %rax, 0xfddd(%rip)      # 0x217b0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/oubuff.c
// Function: buff_add
int buff_add( length )
    int     length;
{
    if ( length + (buff_end-buff_beg) > BUFFSIZE ) 
        fmt_error("Adding too much to internal buffer");
    length = fread( buff_end, sizeof(char), length, o_file );
    buff_end = buff_end + length;   /* Last character at buff[length-1] */
    return( length );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
movq 0xfdba(%rip), %rcx      # 0x217b0
movq 0xfda3(%rip), %rdx      # 0x217a0
subq %rdx, %rcx
addq %rcx, %rax
cmpq $0x1010, %rax           # imm = 0x1010
jle 0x11a17
leaq 0x6694(%rip), %rdi      # 0x180a6
callq 0x16e00
movq 0xfd92(%rip), %rdi      # 0x217b0
movslq -0x4(%rbp), %rdx
leaq 0xe6ff(%rip), %rax      # 0x20128
movq (%rax), %rcx
movl $0x1, %esi
callq 0x9080
movl %eax, -0x4(%rbp)
movq 0xfd70(%rip), %rax      # 0x217b0
movslq -0x4(%rbp), %rcx
addq %rcx, %rax
movq %rax, 0xfd62(%rip)      # 0x217b0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/oubuff.c
// Function: buff_getc
int buff_getc()
{
    uchar   ch;
    int             result;

    if ( buff_cur == buff_end ) {                   /* At End of Buffer? */
        result = EOF;
    } else {
        ch = *buff_cur++;
        result = ch;
    }
    return( result );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xfd3d(%rip), %rax      # 0x217a8
cmpq 0xfd3e(%rip), %rax      # 0x217b0
jne 0x11a7d
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x11a9e
movq 0xfd24(%rip), %rax      # 0x217a8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xfd16(%rip)      # 0x217a8
movb (%rax), %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ouget.c
// Function: get_byte
uint8_t get_byte(void)
{
    int ch = fgetc(o_file);

    if (ch == EOF) {
        fprintf(stderr, "Premature end of input file\n");
        exit(3);
    }

    return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe649(%rip), %rax      # 0x20128
movq (%rax), %rdi
callq 0x90d0
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x11b12
movq 0xa501(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
leaq 0x65c8(%rip), %rsi      # 0x180c9
movb $0x0, %al
callq 0x9120
movl $0x3, %edi
callq 0x91a0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ouget.c
// Function: get_long
uint32_t get_long(void)
{
    uint32_t ch = get_byte();
    ch += get_byte() << 8;
    ch += get_byte() << 16;
    ch += get_byte() << 24;
    return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x11ad0
movzbl %al, %eax
movl %eax, -0x4(%rbp)
callq 0x11ad0
movzbl %al, %eax
shll $0x8, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
callq 0x11ad0
movzbl %al, %eax
shll $0x10, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
callq 0x11ad0
movzbl %al, %eax
shll $0x18, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ouget.c
// Function: get_str
void get_str(size_t length, char *dest_string)
{
    size_t count = length;

    while (count) {
        *dest_string++ = get_byte();
        --count;
    }

    *dest_string = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11c25
callq 0x11ad0
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11bf8
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ouget.c
// Function: get_index
int16_t get_index(int *data)
{
    uint16_t ch = get_byte();

    if (ch > 0x7F) {
        ch = ((ch & 0x7F) << 8) + get_byte();
        *data = ch;
        return 2;
    }
    else {
        *data = ch;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x11ad0
movzbl %al, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x7f, %eax
jle 0x11cd3
movzwl -0x12(%rbp), %eax
andl $0x7f, %eax
shll $0x8, %eax
movl %eax, -0x18(%rbp)
callq 0x11ad0
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
addl %ecx, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movw $0x2, -0x2(%rbp)
jmp 0x11ce3
movzwl -0x12(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movw $0x1, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ousegext.c
// Function: sex_compare
int sex_compare(SEX_T *rec_1, SEX_T *rec_2)
{
    if (rec_1->seg_index > rec_2->seg_index) {
        return LEFT;
    }
    else {
        if (rec_1->seg_index < rec_2->seg_index) {
            return RIGHT;
        }
        else {
            int result = strcmp(rec_1->ext_rec->name, rec_2->ext_rec->name);
            if (result < 0) {
                return LEFT;
            }
            else {
                if (result > 0) {
                    return RIGHT;
                }
                else {
                    return EQUAL;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x11d17
movl $0x0, -0x4(%rbp)
jmp 0x11d73
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x11d2e
movl $0x1, -0x4(%rbp)
jmp 0x11d73
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x4, %rsi
callq 0x9100
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x11d5d
movl $0x0, -0x4(%rbp)
jmp 0x11d73
cmpl $0x0, -0x1c(%rbp)
jle 0x11d6c
movl $0x1, -0x4(%rbp)
jmp 0x11d73
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ousegext.c
// Function: sex_insert
void sex_insert(int seg_index, EXT_T *ext_rec)
{
    SEX_T *sex_rec = o_malloc(sizeof(SEX_T));
    sex_rec->seg_index = seg_index;
    sex_rec->ext_rec = ext_rec;

    insert((char *)sex_rec, sex_tree, TC sex_compare);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x16e40
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
leaq 0xe3cb(%rip), %rax      # 0x20188
movq (%rax), %rsi
leaq -0xd7(%rip), %rdx       # 0x11cf0
callq 0x16820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ousize.c
// Function: size_to_type
int size_to_type(int size)
{
    int result;

    switch (size) {
    case  1: result = BYTE_PTR;     break;
    case  2: result = WORD_PTR;     break;
    case  4: result = DWORD_PTR;    break;
    case  6: result = FWORD_PTR;    break;
    case  8: result = QWORD_PTR;    break;
    case 10: result = TBYTE_PTR;    break;
    default: result = UNKNOWN;      break;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x9, %eax
ja 0x11e41
movq -0x10(%rbp), %rax
leaq 0x62e6(%rip), %rcx      # 0x180e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x8(%rbp)
jmp 0x11e48
movl $0x4, -0x8(%rbp)
jmp 0x11e48
movl $0x5, -0x8(%rbp)
jmp 0x11e48
movl $0x6, -0x8(%rbp)
jmp 0x11e48
movl $0x7, -0x8(%rbp)
jmp 0x11e48
movl $0x8, -0x8(%rbp)
jmp 0x11e48
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ousize.c
// Function: reg_size_to_type
int reg_size_to_type(int reg_size)
{
    int result;

    switch( reg_size ) {
    case 0:     result = BYTE_PTR;      break;
    case 1:     result = WORD_PTR;      break;
    case 2:     result = DWORD_PTR;     break;
    case 3:     result = FWORD_PTR;     break;
    default:    result = UNKNOWN;       break;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x11e9c
movq -0x10(%rbp), %rax
leaq 0x62a1(%rip), %rcx      # 0x18110
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x8(%rbp)
jmp 0x11ea3
movl $0x4, -0x8(%rbp)
jmp 0x11ea3
movl $0x5, -0x8(%rbp)
jmp 0x11ea3
movl $0x6, -0x8(%rbp)
jmp 0x11ea3
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ousize.c
// Function: type_to_size
int type_to_size(int type)
{
    int result;

    switch( type ) {
    case  BYTE_PTR:     result =  1;    break;
    case  WORD_PTR:     result =  2;    break;
    case  DWORD_PTR:    result =  4;    break;
    case  FWORD_PTR:    result =  6;    break;
    case  QWORD_PTR:    result =  8;    break;
    case  TBYTE_PTR:    result = 10;    break;
    default:            result =  0;    break;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x11f12
movq -0x10(%rbp), %rax
leaq 0x624d(%rip), %rcx      # 0x18120
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x8(%rbp)
jmp 0x11f19
movl $0x2, -0x8(%rbp)
jmp 0x11f19
movl $0x4, -0x8(%rbp)
jmp 0x11f19
movl $0x6, -0x8(%rbp)
jmp 0x11f19
movl $0x8, -0x8(%rbp)
jmp 0x11f19
movl $0xa, -0x8(%rbp)
jmp 0x11f19
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ousize.c
// Function: type_to_text
char *type_to_text(int type)
{
    char *result;

    switch( type ) {
    case BYTE_PTR:      result = "byte ptr ";   break;
    case WORD_PTR:      result = "word ptr ";   break;
    case DWORD_PTR:     result = "dword ptr ";  break;
    case FWORD_PTR:     result = "fword ptr ";  break;
    case QWORD_PTR:     result = "qword ptr ";  break;
    case TBYTE_PTR:     result = "tbyte ptr ";  break;
    default:            result = "";            break;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x11f9a
movq -0x18(%rbp), %rax
leaq 0x61f5(%rip), %rcx      # 0x18138
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5336(%rip), %rax      # 0x17289
movq %rax, -0x10(%rbp)
jmp 0x11fa5
leaq 0x5313(%rip), %rax      # 0x17273
movq %rax, -0x10(%rbp)
jmp 0x11fa5
leaq 0x5305(%rip), %rax      # 0x17272
movq %rax, -0x10(%rbp)
jmp 0x11fa5
leaq 0x6202(%rip), %rax      # 0x1817c
movq %rax, -0x10(%rbp)
jmp 0x11fa5
leaq 0x52f6(%rip), %rax      # 0x1727d
movq %rax, -0x10(%rbp)
jmp 0x11fa5
leaq 0x52f4(%rip), %rax      # 0x17288
movq %rax, -0x10(%rbp)
jmp 0x11fa5
leaq 0x621f(%rip), %rax      # 0x181c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/ousize.c
// Function: size_to_opcode
char *size_to_opcode(int size, int *times)
{
    char *result;

    *times = 1;

    switch( size ) {
    case 0:     result = "*ERROR*"; *times = 0; break;
    case 1:     result = "db";                  break;
    case 2:     result = "dw";                  break;
    case 4:     result = "dd";                  break;
    case 6:     result = "df";                  break;
    case 8:     result = "dq";                  break;
    case 10:    result = "dt";                  break;
    default:    result = "db";  *times = size;  break;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl -0x4(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0xa, %rax
ja 0x1204b
movq -0x20(%rbp), %rax
leaq 0x6173(%rip), %rcx      # 0x18150
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x619a(%rip), %rax      # 0x18187
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1205f
leaq 0x608e(%rip), %rax      # 0x18092
movq %rax, -0x18(%rbp)
jmp 0x1205f
leaq 0x617e(%rip), %rax      # 0x1818f
movq %rax, -0x18(%rbp)
jmp 0x1205f
leaq 0x54e7(%rip), %rax      # 0x17505
movq %rax, -0x18(%rbp)
jmp 0x1205f
leaq 0x5d39(%rip), %rax      # 0x17d64
movq %rax, -0x18(%rbp)
jmp 0x1205f
leaq 0x615a(%rip), %rax      # 0x18192
movq %rax, -0x18(%rbp)
jmp 0x1205f
leaq 0x5204(%rip), %rax      # 0x17249
movq %rax, -0x18(%rbp)
jmp 0x1205f
leaq 0x6040(%rip), %rax      # 0x18092
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/oustruct.c
// Function: struc_compare
int struc_compare(STRUC_T *rec_1, STRUC_T *rec_2)
{
    int result = strcmp(rec_1->form, rec_2->form);

    if ( result == 1 ) {
        result = LEFT;
    } else {
        if ( result == 0 ) {
            return EQUAL;
        } else {
            return RIGHT;
        }
    }
    return LEFT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x9100
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x120a5
movl $0x0, -0x1c(%rbp)
jmp 0x120bd
cmpl $0x0, -0x1c(%rbp)
jne 0x120b4
movl $0x2, -0x4(%rbp)
jmp 0x120c4
movl $0x1, -0x4(%rbp)
jmp 0x120c4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/oustruct.c
// Function: struc_insert
STRUC_T *struc_insert(char *form)
{
    STRUC_T *struc_rec = o_malloc(sizeof(STRUC_T));

    size_t length = strlen(form) + 1;

    char *form_copy = o_malloc(length);

    strncpy(form_copy, form, length);
    struc_rec->form  = form_copy;
    struc_rec->index = 0;               /* Not determined yet */

    NODE_T *struc_node = insert( (char *)struc_rec, struc_tree, TC struc_compare );

    return( (STRUC_T *)struc_node->data );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x16e40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x90a0
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16e40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9050
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
leaq 0xe05e(%rip), %rax      # 0x20198
movq (%rax), %rsi
leaq -0xd4(%rip), %rdx       # 0x12070
callq 0x16820
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/outarget.c
// Function: assume
void assume( seg_reg, data_mode, data_index )
    int             seg_reg;
    int             data_mode;
    int             data_index;
{
    char            *seg_name;
    extern  char    *sregsc[];
    char            operand[100];

    seg_name = mode_name( data_mode, data_index );
    if (seg_name && compatibility != 2 && pass == 3 ) {
        out_opcode( "assume" );
        sprintf( operand, "%s %s", sregsc[seg_reg], seg_name );
        out_operand( operand );
        out_endline();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x122d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x123e1
leaq 0xdd37(%rip), %rax      # 0x200c8
cmpl $0x2, (%rax)
je 0x123e1
leaq 0xdd9b(%rip), %rax      # 0x20138
cmpl $0x3, (%rax)
jne 0x123e1
leaq 0x611f(%rip), %rdi      # 0x184c8
callq 0xe150
leaq -0x80(%rbp), %rdi
movslq -0x4(%rbp), %rcx
leaq 0x9e73(%rip), %rax      # 0x1c230
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
leaq 0x682a(%rip), %rsi      # 0x18bf6
movb $0x0, %al
callq 0x9190
leaq -0x80(%rbp), %rdi
callq 0xe190
callq 0xe240
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)