LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xec03(%rip), %rax      # 0x1cf68
cmpl $0x3, (%rax)
jne 0xe36f
callq 0xcad9
leaq 0xee22(%rip), %r13      # 0x1d198
movq (%r13), %rax
movl 0x4(%rbx), %ecx
movl 0xf21d(%rip), %edi      # 0x1d5a0
addl %ecx, %edi
cmpq %rdi, %rax
je 0xe441
movq %rbx, 0x8(%rsp)
leaq 0xedf6(%rip), %rcx      # 0x1d190
movl (%rcx), %ecx
leaq 0xecf5(%rip), %rdx      # 0x1d098
movl %ecx, (%rdx)
movq %rdi, 0x8(%rdx)
leaq 0xecd0(%rip), %rbx      # 0x1d080
movq (%rbx), %rcx
leaq 0xebee(%rip), %r14      # 0x1cfa8
cmpq (%r14), %rcx
je 0xe42a
movq %r12, 0x10(%rsp)
movl %r15d, 0x4(%rsp)
movl $0x1, %ebp
leaq 0xecb3(%rip), %r15      # 0x1d088
leaq 0xecbc(%rip), %r12      # 0x1d098
movq (%r15), %rsi
movq %r12, %rdi
callq 0x11bec
testl %eax, %eax
jne 0xe40c
movq (%r15), %rax
movq 0x8(%rax), %rdi
subq (%r13), %rdi
movl %ebp, %esi
callq 0xd01d
callq 0xd687
movq (%rbx), %rax
xorl %ebp, %ebp
cmpq (%r14), %rax
jne 0xe3dc
movl 0xf18e(%rip), %edi      # 0x1d5a0
movq (%r13), %rax
movq 0x8(%rsp), %rbx
addl 0x4(%rbx), %edi
movl 0x4(%rsp), %r15d
movq 0x10(%rsp), %r12
jmp 0xe434
movl $0x1, %ebp
movq 0x8(%rsp), %rbx
subq %rax, %rdi
movl %ebp, %esi
callq 0xd01d
movl 0x4(%rbx), %ecx
movl %ecx, %eax
leaq 0x10246(%rip), %rcx     # 0x1e690
movq %rax, (%rcx)
movl 0x8(%rbx), %eax
cmpl $0x1, %eax
je 0xe475
testl %eax, %eax
jne 0xe48b
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe1e8
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdf7b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x20(%rdi), %r12
leaq 0xeb06(%rip), %r15      # 0x1cfb8
cmpq %rdi, (%r15)
je 0xe4d6
cmpl %ebx, (%r12)
jge 0xe4d6
movq %r14, %rdi
movl $0x1, %esi
callq 0x1288c
movq %rax, %r14
movq 0x20(%rax), %r12
cmpq (%r15), %rax
jne 0xe4b7
callq 0xcad9
cmpq (%r15), %r14
je 0xe50e
cmpl %ebx, (%r12)
jne 0xe50e
movq 0x8(%r12), %rdi
cmpl %ebx, 0x48(%rdi)
jne 0xe4f5
callq 0xebb0
movq %r14, %rdi
movl $0x1, %esi
callq 0x1288c
movq %rax, %r14
movq 0x20(%rax), %r12
cmpq (%r15), %rax
jne 0xe4e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe275(%rip), %r12      # 0x1cf98
movq (%r12), %rdi
movl $0x1, %esi
callq 0x1286f
xorl %ebx, %ebx
cmpq (%r12), %rax
je 0xed81
movq %rax, %r14
leaq 0xe2ad(%rip), %r13      # 0x1cff0
leaq 0x4835(%rip), %r15      # 0x1357f
movq 0x20(%r14), %rbp
movq %rbp, (%r13)
movq 0x8(%rbp), %rdi
addq $0x4, %rdi
movq %r15, %rsi
callq 0x9050
testl %eax, %eax
je 0xed7e
movq %r14, %rdi
movl $0x1, %esi
callq 0x1288c
movq %rax, %r14
cmpq (%r12), %rax
jne 0xed4a
jmp 0xed81
movl (%rbp), %ebx
callq 0xcad9
leaq 0xe223(%rip), %r12      # 0x1cfb0
movq (%r12), %rdi
xorl %esi, %esi
callq 0x1286f
cmpq (%r12), %rax
je 0xedfe
movq %rax, %r14
leaq 0xe150(%rip), %r13      # 0x1cef8
movq 0x20(%r14), %r15
movl 0x48(%r15), %eax
leal 0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0xedeb
cmpl $0x2, (%r13)
jne 0xede3
testl %ebx, %ebx
je 0xede3
movl 0x2c(%r15), %ecx
addl $-0x2, %ecx
cmpl $0x3, %ecx
ja 0xede3
testl %eax, %eax
jne 0xedeb
movl %ebx, %edi
movq %r15, %rsi
callq 0xf60c
movl %ebx, 0x48(%r15)
jmp 0xedeb
movq %r15, %rdi
callq 0xebb0
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
movq %rax, %r14
cmpq (%r12), %rax
jne 0xeda8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcad9
leaq 0xe181(%rip), %r14      # 0x1cfa8
movq (%r14), %rdi
movl $0x1, %esi
callq 0x1286f
cmpq (%r14), %rax
je 0xeed0
movq %rax, %rbx
movq %rsp, %r15
leaq 0x5157(%rip), %r12      # 0x13fa1
movq 0x20(%rbx), %r13
cmpl $0x1, 0x3c(%r13)
jne 0xeeb7
cmpl $0x0, 0x40(%r13)
leaq 0x52ab(%rip), %rbp      # 0x1410c
leaq 0x50cf(%rip), %rax      # 0x13f37
cmoveq %rax, %rbp
movl (%r13), %edx
movq 0x8(%r13), %rcx
movl 0x38(%r13), %r8d
movq %r15, %rdi
leaq 0x5100(%rip), %rsi      # 0x13f82
xorl %eax, %eax
callq 0x91b0
movq %rbp, %rdi
callq 0xc9ee
movq %r12, %rdi
callq 0xca16
movl $0x3, %edi
callq 0xc959
addq $0x10, %r13
movq %r13, %rdi
callq 0xca45
movq %r15, %rdi
callq 0xca76
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1288c
movq %rax, %rbx
cmpq (%r14), %rax
jne 0xee4a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcad9
leaq 0xdf37(%rip), %rbp      # 0x1cfd0
movq (%rbp), %rdi
movl $0x1, %esi
callq 0x1286f
cmpq (%rbp), %rax
je 0xf10a
movq %rax, %rbx
leaq 0x4f08(%rip), %r14      # 0x13fbf
movq %rsp, %r15
leaq 0x4e0b(%rip), %r12      # 0x13ecc
leaq 0x5044(%rip), %r13      # 0x1410c
movq 0x20(%rbx), %rax
movl (%rax), %edx
movq 0x8(%rax), %rcx
movl 0x10(%rax), %r8d
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x91b0
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xcb44
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1288c
movq %rax, %rbx
cmpq (%rbp), %rax
jne 0xf0c8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xf3ea
leaq 0x4c0b(%rip), %rdi      # 0x13ff0
callq 0x128bc
leaq 0xe1cf(%rip), %rdi      # 0x1d5c0
movq %rdi, 0xf1d8(%rip)      # 0x1e5d0
movq %rdi, 0xf1d9(%rip)      # 0x1e5d8
movslq %ebx, %rdx
leaq 0xdb4f(%rip), %rax      # 0x1cf58
movq (%rax), %rcx
movl $0x1, %esi
callq 0x9090
cltq
movq 0xf1b1(%rip), %rcx      # 0x1e5d0
addq %rax, %rcx
movq %rcx, 0xf1b7(%rip)      # 0x1e5e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movslq %edi, %rbx
movq 0xf1aa(%rip), %rdi      # 0x1e5e0
leaq (%rdi,%rbx), %rax
subq 0xf18f(%rip), %rax      # 0x1e5d0
cmpq $0x1011, %rax           # imm = 0x1011
jl 0xf45c
leaq 0x4bb1(%rip), %rdi      # 0x14001
callq 0x128bc
movq 0xf184(%rip), %rdi      # 0x1e5e0
leaq 0xdaf5(%rip), %rax      # 0x1cf58
movq (%rax), %rcx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x9090
cltq
addq %rax, 0xf164(%rip)      # 0x1e5e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
callq 0xf4b4
movzbl %al, %ebx
callq 0xf4b4
movzbl %al, %ebp
shll $0x8, %ebp
orl %ebx, %ebp
callq 0xf4b4
movzbl %al, %ebx
shll $0x10, %ebx
orl %ebp, %ebx
callq 0xf4b4
movzbl %al, %eax
shll $0x18, %eax
orl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0xf559
movq %rdi, %r14
callq 0xf4b4
movb %al, (%rbx)
incq %rbx
decq %r14
jne 0xf54a
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf4b4
movzbl %al, %ebp
movw $0x1, %ax
testb %bpl, %bpl
jns 0xf5c4
andl $0x7f, %ebp
shll $0x8, %ebp
callq 0xf4b4
movzbl %al, %eax
orl %eax, %ebp
movw $0x2, %ax
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0x128e2
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
leaq 0xd98d(%rip), %rcx      # 0x1cfb8
movq (%rcx), %rsi
leaq -0x65(%rip), %rdx       # 0xf5d0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x125e8
nop
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x1, (%rsi)
leaq 0x4942(%rip), %rax      # 0x13fed
cmpl $0xa, %edi
ja 0xf6d0
movl %edi, %ecx
leaq 0x498b(%rip), %rdx      # 0x14044
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x0, (%rsi)
leaq 0x4a04(%rip), %rax      # 0x140d3
retq
movl %edi, (%rsi)
retq
leaq 0x4a04(%rip), %rax      # 0x140de
retq
leaq 0x3aeb(%rip), %rax      # 0x131cd
retq
leaq 0x49f1(%rip), %rax      # 0x140db
retq
leaq 0x3e6c(%rip), %rax      # 0x1355e
retq
leaq 0x45cc(%rip), %rax      # 0x13cc6
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x128e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x90b0
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x128e2
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9060
movq %r12, (%r14)
movl $0x0, 0x8(%r14)
leaq 0xd85a(%rip), %rax      # 0x1cfc8
movq (%rax), %rsi
leaq -0x7c(%rip), %rdx       # 0xf6fc
movq %r14, %rdi
callq 0x125e8
movq 0x20(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
movl %esi, %edi
movl %edx, %esi
callq 0xf897
testq %rax, %rax
je 0xf94c
movq %rax, %rbx
leaq 0xd5fb(%rip), %rax      # 0x1cef8
cmpl $0x2, (%rax)
je 0xf94c
leaq 0xd65f(%rip), %rax      # 0x1cf68
cmpl $0x3, (%rax)
jne 0xf94c
leaq 0x4ae3(%rip), %rdi      # 0x143f8
callq 0xca16
movslq %ebp, %rax
leaq 0x991c(%rip), %rcx      # 0x19240
movq (%rcx,%rax,8), %rdx
leaq 0x52ad(%rip), %rsi      # 0x14bdc
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x91b0
movq %r14, %rdi
callq 0xca45
callq 0xcaab
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/outarget.c
// Function: adjust_assumes
void adjust_assumes()
{
    int     seg_reg;
    int     new_mode;
    int     new_index;

    for ( seg_reg = 0; seg_reg < MAX_SEG_REGS; seg_reg++ ) {
        new_mode  = seg_rec->new_mode [seg_reg];
        new_index = seg_rec->new_index[seg_reg];
        if ( new_mode  != seg_rec->prv_mode [seg_reg] ||
             new_index != seg_rec->prv_index[seg_reg] ) {
            assume( seg_reg, new_mode, new_index );
            seg_rec->prv_mode [seg_reg] = new_mode;
            seg_rec->prv_index[seg_reg] = new_index;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xd68d(%rip), %r15      # 0x1cff0
movq (%r15), %rax
xorl %ebx, %ebx
movl 0x1c(%rax,%rbx,4), %ebp
movl 0x34(%rax,%rbx,4), %r14d
cmpl 0x4c(%rax,%rbx,4), %ebp
jne 0xf97e
cmpl 0x64(%rax,%rbx,4), %r14d
je 0xf996
movl %ebx, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0xf8db
movq (%r15), %rax
movl %ebp, 0x4c(%rax,%rbx,4)
movl %r14d, 0x64(%rax,%rbx,4)
incq %rbx
cmpq $0x6, %rbx
jne 0xf968
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/outarget.c
// Function: abort_assumes
void abort_assumes()
{
    int     seg_reg;

    for ( seg_reg = 0; seg_reg < MAX_SEG_REGS; seg_reg++ ) {
        seg_rec->new_mode [seg_reg] = seg_rec->prv_mode [seg_reg];
        seg_rec->new_index[seg_reg] = seg_rec->prv_index[seg_reg];
    }
}

// Assembly:
leaq 0xd63f(%rip), %rax      # 0x1cff0
movq (%rax), %rax
movq $-0x6, %rcx
movl 0x64(%rax,%rcx,4), %edx
movl 0x7c(%rax,%rcx,4), %esi
movl %edx, 0x34(%rax,%rcx,4)
movl %esi, 0x4c(%rax,%rcx,4)
incq %rcx
jne 0xf9bb
retq
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/outarget.c
// Function: find_member
int find_member( text, structure, offset )
    char    *text;
    STRUC_T *structure;
    long    *offset;
{
    int     type;
    int     mem_cnt;
    long    dup_cnt;
    long     this_size;
    char    *cp;
    char    ch;

    mem_cnt = 0;
    cp = structure->form;

    while ( (ch=*cp) != '\0' ) {
        switch( ch ) {
            case '(':
                dup_cnt = atol( cp+1 );
                break;
            case ',':
                type = atoi( cp+1 );
                break;
            case ')':
                this_size = type_to_size(type)*dup_cnt;
                if ( *offset < this_size ) {
                    sprintf( text, ".s%dm_%d", structure->index, mem_cnt );
                    return( type );
                }
                *offset -= this_size;
                mem_cnt++;
            default:
                break;
        }
        cp++;
    }

    strcpy( text, ".past struct" );

    return( UNKNOWN );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, (%rsp)
movq (%rsi), %r13
incq %r13
xorl %r14d, %r14d
movzbl -0x1(%r13), %eax
cmpl $0x28, %eax
jle 0xfe3c
cmpl $0x29, %eax
je 0xfe4b
cmpl $0x2c, %eax
jne 0xfe6f
movq %r13, %rdi
callq 0x9190
movl %eax, %ebp
jmp 0xfe6f
jne 0xfe6b
movq %r13, %rdi
callq 0x9170
movq %rax, %rbx
jmp 0xfe6f
movl %ebp, %edi
callq 0xf666
movslq %eax, %rcx
imulq %rbx, %rcx
movq (%r12), %rax
subq %rcx, %rax
jl 0xfe97
movq %rax, (%r12)
incl %r14d
jmp 0xfe6f
testl %eax, %eax
je 0xfe74
incq %r13
jmp 0xfe1c
movabsq $0x74637572747320, %rax # imm = 0x74637572747320
movq (%rsp), %rcx
movq %rax, 0x5(%rcx)
movabsq $0x747320747361702e, %rax # imm = 0x747320747361702E
movq %rax, (%rcx)
xorl %ebp, %ebp
jmp 0xfeb0
movl 0x8(%r15), %edx
leaq 0x4569(%rip), %rsi      # 0x1440b
movq (%rsp), %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x91b0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_comdef.c
// Function: get_val
word get_val( value )
    dword   *value;
{   
    word    byte;
    word    result;

    byte = get_byte();

    switch( byte ) {
        case 0x81:
            *value = (dword)get_word();
            result = 3;
            break;
        case 0x84:
            *value = (dword)get_word()
                     + ((dword)get_byte() << 8);
            result = 4;
            break;
        case 0x88:
            *value = get_long();
            result = 5;
            break;
        default:
            *value = (dword)byte;
            result = 1;
            break;
    }
    return( result );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf4b4
cmpb $-0x78, %al
je 0x10450
movzbl %al, %ecx
cmpl $0x84, %ecx
je 0x10432
cmpl $0x81, %ecx
jne 0x1045e
callq 0xf4e8
movzwl %ax, %ecx
movl $0x3, %eax
jmp 0x10463
callq 0xf4e8
movzwl %ax, %r14d
callq 0xf4b4
movzbl %al, %ecx
shll $0x8, %ecx
addq %r14, %rcx
movl $0x4, %eax
jmp 0x10463
callq 0xf502
movl %eax, %ecx
movl $0x5, %eax
jmp 0x10463
movl $0x1, %eax
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_comdef.c
// Function: comdef
void comdef(size_t length, int scope)
{
    char            name[41];
    int             typ_idx;
    int             var_type;
    dword   num_elements;
    dword   element_size;
    char            cksum;

    --length;
    while( length ) {
        length -= get_name( name );
        length -= get_index( &typ_idx );
        --length;
        var_type = get_byte();
        if ( var_type == 0x61 ) {
            /* MSC v4.0 actually has these values reversed, so you may
               have to reverse the two lines below to generate resonable
               .asm code */
            length -= get_val( &num_elements );
            length -= get_val( &element_size );
        } else {
            length -= get_val( &element_size );
            num_elements = 1L;
        }
        ext_insert( name, 1, var_type, num_elements, 
                                        (word)element_size, scope );
    }
    cksum = get_byte();
    cksum = cksum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, 0x4(%rsp)
movq %rdi, %r14
decq %r14
je 0x1051e
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xf564
movq %rax, %r13
leaq 0x1c(%rsp), %rdi
callq 0xf599
movl %eax, %ebp
callq 0xf4b4
movl %eax, %r12d
cmpb $0x61, %al
jne 0x104d3
leaq 0x10(%rsp), %rdi
callq 0x10400
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x10400
addl %ebx, %eax
movq 0x10(%rsp), %rcx
jmp 0x104eb
leaq 0x8(%rsp), %rdi
callq 0x10400
movq $0x1, 0x10(%rsp)
movl $0x1, %ecx
movswq %bp, %rdx
addq %rdx, %r13
notq %r13
addq %r13, %r14
movzbl %r12b, %edx
movl %eax, %ebx
movl 0x8(%rsp), %r8d
movq %r15, %rdi
movl $0x1, %esi
movl 0x4(%rsp), %r9d
callq 0x11102
subq %rbx, %r14
jne 0x10491
callq 0xf4b4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_extdef.c
// Function: ext_insert
void ext_insert( this_name, com_ext, var_type, count, size, scope )
    char            *this_name;
    int             com_ext;
    int             var_type;
    dword   count;
    word    size;
    int             scope;
{
    static  int extern_count = 0;
    EXT_T   *extern_rec;

    extern_count++;
    extern_rec = (EXT_T *)o_malloc( sizeof(EXT_T) );
    extern_rec->index    = extern_count;
    extern_rec->type     = size_to_type(size);
    extern_rec->pos_abs  = TRUE;
    extern_rec->size     = count;
    extern_rec->com_ext  = com_ext;
    extern_rec->var_type = var_type;
    extern_rec->used     = 0;                   /* Default to never used */
    extern_rec->scope    = scope;
    strcpy( extern_rec->name, this_name );

    insert( (char *)extern_rec, extern_tree, TC ext_compare );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
incl 0xd4f1(%rip)            # 0x1e618
movl $0x50, %edi
callq 0x128e2
movq %rax, %rbx
movl 0xd4de(%rip), %eax      # 0x1e618
movl %eax, (%rbx)
movl %ebp, %edi
callq 0xf644
movl %eax, 0x2c(%rbx)
movl $0x1, 0x30(%rbx)
movq %r14, 0x40(%rbx)
movl %r12d, 0x34(%rbx)
movl %r15d, 0x38(%rbx)
movl $0x0, 0x48(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x4c(%rbx)
leaq 0x4(%rbx), %rdi
movq %r13, %rsi
callq 0x9070
leaq 0xbe36(%rip), %rax      # 0x1cfb0
movq (%rax), %rsi
leaq -0x98(%rip), %rdx       # 0x110ec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x125e8
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_extdef.c
// Function: extdef
void extdef(size_t length, int scope)
{
    char    name[41];
    int     typ_idx;
    char    cksum;

    --length;
    while( length ) {
        length -= get_name( name );
        length -= get_index( &typ_idx );

#ifdef DEBUG
printf("%s\n", name );
#endif

        ext_insert( name, 0, 0, 0L, 0, scope );
    }
    cksum = get_byte();
    cksum = cksum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
decq %r14
je 0x111ef
movl %esi, %ebx
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r15, %rdi
callq 0xf564
movq %rax, %r13
movq %r12, %rdi
callq 0xf599
movswq %ax, %rbp
addq %r13, %rbp
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl %ebx, %r9d
callq 0x11102
subq %rbp, %r14
jne 0x111bc
callq 0xf4b4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_fixupp.c
// Function: fix_insert
void fix_insert( offset, relate, form, displacement, a_mode, a_index, 
                                                    b_mode, b_index, extension )
    int     offset;
    int     relate;
    int     form;
    long    displacement;
    int     a_mode;
    int     a_index;
    int     b_mode;
    int     b_index;
    int     extension;
{
    FIX_T   *fixup_rec;

    fixup_rec = (FIX_T *)o_malloc( sizeof(FIX_T) );
    fixup_rec->seg_idx      = data_seg_idx;
    fixup_rec->dat_offset   = data_offset;
    fixup_rec->offset       = offset;
    fixup_rec->relate       = relate;
    fixup_rec->form         = form;
    fixup_rec->displacement = displacement;
    fixup_rec->a_mode       = a_mode;           /* Mode of frame   */
    fixup_rec->a_index      = a_index;          /* Index of frame  */
    fixup_rec->b_mode       = b_mode;           /* Mode of target  */
    fixup_rec->b_index      = b_index;          /* Index of target */
    fixup_rec->extended     = extension;

#ifdef DEBUG
printf("FIXUP:%04X:%08lX:%04X displacement=%08lX\n",
            data_seg_idx,data_offset,offset, displacement );
#endif
    if ( form == OFFSET || form == BASE || form == LOADOFF ) {
        fixup_rec->word_sized = TRUE;
    } else {
        fixup_rec->word_sized = FALSE;
    }

    insert( (char *)fixup_rec, fix_tree, TC fix_compare );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq %rcx, %r15
movl %edx, %ebx
movl %esi, %r12d
movl %edi, %r13d
movl 0x60(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x58(%rsp), %r14d
movl 0x50(%rsp), %ebp
movl $0x40, %edi
callq 0x128e2
leaq 0xd40c(%rip), %rcx      # 0x1e688
movl (%rcx), %ecx
movl %ecx, (%rax)
leaq 0xd409(%rip), %rcx      # 0x1e690
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movl %r13d, 0x10(%rax)
movl %r12d, 0x14(%rax)
movl %ebx, 0x18(%rax)
movq %r15, 0x30(%rax)
movl 0x10(%rsp), %ecx
movl %ecx, 0x1c(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl %ebp, 0x24(%rax)
movl %r14d, 0x28(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x38(%rax)
decl %ebx
xorl %ecx, %ecx
cmpl $0x4, %ebx
ja 0x112ce
movl %ebx, %ecx
leaq 0x3715(%rip), %rdx      # 0x149e0
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x3c(%rax)
leaq 0xbcf8(%rip), %rcx      # 0x1cfd0
movq (%rcx), %rsi
leaq -0xde(%rip), %rdx       # 0x11204
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x125e8
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_fixupp.c
// Function: fixupp
void fixupp(size_t length, int extension)
{
    uchar   type;           /* First byte of a FIXUPP packet */
    int             kind;
    int             thread;
    int             locat;
    int             relate;
    int             size;
    int             form;
    int             offset;
    int             mode;
    int             index;

    --length;                           /* Subtract 1 for checksum */

    while ( length ) {
        type = get_byte();
        --length;
        if ( type & 0x80 ) {
            /*
            ** True FixUp aka Explicit FixUp Record
            */
            --length;
            locat = ((int)type << 8) + get_byte();
            relate = ( locat & 0x4000 ) >> 14;  /* mode */
            size   = ( locat & 0x2000 ) >> 13;  /* zero */
            form   = ( locat & 0x1C00 ) >> 10;  /* LOC [0,4] */
            offset = ( locat & 0x03FF );

            length -= decode_fixup( relate, size, form, offset, extension );
        } else {
            /*
            ** Thread FixUp
            */
            kind   = ( type & 0x40 ) >> 6;
            mode   = ( type & 0x1C ) >> 2;
            thread = ( type & 0x03 );
            threads[kind][thread].mode  = mode;
            if ( mode == 0 || thread < 4 ) {
                length -= get_index( &index );
                threads[kind][thread].index = index;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
decq %r14
je 0x11507
movl %esi, %ebx
leaq 0xba30(%rip), %r13      # 0x1cea0
leaq 0x4(%rsp), %r15
callq 0xf4b4
movzbl %al, %r12d
testb %r12b, %r12b
js 0x114bc
movl %r12d, %eax
shrl $0x2, %eax
andl $0x7, %eax
movl %r12d, %ebp
andl $0x3, %ebp
shrl %r12d
andl $-0x20, %r12d
addq %r13, %r12
movl %eax, (%r12,%rbp,8)
movq %r15, %rdi
callq 0xf599
notl %eax
movswq %ax, %rax
addq %rax, %r14
movl 0x4(%rsp), %eax
movl %eax, 0x4(%r12,%rbp,8)
jmp 0x114fe
callq 0xf4b4
movzbl %al, %eax
movl %r12d, %edi
shrl $0x6, %edi
andl $0x1, %edi
movl %r12d, %esi
shrl $0x5, %esi
andl $0x1, %esi
movl %r12d, %edx
shrl $0x2, %edx
andl $0x7, %edx
andl $0x3, %r12d
shll $0x8, %r12d
orl %eax, %r12d
movl %r12d, %ecx
movl %ebx, %r8d
callq 0x112f8
cltq
subq %rax, %r14
addq $-0x2, %r14
testq %r14, %r14
jne 0x11475
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_grpdef.c
// Function: grp_insert
void grp_insert( name_idx )
    int     name_idx;
{
    static  int group_count = 0;
    GRP_T   *group_rec;

    group_count++;
    group_rec = (GRP_T *)o_malloc( sizeof(GRP_T) );
    group_rec->index = group_count;
    group_rec->name = name_idx;

    insert( (char *)group_rec, group_tree, TC grp_compare );
}

// Assembly:
pushq %rbx
movl %edi, %ebx
incl 0xd14d(%rip)            # 0x1e684
movl $0x8, %edi
callq 0x128e2
movl 0xd13d(%rip), %ecx      # 0x1e684
movl %ecx, (%rax)
movl %ebx, 0x4(%rax)
leaq 0xba4d(%rip), %rcx      # 0x1cfa0
movq (%rcx), %rsi
leaq -0x45(%rip), %rdx       # 0x11518
movq %rax, %rdi
popq %rbx
jmp 0x125e8
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_ledata.c
// Function: dat_insert
void dat_insert( seg_idx, offset, file_pos, length, extended, type )
    int             seg_idx;
    dword   offset;
    long            file_pos;
    int             length;
    int             extended;
    int             type;
{
    DAT_T           *data_rec;

    data_rec = (DAT_T *)o_malloc( sizeof(DAT_T) );
    data_rec->seg_idx   = seg_idx;
    data_rec->offset    = offset;
    data_rec->type      = type;
    data_rec->size      = 1;             /* Default to DB */
    data_rec->file_pos  = file_pos;
    data_rec->length    = length;
    data_rec->extended  = extended;
    data_rec->structure = NULL;
    insert( (char *)data_rec, data_tree, TC dat_compare );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %r13d
movl $0x28, %edi
callq 0x128e2
movl %r13d, (%rax)
movl %r12d, 0x4(%rax)
movl %ebx, 0x8(%rax)
movl $0x1, 0xc(%rax)
movq %r15, 0x10(%rax)
movl %r14d, 0x18(%rax)
movl %ebp, 0x1c(%rax)
movq $0x0, 0x20(%rax)
leaq 0xb78d(%rip), %rcx      # 0x1cfc0
movq (%rcx), %rsi
leaq -0x81(%rip), %rdx       # 0x117bc
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x125e8
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_ledata.c
// Function: ledata
void ledata(size_t length, int extension)
{
    SEG_T seg_search;
    SEG_T *seg;
    uint32_t offset;
    long position;

    position = o_position + length;     /* Position assumed at end of rec */

    length -= get_index( &seg_search.index );

    seg = (SEG_T *)find( (char *)&seg_search, segment_tree, TC seg_compare, NULL );

    if ( seg == NULL ) fmt_error("Undefined segment\n");

    if ( extension == REGULAR ) {
        offset = get_word(); /* Spot to begin within segment */
        length -= 2;
    } else {
        offset = get_long();
        length -= 4;
    }

    data_seg_idx = seg_search.index;    /* Needed by FIXUPPs */
    data_offset  = offset;              /* Ditto */

    position -= length;                 /* Move back remainder of bytes */
    --length;                           /* Ignore checksum in length */

    dat_insert( seg_search.index, offset, position, length, 
                                            extension, ENUMERATED );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xb6f0(%rip), %rax      # 0x1cf60
movq (%rax), %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf599
movl %eax, %ebp
leaq 0xb70f(%rip), %rax      # 0x1cf98
movq (%rax), %rsi
leaq 0x499(%rip), %rdx       # 0x11d2c
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x1280f
testq %rax, %rax
jne 0x118ae
leaq 0x326f(%rip), %rdi      # 0x14b18
callq 0x128bc
testl %ebx, %ebx
je 0x118c3
movq $-0x4, %r13
callq 0xf502
movl %eax, %r15d
jmp 0x118d3
callq 0xf4e8
movzwl %ax, %r15d
movq $-0x2, %r13
movswq %bp, %rax
addq %r14, %r12
subq %rax, %r14
addq %r13, %r14
movl 0x8(%rsp), %ebp
movl %ebp, 0xcd9e(%rip)      # 0x1e688
movl %r15d, %eax
movq %rax, 0xcd9c(%rip)      # 0x1e690
subq %r14, %r12
decl %r14d
movl $0x28, %edi
callq 0x128e2
movl %ebp, (%rax)
movl %r15d, 0x4(%rax)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x8(%rax)
movq %r12, 0x10(%rax)
movl %r14d, 0x18(%rax)
movl %ebx, 0x1c(%rax)
movq $0x0, 0x20(%rax)
leaq 0xb68e(%rip), %rcx      # 0x1cfc0
movq (%rcx), %rsi
leaq -0x180(%rip), %rdx      # 0x117bc
movq %rax, %rdi
callq 0x125e8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_lidata.c
// Function: lidata
void lidata(size_t length, int extension)
{
    SEG_T           seg_search;
    SEG_T           *seg;
    dword   offset;
    long            position;

    position = o_position + length;     /* Position assumed at end of rec */

    length -= get_index( &seg_search.index );
    seg = (SEG_T *)find( (char *)&seg_search, segment_tree, TC seg_compare, NULL );
    if ( seg == NULL ) fmt_error("Undefined segment" );

    if ( extension == REGULAR ) {
        offset = (dword)get_word(); /* Spot to begin within segment */
        length -= 2;
    } else {
        offset = get_long();
        length -= 4;
    }

    data_seg_idx = seg_search.index;    /* Needed by FIXUPPs */
    data_offset  = offset;              /* Ditto */

    position -= length;                 /* Move back remainder of bytes */
    --length;                           /* Ignore checksum in length */

    dat_insert( seg_search.index, offset, position, length, 
                                                    extension, ITERATED );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xb5ed(%rip), %rax      # 0x1cf60
movq (%rax), %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0xf599
movl %eax, %ebp
leaq 0xb60e(%rip), %rax      # 0x1cf98
movq (%rax), %rsi
leaq 0x398(%rip), %rdx       # 0x11d2c
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x1280f
testq %rax, %rax
jne 0x119af
leaq 0x3079(%rip), %rdi      # 0x14a23
callq 0x128bc
testl %ebx, %ebx
je 0x119c3
callq 0xf502
movl %eax, %esi
movq $-0x4, %rax
jmp 0x119d2
callq 0xf4e8
movzwl %ax, %esi
movq $-0x2, %rax
movswq %bp, %rcx
addq %r14, %r15
subq %rcx, %r14
addq %rax, %r14
movl (%rsp), %edi
leaq 0xcc9f(%rip), %rax      # 0x1e688
movl %edi, (%rax)
leaq 0xcc9e(%rip), %rax      # 0x1e690
movq %rsi, (%rax)
subq %r14, %r15
decl %r14d
movq %r15, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
movl $0x1, %r9d
callq 0x117e1
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_linnum.c
// Function: linnum
void linnum(size_t length)
{
  char            *record;
  char            text[80];
  char            cksum;
  int             i;
  LINE_T          *line;

  get_byte();
  get_byte();
  length -= 3;
  record = o_malloc(length);
  get_str( length, record );
  i = 0;
  while (length) {
    line = (LINE_T*)o_malloc(sizeof(LINE_T));
    line->hex_offset = *(word*)&record[i+2];
    line = insert(line, line_tree, TC linnum_compare)->data;
    line->line_number = *(word*)&record[i];
    sprintf(text, "; %4d: %04X",line->line_number,line->hex_offset);
    out_line(text,"","","");
    out_newline();
    i+=4;
    length-=4;
  }
  out_newline();
  cksum = get_byte();
  cksum = cksum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0xf4b4
callq 0xf4b4
leaq -0x3(%rbx), %r15
movq %r15, %rdi
callq 0x128e2
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0xf53b
addq $-0x3, %rbx
je 0x11aee
leaq 0x30af(%rip), %r12      # 0x14b2b
movq %rsp, %r13
leaq 0x2686(%rip), %rbp      # 0x1410c
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x128e2
movl 0x2(%r14,%r15), %ecx
movq %rcx, (%rax)
leaq 0xb4ce(%rip), %rcx      # 0x1cf70
movq (%rcx), %rsi
movq %rax, %rdi
leaq -0x8f(%rip), %rdx       # 0x11a20
callq 0x125e8
movq 0x20(%rax), %rax
movl (%r14,%r15), %edx
movl %edx, 0x8(%rax)
movq (%rax), %rcx
movq %r13, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x91b0
movq %r13, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
movq %rbp, %rcx
callq 0xcb44
callq 0xcad9
addq $0x4, %r15
cmpq %r15, %rbx
jne 0x11a89
callq 0xcad9
callq 0xf4b4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_lnames.c
// Function: name_insert
void name_insert( this_name )
    char    *this_name;
{
    static  int name_count = 0;
    NAME_T  *name_rec;

    name_count++;
    name_rec = (NAME_T *)o_malloc( sizeof(NAME_T) );
    name_rec->index = name_count;
    strcpy( name_rec->name, this_name );

    insert( (char *)name_rec, name_tree, TC name_compare );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0xcb6d(%rip)            # 0x1e698
movl $0x30, %edi
callq 0x128e2
movq %rax, %r14
movl 0xcb5a(%rip), %eax      # 0x1e698
movl %eax, (%r14)
leaq 0x4(%r14), %rdi
movq %rbx, %rsi
callq 0x9070
leaq 0xb43c(%rip), %rax      # 0x1cf90
movq (%rax), %rsi
leaq -0x56(%rip), %rdx       # 0x11b08
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x125e8
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_lnames.c
// Function: lnames
void lnames(size_t length)
{
    char    mod_name[41];
    char    cksum;

    --length;
    while( length ) {
        length -= get_name( mod_name );
        name_insert( mod_name );
    }
    cksum = get_byte();
    cksum = cksum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
decq %rbx
je 0x11b99
movq %rsp, %r14
movq %r14, %rdi
callq 0xf564
movq %rax, %r15
movq %r14, %rdi
callq 0x11b1e
subq %r15, %rbx
jne 0x11b81
callq 0xf4b4
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_modend.c
// Function: modend
void modend(size_t length, int extension)
{
    int             type;

    /*
    ** Processing for MODEND records
    */
    type = get_byte();

    if ( type & 0x40 ) {
        data_seg_idx = 0;
        data_offset  = 0L;
        length -= decode_fixup( 1, 0, 1, 1, extension );    /* Seg 0 offset 1 */
    }
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0xf4b4
testb $0x40, %al
jne 0x11bb6
popq %rbx
retq
leaq 0xcacb(%rip), %rax      # 0x1e688
movl $0x0, (%rax)
leaq 0xcac6(%rip), %rax      # 0x1e690
movq $0x0, (%rax)
movl $0x1, %edi
xorl %esi, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl %ebx, %r8d
popq %rbx
jmp 0x112f8
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_pubdef.c
// Function: pubdef
void pubdef(size_t length, int scope)
{
    int             grp_idx;
    int             seg_idx;
    int             frame;
    int             typ_idx;
    dword   offset;
    char            pub_name[41];

    length -= get_index( &grp_idx );
    length -= get_index( &seg_idx );

    if ( seg_idx == 0 ) {
        frame = get_word();
        length -= 2;
    }

    --length;
    while ( length ) {
        length -= get_name( pub_name );

#ifdef DEBUG
printf("%s\n", pub_name );
#endif

        offset = (dword)get_word();

        pub_insert( seg_idx, offset, pub_name, PUBLIC, scope );
        length -= 2;
        length -= get_index( &typ_idx );
    }
    frame = frame;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %rdi
callq 0xf599
movswq %ax, %r12
leaq 0x4(%rsp), %r15
movq %r15, %rdi
callq 0xf599
movswq %ax, %rax
addq %r12, %rax
subq %rax, %r14
cmpl $0x0, (%r15)
jne 0x11cce
callq 0xf4e8
addq $-0x2, %r14
decq %r14
je 0x11d1c
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
callq 0xf564
movq %rax, %r13
callq 0xf4e8
movzwl %ax, %esi
movl 0x4(%rsp), %edi
movq %r15, %rdx
movl $0x1, %ecx
movl %ebx, %r8d
callq 0x11c13
movq %r12, %rdi
callq 0xf599
movswq %ax, %rax
addq %r13, %rax
subq %rax, %r14
addq $-0x2, %r14
jne 0x11cdd
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_segdef.c
// Function: seg_insert
void seg_insert( name_idx, class, length, bit32, code )
    int     name_idx;
    NAME_T  *class;
    int     length;
    int     bit32;
    int     code;
{
    static  int segment_count = 0;
    SEG_T   *segment_rec;

    segment_count++;
    segment_rec = (SEG_T *)o_malloc( sizeof(SEG_T) );
    segment_rec->index      = segment_count;
    segment_rec->name       = name_idx;
    segment_rec->class      = class;
    segment_rec->length     = length;       /* To infer extra dups          */
    segment_rec->code       = code;
    segment_rec->bit32      = bit32;        /* USE32 segment                */

    insert( (char *)segment_rec, segment_tree, TC seg_compare );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %r12d
incl 0xc93e(%rip)            # 0x1e69c
movl $0x80, %edi
callq 0x128e2
movl 0xc92e(%rip), %ecx      # 0x1e69c
movl %ecx, (%rax)
movl %r12d, 0x4(%rax)
movq %r15, 0x8(%rax)
movl %r14d, 0x10(%rax)
movl %ebx, 0x14(%rax)
movl %ebp, 0x18(%rax)
leaq 0xb20f(%rip), %rcx      # 0x1cf98
movq (%rcx), %rsi
leaq -0x67(%rip), %rdx       # 0x11d2c
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x125e8
// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_segdef.c
// Function: upstr
void upstr( dest, source )
    char     *dest;
    char     *source;
{
    char     ch;
    while ( (ch = *source) != '\0' ) {
        *dest++ = (char)toupper( ch );
        source++;
    }
    *dest = '\0';
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rsi), %bpl
testb %bpl, %bpl
je 0x11dd7
movq %rsi, %r14
callq 0x9030
incq %r14
movq (%rax), %rcx
movsbq %bpl, %rdx
movb (%rcx,%rdx,4), %cl
movb %cl, (%rbx)
incq %rbx
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x11dbd
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq