LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x6, -0x4(%rbp)
jge 0x124a9
leaq 0xddb0(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl 0x1c(%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
leaq 0xdd9b(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
leaq 0xdd83(%rip), %rcx      # 0x201c0
movq (%rcx), %rcx
movslq -0x4(%rbp), %rdx
cmpl 0x4c(%rcx,%rdx,4), %eax
jne 0x12461
movl -0xc(%rbp), %eax
leaq 0xdd6c(%rip), %rcx      # 0x201c0
movq (%rcx), %rcx
movslq -0x4(%rbp), %rdx
cmpl 0x64(%rcx,%rdx,4), %eax
je 0x12499
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x12360
movl -0x8(%rbp), %edx
leaq 0xdd47(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, 0x4c(%rax,%rcx,4)
movl -0xc(%rbp), %edx
leaq 0xdd32(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, 0x64(%rax,%rcx,4)
jmp 0x1249b
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x123ff
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x6, -0x4(%rbp)
jge 0x12514
leaq 0xdcf8(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl 0x4c(%rax,%rcx,4), %edx
leaq 0xdce6(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, 0x1c(%rax,%rcx,4)
leaq 0xdcd4(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl 0x64(%rax,%rcx,4), %edx
leaq 0xdcc2(%rip), %rax      # 0x201c0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, 0x34(%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x124bb
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb (%rax), %al
movb %al, -0x41(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x12d06
movsbl -0x41(%rbp), %eax
movl %eax, -0x48(%rbp)
subl $0x28, %eax
je 0x12c70
jmp 0x12c59
movl -0x48(%rbp), %eax
subl $0x29, %eax
je 0x12c95
jmp 0x12c63
movl -0x48(%rbp), %eax
subl $0x2c, %eax
je 0x12c83
jmp 0x12cf3
movq -0x40(%rbp), %rdi
addq $0x1, %rdi
callq 0x9150
movq %rax, -0x30(%rbp)
jmp 0x12cf5
movq -0x40(%rbp), %rdi
addq $0x1, %rdi
callq 0x9170
movl %eax, -0x24(%rbp)
jmp 0x12cf5
movl -0x24(%rbp), %edi
callq 0x11eb0
cltq
imulq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x38(%rbp), %rax
jge 0x12cd9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movl -0x28(%rbp), %ecx
leaq 0x5811(%rip), %rsi      # 0x184db
movb $0x0, %al
callq 0x9190
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12d1d
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x12cf5
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x12c36
movq -0x10(%rbp), %rdi
leaq 0x57d3(%rip), %rsi      # 0x184e4
callq 0x9060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x11ad0
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x81, %eax
je 0x1341e
jmp 0x13406
movl -0x14(%rbp), %eax
subl $0x84, %eax
je 0x13438
jmp 0x13412
movl -0x14(%rbp), %eax
subl $0x88, %eax
je 0x13467
jmp 0x13480
callq 0x11b50
movzwl %ax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x10(%rbp)
jmp 0x13493
callq 0x11b50
movzwl %ax, %eax
movq %rax, -0x20(%rbp)
callq 0x11ad0
movq -0x20(%rbp), %rcx
movzbl %al, %eax
shlq $0x8, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x4, -0x10(%rbp)
jmp 0x13493
callq 0x11b90
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x5, -0x10(%rbp)
jmp 0x13493
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13589
leaq -0x40(%rbp), %rdi
callq 0x11c40
movq %rax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq -0x44(%rbp), %rdi
callq 0x11c80
movswq %ax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
callq 0x11ad0
movzbl %al, %eax
movl %eax, -0x48(%rbp)
cmpl $0x61, -0x48(%rbp)
jne 0x13544
leaq -0x50(%rbp), %rdi
callq 0x133e0
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x133e0
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x13564
leaq -0x58(%rbp), %rdi
callq 0x133e0
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
movl -0x48(%rbp), %edx
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rax
movl %eax, %r8d
movl -0xc(%rbp), %r9d
movl $0x1, %esi
callq 0x14920
jmp 0x134bb
callq 0x11ad0
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
movb %al, -0x59(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_coment.c
// Function: scope_compare
int scope_compare(SCOPE_T *btreescope, SCOPE_T *scope)
{
  if ( btreescope->hex_offset > scope->hex_offset ) {
      return( LEFT );
  } else {
      if ( btreescope->hex_offset < scope->hex_offset ) {
          return( RIGHT );
      } else {
          return( EQUAL );
      }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x135c5
movl $0x0, -0x4(%rbp)
jmp 0x135e5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x135de
movl $0x1, -0x4(%rbp)
jmp 0x135e5
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_coment.c
// Function: sprint_date
static void sprint_date(char*string,char*datestr)
{
  TIME time;
  DATE date;

  time = *(TIME*)datestr;
  date = *(DATE*)&datestr[2];
  sprintf(string, "%02d:%02d:%02d on %.3s %d, %04d", time.hour, time.minute, time.seconds,
                months[date.month], date.day, date.year+1980);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movw -0x14(%rbp), %ax
shrw $0xb, %ax
movzwl %ax, %edx
movw -0x14(%rbp), %ax
shrw $0x5, %ax
andw $0x3f, %ax
movzwl %ax, %ecx
movw -0x14(%rbp), %ax
andw $0x1f, %ax
movzwl %ax, %r8d
movw -0x18(%rbp), %ax
shrw $0x5, %ax
andw $0xf, %ax
movzwl %ax, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0xb6c9(%rip), %rax      # 0x1ff50
movq (%rax,%rsi,8), %r9
movw -0x18(%rbp), %ax
andw $0x1f, %ax
movzwl %ax, %r10d
movw -0x18(%rbp), %ax
shrw $0x9, %ax
movzwl %ax, %eax
addl $0x7bc, %eax            # imm = 0x7BC
leaq 0x40e2(%rip), %rsi      # 0x18990
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x9190
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_extdef.c
// Function: ext_compare
int ext_compare( rec_1, rec_2 )
    EXT_T  *rec_1;
    EXT_T  *rec_2;
{
    if ( rec_1->index > rec_2->index ) {
        return( LEFT );
    } else {
        if ( rec_1->index < rec_2->index ) {
            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 0x148f3
movl $0x0, -0x4(%rbp)
jmp 0x14911
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1490a
movl $0x1, -0x4(%rbp)
jmp 0x14911
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl 0xcea4(%rip), %eax      # 0x217e8
addl $0x1, %eax
movl %eax, 0xce9b(%rip)      # 0x217e8
movl $0x50, %edi
callq 0x16e40
movq %rax, -0x28(%rbp)
movl 0xce87(%rip), %ecx      # 0x217e8
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %edi
callq 0x11de0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x34(%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x48(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
callq 0x9060
movq -0x28(%rbp), %rdi
leaq 0xb7ac(%rip), %rax      # 0x20180
movq (%rax), %rsi
leaq -0x10e(%rip), %rdx      # 0x148d0
callq 0x16820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14a5d
leaq -0x40(%rbp), %rdi
callq 0x11c40
movq %rax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq -0x44(%rbp), %rdi
callq 0x11c80
movswq %ax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
movl -0xc(%rbp), %r9d
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %ecx
movl %r8d, %esi
movl %r8d, %edx
callq 0x14920
jmp 0x14a0b
callq 0x11ad0
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
movb %al, -0x45(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_fixupp.c
// Function: fix_compare
int fix_compare( rec_1, rec_2 )
    FIX_T  *rec_1;
    FIX_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->dat_offset > rec_2->dat_offset ) {
                return( LEFT );
            } else {
                if ( rec_1->dat_offset < rec_2->dat_offset ) {
                    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 0x14aa6
movl $0x0, -0x4(%rbp)
jmp 0x14b2c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x14abd
movl $0x1, -0x4(%rbp)
jmp 0x14b2c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x14ad8
movl $0x0, -0x4(%rbp)
jmp 0x14b2c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x14af3
movl $0x1, -0x4(%rbp)
jmp 0x14b2c
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x14b0c
movl $0x0, -0x4(%rbp)
jmp 0x14b2c
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x14b25
movl $0x1, -0x4(%rbp)
jmp 0x14b2c
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl $0x40, %edi
callq 0x16e40
movq %rax, -0x28(%rbp)
leaq 0xccdd(%rip), %rax      # 0x21858
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
leaq 0xccd6(%rip), %rax      # 0x21860
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x8(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movl 0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x24(%rax)
movl 0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x28(%rax)
movl 0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x38(%rax)
cmpl $0x1, -0xc(%rbp)
je 0x14c03
cmpl $0x2, -0xc(%rbp)
je 0x14c03
cmpl $0x5, -0xc(%rbp)
jne 0x14c10
movq -0x28(%rbp), %rax
movl $0x1, 0x3c(%rax)
jmp 0x14c1b
movq -0x28(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x28(%rbp), %rdi
leaq 0xb57a(%rip), %rax      # 0x201a0
movq (%rax), %rsi
leaq -0x1b0(%rip), %rdx      # 0x14a80
callq 0x16820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_grpdef.c
// Function: grp_compare
int grp_compare( rec_1, rec_2 )
    GRP_T  *rec_1;
    GRP_T  *rec_2;
{
    if ( rec_1->index > rec_2->index ) {
        return( LEFT );
    } else {
        if ( rec_1->index < rec_2->index ) {
            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 0x14f83
movl $0x0, -0x4(%rbp)
jmp 0x14fa1
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x14f9a
movl $0x1, -0x4(%rbp)
jmp 0x14fa1
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0xc893(%rip), %eax      # 0x21854
addl $0x1, %eax
movl %eax, 0xc88a(%rip)      # 0x21854
movl $0x8, %edi
callq 0x16e40
movq %rax, -0x10(%rbp)
movl 0xc876(%rip), %ecx      # 0x21854
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
leaq 0xb177(%rip), %rax      # 0x20170
movq (%rax), %rsi
leaq -0xa3(%rip), %rdx       # 0x14f60
callq 0x16820
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_ledata.c
// Function: dat_compare
int dat_compare(DAT_T *rec_1,DAT_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 0x153a3
movl $0x0, -0x4(%rbp)
jmp 0x153f3
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x153ba
movl $0x1, -0x4(%rbp)
jmp 0x153f3
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jbe 0x153d3
movl $0x0, -0x4(%rbp)
jmp 0x153f3
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x153ec
movl $0x1, -0x4(%rbp)
jmp 0x153f3
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x28, %edi
callq 0x16e40
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x30(%rbp), %rdi
leaq 0xad02(%rip), %rax      # 0x20190
movq (%rax), %rsi
leaq -0x118(%rip), %rdx      # 0x15380
callq 0x16820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xac67(%rip), %rax      # 0x20130
movq (%rax), %rax
addq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x11c80
movswq %ax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq 0xac6f(%rip), %rax      # 0x20168
movq (%rax), %rsi
leaq -0x90(%rbp), %rdi
leaq 0x706(%rip), %rdx       # 0x15c10
xorl %eax, %eax
movl %eax, %ecx
callq 0x16c50
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x15530
leaq 0x3607(%rip), %rdi      # 0x18b32
callq 0x16e00
cmpl $0x0, -0xc(%rbp)
jne 0x15552
callq 0x11b50
movzwl %ax, %eax
movl %eax, -0x9c(%rbp)
movq -0x8(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x15569
callq 0x11b90
movl %eax, -0x9c(%rbp)
movq -0x8(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0x90(%rbp), %eax
movl %eax, 0xc2e3(%rip)      # 0x21858
movl -0x9c(%rbp), %eax
movq %rax, 0xc2de(%rip)      # 0x21860
movq -0x8(%rbp), %rcx
movq -0xa8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x90(%rbp), %edi
movl -0x9c(%rbp), %eax
movl %eax, %esi
movq -0xa8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl %eax, %ecx
movl -0xc(%rbp), %r8d
xorl %r9d, %r9d
callq 0x15400
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xab37(%rip), %rax      # 0x20130
movq (%rax), %rax
addq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x11c80
movswq %ax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq 0xab3f(%rip), %rax      # 0x20168
movq (%rax), %rsi
leaq -0x90(%rbp), %rdi
leaq 0x5d6(%rip), %rdx       # 0x15c10
xorl %eax, %eax
movl %eax, %ecx
callq 0x16c50
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x15660
leaq 0x33e0(%rip), %rdi      # 0x18a3b
callq 0x16e00
cmpl $0x0, -0xc(%rbp)
jne 0x15683
callq 0x11b50
movzwl %ax, %eax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x1569d
callq 0x11b90
movl %eax, %eax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0x90(%rbp), %ecx
leaq 0xc1ae(%rip), %rax      # 0x21858
movl %ecx, (%rax)
movq -0xa0(%rbp), %rcx
leaq 0xc1a6(%rip), %rax      # 0x21860
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0xa8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x90(%rbp), %edi
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl %eax, %ecx
movl -0xc(%rbp), %r8d
movl $0x1, %r9d
callq 0x15400
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_linnum.c
// Function: linnum_compare
int linnum_compare(LINE_T *btreeline, LINE_T*line)
{
    if ( btreeline->hex_offset > line->hex_offset ) {
        return( LEFT );
    } else {
        if ( btreeline->hex_offset < line->hex_offset ) {
            return( RIGHT );
        } else {
            return( EQUAL );
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x15735
movl $0x0, -0x4(%rbp)
jmp 0x15755
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x1574e
movl $0x1, -0x4(%rbp)
jmp 0x15755
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
callq 0x11ad0
callq 0x11ad0
movq -0x8(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16e40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11be0
movl $0x0, -0x68(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1585e
movl $0x10, %edi
callq 0x16e40
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movl -0x68(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx), %eax
movl %eax, %ecx
movq -0x70(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rdi
leaq 0xa960(%rip), %rax      # 0x20140
movq (%rax), %rsi
leaq -0xda(%rip), %rdx       # 0x15710
callq 0x16820
movq 0x20(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movslq -0x68(%rbp), %rcx
movl (%rax,%rcx), %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x8(%rax)
leaq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x70(%rbp), %rax
movq (%rax), %rcx
leaq 0x3323(%rip), %rsi      # 0x18b45
movb $0x0, %al
callq 0x9190
leaq -0x60(%rbp), %rdi
leaq 0x298c(%rip), %rcx      # 0x181c0
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xe2d0
callq 0xe280
movl -0x68(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x157a3
callq 0xe280
callq 0x11ad0
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
movb %al, -0x61(%rbp)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_lnames.c
// Function: name_compare
int name_compare( rec_1, rec_2 )
    NAME_T  *rec_1;
    NAME_T  *rec_2;
{
    if ( rec_1->index > rec_2->index ) {
        return( LEFT );
    } else {
        if ( rec_1->index < rec_2->index ) {
            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 0x158a3
movl $0x0, -0x4(%rbp)
jmp 0x158c1
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x158ba
movl $0x1, -0x4(%rbp)
jmp 0x158c1
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xbf86(%rip), %eax      # 0x21868
addl $0x1, %eax
movl %eax, 0xbf7d(%rip)      # 0x21868
movl $0x30, %edi
callq 0x16e40
movq %rax, -0x10(%rbp)
movl 0xbf69(%rip), %ecx      # 0x21868
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
callq 0x9060
movq -0x10(%rbp), %rdi
leaq 0xa83f(%rip), %rax      # 0x20160
movq (%rax), %rsi
leaq -0xab(%rip), %rdx       # 0x15880
callq 0x16820
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15981
leaq -0x40(%rbp), %rdi
callq 0x11c40
movq %rax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x158d0
jmp 0x15958
callq 0x11ad0
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movb %al, -0x41(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x11ad0
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x15a02
leaq 0xbe8c(%rip), %rax      # 0x21858
movl $0x0, (%rax)
leaq 0xbe87(%rip), %rax      # 0x21860
movq $0x0, (%rax)
movl -0xc(%rbp), %r8d
movl $0x1, %ecx
xorl %esi, %esi
movl %ecx, %edi
movl %ecx, %edx
callq 0x14c40
movslq %eax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_pubdef.c
// Function: pub_compare
int pub_compare( rec_1, rec_2 )
    PUB_T  *rec_1;
    PUB_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 0x15a33
movl $0x0, -0x4(%rbp)
jmp 0x15a87
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x15a4a
movl $0x1, -0x4(%rbp)
jmp 0x15a87
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x15a65
movl $0x0, -0x4(%rbp)
jmp 0x15a87
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x15a80
movl $0x1, -0x4(%rbp)
jmp 0x15a87
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x11c80
movswq %ax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x11c80
movswq %ax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x15b8c
callq 0x11b50
movzwl %ax, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15c01
leaq -0x60(%rbp), %rdi
callq 0x11c40
movq %rax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
callq 0x11b50
movzwl %ax, %eax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movl -0xc(%rbp), %r8d
movl $0x1, %ecx
callq 0x15a90
movq -0x8(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x8(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x11c80
movswq %ax, %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x15b98
movl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/rec_segdef.c
// Function: seg_compare
int seg_compare( rec_1, rec_2 )
    SEG_T  *rec_1;
    SEG_T  *rec_2;
{
    if ( rec_1->index > rec_2->index ) {
        return( LEFT );
    } else {
        if ( rec_1->index < rec_2->index ) {
            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 0x15c33
movl $0x0, -0x4(%rbp)
jmp 0x15c51
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x15c4a
movl $0x1, -0x4(%rbp)
jmp 0x15c51
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl 0xbbed(%rip), %eax      # 0x2186c
addl $0x1, %eax
movl %eax, 0xbbe4(%rip)      # 0x2186c
movl $0x80, %edi
callq 0x16e40
movq %rax, -0x28(%rbp)
movl 0xbbd0(%rip), %ecx      # 0x2186c
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rdi
leaq 0xa487(%rip), %rax      # 0x20168
movq (%rax), %rsi
leaq -0xdb(%rip), %rdx       # 0x15c10
callq 0x16820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x15d4b
movsbl -0x11(%rbp), %edi
callq 0x9070
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x15d10
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/t_tree.c
// Function: new_tree
NODE_T *new_tree(void *data_ptr, int dup_allowed)
{
    NODE_T *tree = o_malloc(sizeof(NODE_T));

    tree->data = data_ptr;

    if (dup_allowed) {        /* Hide the duplicates allowed indicator */
        tree->balance = LEFT; /* in the tree root's balance!           */
    }
    else {
        tree->balance = RIGHT;
    }

    tree->ptr[LEFT] = 0; /* Hide the tree depth in left pointer */
    tree->ptr[RIGHT] = (NODE_T *)tree;
    tree->thread[LEFT] = TRUE;
    tree->thread[RIGHT] = TRUE;

    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x28, %edi
callq 0x16e40
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x1635a
movq -0x18(%rbp), %rax
movw $0x0, (%rax)
jmp 0x16363
movq -0x18(%rbp), %rax
movw $0x1, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/t_tree.c
// Function: swap
static void swap(NODE_T *node_A, int direct_A, NODE_T *node_B, int direct_B)
{
    /* Swap the pointers (unless they are already threads) */
    if (node_A->thread[direct_A]) {
        node_B->ptr[direct_B] = node_A;
        node_B->thread[direct_B] = TRUE;
        node_A->thread[direct_A] = FALSE;
    }
    else {
        node_B->ptr[direct_B] = node_A->ptr[direct_A];
        node_A->ptr[direct_A] = node_B;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, 0x18(%rax,%rcx,4)
je 0x16c14
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x1, 0x18(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, 0x18(%rax,%rcx,4)
jmp 0x16c3f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/t_tree.c
// Function: find
void *find(void *data, NODE_T *root_node, int (*cmp_routine)(const void *, const void *), NODE_T **node_ptr)
{
    NODE_T *curr_node;
    int curr_direct;

    /* Prepare initial value for tree traversal */
    NODE_T *child_node = root_node;

    /*  Traverse tree looking for the place to insert this new node.  If
    **  we find a node which gives a comparison result of 0 (equal), then
    **  we cannot insert this new node.  To indicate this duplicate value,
    **  a non-zero value is returned (the value happens to be a pointer to
    **  node which contains the duplicate value). */
    do {
        curr_node = child_node;

        /*  Compare this new node with the node at this position in the
        **  tree and determine which direction to proceed from here. */
        curr_direct = (*cmp_routine)(curr_node->data, data);

        //  is this node is a duplicate node?
        if (node_ptr && curr_direct == RIGHT) {
            *node_ptr = curr_node;
        }

        if (curr_direct == EQUAL) {
            if (node_ptr) {
                *node_ptr = curr_node;
            }
            return curr_node->data;
        }

        child_node = curr_node->ptr[curr_direct];

    } while (!curr_node->thread[curr_direct]);

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16ca5
cmpl $0x1, -0x34(%rbp)
jne 0x16ca5
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x2, -0x34(%rbp)
jne 0x16ccb
cmpq $0x0, -0x28(%rbp)
je 0x16cbd
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x16cfe
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpl $0x0, 0x18(%rax,%rcx,4)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x16c70
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)