LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xf85b
testq %rax, %rax
je 0xf910
movq %rax, %rbx
leaq 0xd637(%rip), %rax      # 0x1cef8
cmpl $0x2, (%rax)
je 0xf910
leaq 0xd69b(%rip), %rax      # 0x1cf68
cmpl $0x3, (%rax)
jne 0xf910
leaq 0x4b1f(%rip), %rdi      # 0x143f8
callq 0xc9aa
movslq %ebp, %rax
leaq 0x9958(%rip), %rcx      # 0x19240
movq (%rcx,%rax,8), %rdx
leaq 0x52e9(%rip), %rsi      # 0x14bdc
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x91b0
movq %r14, %rdi
callq 0xc9d9
callq 0xca3f
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ebx, %ebx
leaq 0xd6c7(%rip), %r15      # 0x1cff0
movq (%r15), %rax
movl 0x1c(%rax,%rbx,4), %ebp
movl 0x34(%rax,%rbx,4), %r14d
cmpl 0x4c(%rax,%rbx,4), %ebp
jne 0xf942
cmpl 0x64(%rax,%rbx,4), %r14d
je 0xf95a
movl %ebx, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0xf89f
movq (%r15), %rax
movl %ebp, 0x4c(%rax,%rbx,4)
movl %r14d, 0x64(%rax,%rbx,4)
incq %rbx
cmpq $0x6, %rbx
jne 0xf929
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd67b(%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 0xf97f
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfe17
cmpl $0x29, %eax
je 0xfe26
cmpl $0x2c, %eax
jne 0xfe4a
movq %r13, %rdi
callq 0x9190
movl %eax, %ebp
jmp 0xfe4a
jne 0xfe46
movq %r13, %rdi
callq 0x9170
movq %rax, %rbx
jmp 0xfe4a
movl %ebp, %edi
callq 0xf62a
movslq %eax, %rcx
imulq %rbx, %rcx
movq (%r12), %rax
subq %rcx, %rax
jl 0xfe72
movq %rax, (%r12)
incl %r14d
jmp 0xfe4a
testl %eax, %eax
je 0xfe4f
incq %r13
jmp 0xfdf7
movabsq $0x74637572747320, %rax # imm = 0x74637572747320
movq (%rsp), %rcx
movq %rax, 0x5(%rcx)
movabsq $0x747320747361702e, %rax # imm = 0x747320747361702E
movq %rax, (%rcx)
xorl %ebp, %ebp
jmp 0xfe8b
movl 0x8(%r15), %edx
leaq 0x458e(%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_O1/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 0xf478
cmpb $-0x78, %al
je 0x103d8
movzbl %al, %ecx
cmpl $0x84, %ecx
je 0x103ba
cmpl $0x81, %ecx
jne 0x103e6
callq 0xf4ac
movzwl %ax, %ecx
movl $0x3, %eax
jmp 0x103eb
callq 0xf4ac
movzwl %ax, %r14d
callq 0xf478
movzbl %al, %ecx
shll $0x8, %ecx
addq %r14, %rcx
movl $0x4, %eax
jmp 0x103eb
callq 0xf4c6
movl %eax, %ecx
movl $0x5, %eax
jmp 0x103eb
movl $0x1, %eax
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x104a1
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xf528
movq %rax, %r13
leaq 0x1c(%rsp), %rdi
callq 0xf55d
movl %eax, %ebp
callq 0xf478
movl %eax, %r12d
cmpb $0x61, %al
jne 0x10456
leaq 0x10(%rsp), %rdi
callq 0x10388
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x10388
addl %ebx, %eax
jmp 0x10469
leaq 0x8(%rsp), %rdi
callq 0x10388
movq $0x1, 0x10(%rsp)
movswq %bp, %rcx
addq %rcx, %r13
notq %r13
addq %r13, %r14
movzbl %r12b, %edx
movl %eax, %ebx
movq 0x10(%rsp), %rcx
movl 0x8(%rsp), %r8d
movq %r15, %rdi
movl $0x1, %esi
movl 0x4(%rsp), %r9d
callq 0x11076
subq %rbx, %r14
jne 0x10419
callq 0xf478
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movzwl (%rsi), %r8d
movzwl 0x2(%rsi), %r10d
movl %r8d, %edx
shrl $0xb, %edx
movl %r8d, %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
andl $0x1f, %r8d
movl %r10d, %eax
shrl $0x3, %eax
andl $0x3c, %eax
leaq 0x354d(%rip), %rsi      # 0x1457c
movslq (%rax,%rsi), %r9
addq %rsi, %r9
movl %r10d, %r11d
andl $0x1f, %r11d
shrl $0x9, %r10d
addl $0x7bc, %r10d           # imm = 0x7BC
leaq 0x3919(%rip), %rsi      # 0x14968
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x91b0
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd57d(%rip)            # 0x1e618
movl $0x50, %edi
callq 0x1282e
movq %rax, %rbx
movl 0xd56a(%rip), %eax      # 0x1e618
movl %eax, (%rbx)
movl %ebp, %edi
callq 0xf608
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 0xbec2(%rip), %rax      # 0x1cfb0
movq (%rax), %rsi
leaq -0x98(%rip), %rdx       # 0x11060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12538
// File: /workspace/github_c_makefile_star2_O1/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 0x11163
movl %esi, %ebx
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r15, %rdi
callq 0xf528
movq %rax, %r13
movq %r12, %rdi
callq 0xf55d
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 0x11076
subq %rbp, %r14
jne 0x11130
callq 0xf478
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1282e
leaq 0xd498(%rip), %rcx      # 0x1e688
movl (%rcx), %ecx
movl %ecx, (%rax)
leaq 0xd495(%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 0x11242
movl %ebx, %ecx
leaq 0x37a1(%rip), %rdx      # 0x149e0
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x3c(%rax)
leaq 0xbd84(%rip), %rcx      # 0x1cfd0
movq (%rcx), %rsi
leaq -0xde(%rip), %rdx       # 0x11178
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12538
// File: /workspace/github_c_makefile_star2_O1/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 0x11477
movl %esi, %ebx
leaq 0xbac0(%rip), %r13      # 0x1cea0
leaq 0x4(%rsp), %r15
callq 0xf478
movzbl %al, %r12d
testb %r12b, %r12b
js 0x1142c
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 0xf55d
notl %eax
movswq %ax, %rax
addq %rax, %r14
movl 0x4(%rsp), %eax
movl %eax, 0x4(%r12,%rbp,8)
jmp 0x1146e
callq 0xf478
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 0x1126c
cltq
subq %rax, %r14
addq $-0x2, %r14
testq %r14, %r14
jne 0x113e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xd1dd(%rip)            # 0x1e684
movl $0x8, %edi
callq 0x1282e
movl 0xd1cd(%rip), %ecx      # 0x1e684
movl %ecx, (%rax)
movl %ebx, 0x4(%rax)
leaq 0xbadd(%rip), %rcx      # 0x1cfa0
movq (%rcx), %rsi
leaq -0x45(%rip), %rdx       # 0x11488
movq %rax, %rdi
popq %rbx
jmp 0x12538
// File: /workspace/github_c_makefile_star2_O1/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 0x1282e
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 0xb819(%rip), %rcx      # 0x1cfc0
movq (%rcx), %rsi
leaq -0x81(%rip), %rdx       # 0x11730
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12538
// File: /workspace/github_c_makefile_star2_O1/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 0xb77c(%rip), %rax      # 0x1cf60
movq (%rax), %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf55d
movl %eax, %ebp
leaq 0xb79b(%rip), %rax      # 0x1cf98
movq (%rax), %rsi
leaq 0x499(%rip), %rdx       # 0x11ca0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x1275f
testq %rax, %rax
jne 0x11822
leaq 0x32fb(%rip), %rdi      # 0x14b18
callq 0x12808
testl %ebx, %ebx
je 0x11837
movq $-0x4, %r13
callq 0xf4c6
movl %eax, %r15d
jmp 0x11847
callq 0xf4ac
movzwl %ax, %r15d
movq $-0x2, %r13
movswq %bp, %rax
addq %r14, %r12
subq %rax, %r14
addq %r13, %r14
movl 0x8(%rsp), %ebp
movl %ebp, 0xce2a(%rip)      # 0x1e688
movl %r15d, %eax
movq %rax, 0xce28(%rip)      # 0x1e690
subq %r14, %r12
decl %r14d
movl $0x28, %edi
callq 0x1282e
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 0xb71a(%rip), %rcx      # 0x1cfc0
movq (%rcx), %rsi
leaq -0x180(%rip), %rdx      # 0x11730
movq %rax, %rdi
callq 0x12538
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb679(%rip), %rax      # 0x1cf60
movq (%rax), %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0xf55d
movl %eax, %ebp
leaq 0xb69a(%rip), %rax      # 0x1cf98
movq (%rax), %rsi
leaq 0x398(%rip), %rdx       # 0x11ca0
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x1275f
testq %rax, %rax
jne 0x11923
leaq 0x3105(%rip), %rdi      # 0x14a23
callq 0x12808
testl %ebx, %ebx
je 0x11937
callq 0xf4c6
movl %eax, %esi
movq $-0x4, %rax
jmp 0x11946
callq 0xf4ac
movzwl %ax, %esi
movq $-0x2, %rax
movswq %bp, %rcx
addq %r14, %r15
subq %rcx, %r14
addq %rax, %r14
movl (%rsp), %edi
leaq 0xcd2b(%rip), %rax      # 0x1e688
movl %edi, (%rax)
leaq 0xcd2a(%rip), %rax      # 0x1e690
movq %rsi, (%rax)
subq %r14, %r15
decl %r14d
movq %r15, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
movl $0x1, %r9d
callq 0x11755
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xf478
callq 0xf478
leaq -0x3(%rbx), %r15
movq %r15, %rdi
callq 0x1282e
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0xf4ff
addq $-0x3, %rbx
je 0x11a62
leaq 0x313b(%rip), %r12      # 0x14b2b
movq %rsp, %r13
leaq 0x2712(%rip), %rbp      # 0x1410c
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x1282e
movl 0x2(%r14,%r15), %ecx
movq %rcx, (%rax)
leaq 0xb55a(%rip), %rcx      # 0x1cf70
movq (%rcx), %rsi
movq %rax, %rdi
leaq -0x8f(%rip), %rdx       # 0x11994
callq 0x12538
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 0xcad8
callq 0xca6d
addq $0x4, %r15
cmpq %r15, %rbx
jne 0x119fd
callq 0xca6d
callq 0xf478
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xcbf9(%rip)            # 0x1e698
movl $0x30, %edi
callq 0x1282e
movq %rax, %r14
movl 0xcbe6(%rip), %eax      # 0x1e698
movl %eax, (%r14)
leaq 0x4(%r14), %rdi
movq %rbx, %rsi
callq 0x9070
leaq 0xb4c8(%rip), %rax      # 0x1cf90
movq (%rax), %rsi
leaq -0x56(%rip), %rdx       # 0x11a7c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12538
// File: /workspace/github_c_makefile_star2_O1/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 0x11b0d
movq %rsp, %r14
movq %r14, %rdi
callq 0xf528
movq %rax, %r15
movq %r14, %rdi
callq 0x11a92
subq %r15, %rbx
jne 0x11af5
callq 0xf478
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf478
testb $0x40, %al
jne 0x11b2a
popq %rbx
retq
leaq 0xcb57(%rip), %rax      # 0x1e688
movl $0x0, (%rax)
leaq 0xcb52(%rip), %rax      # 0x1e690
movq $0x0, (%rax)
movl $0x1, %edi
xorl %esi, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl %ebx, %r8d
popq %rbx
jmp 0x1126c
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xf55d
movswq %ax, %r12
leaq 0x4(%rsp), %r15
movq %r15, %rdi
callq 0xf55d
movswq %ax, %rax
addq %r12, %rax
subq %rax, %r14
cmpl $0x0, (%r15)
jne 0x11c42
callq 0xf4ac
addq $-0x2, %r14
decq %r14
je 0x11c90
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
callq 0xf528
movq %rax, %r13
callq 0xf4ac
movzwl %ax, %esi
movl 0x4(%rsp), %edi
movq %r15, %rdx
movl $0x1, %ecx
movl %ebx, %r8d
callq 0x11b87
movq %r12, %rdi
callq 0xf55d
movswq %ax, %rax
addq %r13, %rax
subq %rax, %r14
addq $-0x2, %r14
jne 0x11c51
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xc9ca(%rip)            # 0x1e69c
movl $0x80, %edi
callq 0x1282e
movl 0xc9ba(%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 0xb29b(%rip), %rcx      # 0x1cf98
movq (%rcx), %rsi
leaq -0x67(%rip), %rdx       # 0x11ca0
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12538
// File: /workspace/github_c_makefile_star2_O1/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 0x11d4b
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 0x11d31
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x28, %edi
callq 0x1282e
movq %r14, 0x20(%rax)
xorl %ecx, %ecx
testl %ebx, %ebx
sete %cl
movw %cx, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: set_dir_action
static int set_dir_action(char *arg)
{
  arg = xstrdup(arg);

  char *colon = strchr(arg, ':');
  unsigned int flags = 0;
  while (colon)
    {
      *colon++ = 0;
      char *next = strchr(colon, ':');
      if (next)
	*next = 0;
      flags |= parse_dir_option(colon);
      colon = next;
    }

  char *eq = strchr(arg, '=');
  if (eq)
    {
      *eq++ = 0;
      return add_dir_rule(arg, (*eq ? eq : NULL), flags);
    }
  else
    {
      char *out = xmalloc(1 + strlen(arg) + 1);
      sprintf(out, "/%s", arg);
      return add_dir_rule(arg, out, flags);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2490
testq %rax, %rax
je 0x2d26
movq %rax, (%rsp)
movq %rax, %rdi
movl $0x3a, %esi
callq 0x21f0
testq %rax, %rax
je 0x2c9b
movq %rax, %r12
xorl %r14d, %r14d
leaq 0x266d(%rip), %r15      # 0x527f
leaq 0x24ef(%rip), %rbx      # 0x5108
movb $0x0, (%r12)
movq %r12, %r13
incq %r13
movq %r13, %rdi
movl $0x3a, %esi
callq 0x21f0
movq %rax, %r12
testq %rax, %rax
je 0x2c3e
movb $0x0, (%r12)
movq %r13, %rdi
movq %r15, %rsi
callq 0x22f0
xorl %ebp, %ebp
testl %eax, %eax
je 0x2c79
cmpq $0x4, %rbp
je 0x2c86
movslq 0x4(%rbx,%rbp,4), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0x22f0
incq %rbp
testl %eax, %eax
jne 0x2c4f
leaq -0x1(%rbp), %rax
cmpq $0x4, %rax
setae %al
jmp 0x2c7b
xorl %eax, %eax
movl $0x1, %edx
movl %ebp, %ecx
shll %cl, %edx
jmp 0x2c89
setae %al
testb %al, %al
jne 0x2d15
orl %edx, %r14d
testq %r12, %r12
jne 0x2c19
jmp 0x2c9e
xorl %r14d, %r14d
movq (%rsp), %rbx
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x21f0
testq %rax, %rax
je 0x2ccc
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
xorl %esi, %esi
cmpb $0x0, 0x1(%rax)
cmovneq %rcx, %rsi
movq %rbx, %rdi
jmp 0x2cff
movq %rbx, %rdi
callq 0x2180
leaq 0x2(%rax), %rdi
callq 0x2360
testq %rax, %rax
je 0x2d26
movq %rax, %r15
leaq 0x287a(%rip), %rsi      # 0x5566
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2460
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a31
leaq 0x2641(%rip), %rdi      # 0x535d
movq %r13, %rsi
xorl %eax, %eax
callq 0x2de4
leaq 0x2622(%rip), %rdi      # 0x534f
xorl %eax, %eax
callq 0x2de4
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: box_init
static void
box_init(void)
{
  if (box_id < 0 || box_id >= CONFIG_ISOLATE_NUM_BOXES)
    die("Sandbox ID out of range (allowed: 0-%d)", CONFIG_ISOLATE_NUM_BOXES-1);
  box_uid = CONFIG_ISOLATE_FIRST_UID + box_id;
  box_gid = CONFIG_ISOLATE_FIRST_GID + box_id;

  snprintf(box_dir, sizeof(box_dir), "%s/%d", CONFIG_ISOLATE_BOX_DIR, box_id);
  make_dir(box_dir);
  if (chdir(box_dir) < 0)
    die("chdir(%s): %m", box_dir);
}

// Assembly:
pushq %rbx
movl 0x63d3(%rip), %r8d      # 0x92c0
cmpl $0x7530, %r8d           # imm = 0x7530
jae 0x2f43
leal 0xea60(%r8), %eax
movl %eax, 0x6585(%rip)      # 0x9488
movl %eax, 0x6583(%rip)      # 0x948c
leaq 0x6580(%rip), %rbx      # 0x9490
leaq 0x2716(%rip), %rdx      # 0x562d
leaq 0x249b(%rip), %rcx      # 0x53b9
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x424f
movq %rbx, %rdi
callq 0x21a0
testl %eax, %eax
js 0x2f56
popq %rbx
retq
leaq 0x26bb(%rip), %rdi      # 0x5605
movl $0x752f, %esi           # imm = 0x752F
xorl %eax, %eax
callq 0x2de4
leaq 0x26d6(%rip), %rdi      # 0x5633
leaq 0x652c(%rip), %rsi      # 0x9490
xorl %eax, %eax
callq 0x2de4
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: cg_init
static void
cg_init(void)
{
  if (!cg_enable)
    return;

  char *cg_root = CONFIG_ISOLATE_CGROUP_ROOT;
  if (!dir_exists(cg_root))
    die("Control group filesystem at %s not mounted", cg_root);

  snprintf(cg_name, sizeof(cg_name), "box-%d", box_id);
  msg("Using control group %s\n", cg_name);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
cmpb $0x1, 0x6356(%rip)      # 0x92d0
jne 0x2fdb
leaq 0x25b1(%rip), %rdi      # 0x5534
movq %rsp, %rsi
callq 0x2320
testl %eax, %eax
js 0x2fe4
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x2fe4
movl 0x631b(%rip), %ecx      # 0x92c0
leaq 0x63c4(%rip), %rbx      # 0x9370
leaq 0x26d9(%rip), %rdx      # 0x568c
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2210
leaq 0x26ca(%rip), %rdi      # 0x5693
movq %rbx, %rsi
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
jmp 0x418b
addq $0x90, %rsp
popq %rbx
retq
leaq 0x2676(%rip), %rdi      # 0x5661
leaq 0x2542(%rip), %rsi      # 0x5534
xorl %eax, %eax
callq 0x2de4
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: add_dir_rule
static int add_dir_rule(char *in, char *out, unsigned int flags)
{
  // Make sure that "in" is relative
  while (in[0] == '/')
    in++;
  if (!*in)
    return 0;

  // Check "out"
  if (flags & DIR_FLAG_FS)
    {
      if (!out || out[0] == '/')
	return 0;
    }
  else
    {
      if (out && out[0] != '/' && strncmp(out, "./", 2))
	return 0;
    }

  // Override an existing rule
  struct dir_rule *r;
  for (r = first_dir_rule; r; r = r->next)
    if (!strcmp(r->inside, in))
      break;

  // Add a new rule
  if (!r)
    {
      r = xmalloc(sizeof(*r));
      r->inside = in;
      *last_dir_rule = r;
      last_dir_rule = &r->next;
      r->next = NULL;
    }
  r->outside = out;
  r->flags = flags;
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movzbl (%r15), %eax
cmpl $0x2f, %eax
jne 0x3a4f
incq %r15
jmp 0x3a41
testl %eax, %eax
jne 0x3a5a
xorl %eax, %eax
jmp 0x3afd
testb $0x4, %bl
jne 0x3a88
testq %r14, %r14
je 0x3a95
cmpb $0x2f, (%r14)
je 0x3a95
leaq 0x190f(%rip), %rsi      # 0x5380
movl $0x2, %edx
movq %r14, %rdi
callq 0x2080
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x3afd
jmp 0x3a95
xorl %eax, %eax
testq %r14, %r14
je 0x3afd
cmpb $0x2f, (%r14)
je 0x3afd
movq 0x5894(%rip), %r12      # 0x9330
testq %r12, %r12
je 0x3ab8
movq (%r12), %rdi
movq %r15, %rsi
callq 0x22f0
testl %eax, %eax
je 0x3aee
movq 0x18(%r12), %r12
jmp 0x3a9c
movl $0x20, %edi
callq 0x2360
testq %rax, %rax
je 0x3b09
movq %rax, %r12
movq %r15, (%rax)
movq 0x57a4(%rip), %rax      # 0x9278
movq %r12, (%rax)
movq %r12, %rax
addq $0x18, %rax
movq %rax, 0x5793(%rip)      # 0x9278
movq $0x0, 0x18(%r12)
movq %r14, 0x8(%r12)
movl %ebx, 0x10(%r12)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x183f(%rip), %rdi      # 0x534f
xorl %eax, %eax
callq 0x2de4
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: box_exit
static void NONRET
box_exit(int rc)
{
  if (box_pid > 0)
    {
      kill(-box_pid, SIGKILL);
      kill(box_pid, SIGKILL);
      meta_printf("killed:1\n");

      struct rusage rus;
      int p, stat;
      do
	p = wait4(box_pid, &stat, 0, &rus);
      while (p < 0 && errno == EINTR);
      if (p < 0)
	fprintf(stderr, "UGH: Lost track of the process (%m)\n");
      else
	final_stats(&rus);
    }

  if (rc < 2 && cleanup_ownership)
    {
      chowntree("box", orig_uid, orig_gid);
    }

  meta_close();
  exit(rc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movl %edi, %ebx
movl 0x5759(%rip), %edi      # 0x9350
testl %edi, %edi
jle 0x3c68
negl %edi
movl $0x9, %esi
callq 0x2340
movl 0x5743(%rip), %edi      # 0x9350
movl $0x9, %esi
callq 0x2340
leaq 0x17e4(%rip), %rdi      # 0x5402
xorl %eax, %eax
callq 0x3b44
leaq 0xc(%rsp), %r14
leaq 0x10(%rsp), %r15
movl 0x571b(%rip), %edi      # 0x9350
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x23f0
testl %eax, %eax
jns 0x3cb7
callq 0x2060
cmpl $0x4, (%rax)
je 0x3c2f
movq 0x53a1(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x17ab(%rip), %rsi      # 0x540c
xorl %eax, %eax
callq 0x2300
cmpl $0x1, %ebx
jg 0x3cab
testb $0x1, 0x56e0(%rip)      # 0x9354
je 0x3cab
movl 0x56ac(%rip), %eax      # 0x9328
movl 0x56aa(%rip), %ecx      # 0x932c
movl %eax, 0x57f8(%rip)      # 0x9480
movl %ecx, 0x57f6(%rip)      # 0x9484
leaq 0x1729(%rip), %rdi      # 0x53be
leaq 0x585(%rip), %rsi       # 0x4221
movl $0x20, %edx
movl $0x3, %ecx
callq 0x2050
callq 0x3df4
movl %ebx, %edi
callq 0x2470
leaq 0x10(%rsp), %rdi
callq 0x3cc3
jmp 0x3c68
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: final_stats
static void
final_stats(struct rusage *rus)
{
  total_ms = get_run_time_ms(rus);
  wall_ms = get_wall_time_ms();

  meta_printf("time:%d.%03d\n", total_ms/1000, total_ms%1000);
  meta_printf("time-wall:%d.%03d\n", wall_ms/1000, wall_ms%1000);
  meta_printf("max-rss:%ld\n", rus->ru_maxrss);
  meta_printf("csw-voluntary:%ld\n", rus->ru_nvcsw);
  meta_printf("csw-forced:%ld\n", rus->ru_nivcsw);

  cg_stats();
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
callq 0x3e11
movl %eax, 0x567f(%rip)      # 0x9358
callq 0x4014
movl %eax, 0x5678(%rip)      # 0x935c
movslq 0x566d(%rip), %rdx      # 0x9358
imulq $0x10624dd3, %rdx, %rsi # imm = 0x10624DD3
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x26, %rsi
addl %eax, %esi
imull $0x3e8, %esi, %eax      # imm = 0x3E8
subl %eax, %edx
leaq 0x1723(%rip), %rdi      # 0x5431
xorl %eax, %eax
callq 0x3b44
movslq 0x5640(%rip), %rdx      # 0x935c
imulq $0x10624dd3, %rdx, %rsi # imm = 0x10624DD3
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x26, %rsi
addl %eax, %esi
imull $0x3e8, %esi, %eax      # imm = 0x3E8
subl %eax, %edx
leaq 0x1700(%rip), %rdi      # 0x543f
xorl %eax, %eax
callq 0x3b44
movq 0x20(%rbx), %rsi
leaq 0x1701(%rip), %rdi      # 0x5452
xorl %eax, %eax
callq 0x3b44
movq 0x80(%rbx), %rsi
leaq 0x16f9(%rip), %rdi      # 0x545f
xorl %eax, %eax
callq 0x3b44
movq 0x88(%rbx), %rsi
leaq 0x16f7(%rip), %rdi      # 0x5472
xorl %eax, %eax
callq 0x3b44
cmpb $0x1, 0x5547(%rip)      # 0x92d0
jne 0x3deb
leaq 0x1816(%rip), %rsi      # 0x55a8
xorl %ebx, %ebx
movq %rsp, %rdx
xorl %edi, %edi
callq 0x4075
testl %eax, %eax
je 0x3dad
movq %rsp, %rdi
callq 0x22e0
movq %rax, %rbx
leaq 0x180f(%rip), %rsi      # 0x55c3
movq %rsp, %rdx
xorl %edi, %edi
callq 0x4075
testl %eax, %eax
je 0x3dd1
movq %rsp, %rdi
callq 0x22e0
cmpq %rbx, %rax
cmovaq %rax, %rbx
testq %rbx, %rbx
je 0x3deb
shrq $0xa, %rbx
leaq 0x1803(%rip), %rdi      # 0x55e4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3b44
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: cg_read
static int
cg_read(cg_controller controller, const char *attr, char *buf)
{
  int maybe = 0;
  if (attr[0] == '?')
    {
      attr++;
      maybe = 1;
    }

  char path[256];
  cg_makepath(path, sizeof(path), controller, attr);

  int fd = open(path, O_RDONLY);
  if (fd < 0)
    {
      if (maybe)
	return 0;
      die("Cannot read %s: %m", path);
    }

  int n = read(fd, buf, CG_BUFSIZE);
  if (n < 0)
    {
      if (maybe)
	return 0;
      die("Cannot read %s: %m", path);
    }
  if (n >= CG_BUFSIZE - 1)
    die("Attribute %s too long", path);
  if (n > 0 && buf[n-1] == '\n')
    n--;
  buf[n] = 0;

  if (verbose > 1)
    msg("CG: Read %s = %s\n", attr, buf);

  close(fd);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %rbx
movb (%rsi), %r13b
xorl %r14d, %r14d
cmpb $0x3f, %r13b
sete %r14b
addq %rsi, %r14
movl %edi, %eax
shlq $0x4, %rax
leaq 0x4ce9(%rip), %rcx      # 0x8d90
movq (%rax,%rcx), %r8
movq %r14, (%rsp)
leaq 0x148d(%rip), %rdx      # 0x5543
leaq 0x1477(%rip), %rcx      # 0x5534
leaq 0x52ac(%rip), %r9       # 0x9370
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
xorl %eax, %eax
callq 0x2210
movq %r12, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2400
testl %eax, %eax
js 0x4124
movl %eax, %ebp
movl $0x400, %edx            # imm = 0x400
movl %eax, %edi
movq %rbx, %rsi
callq 0x22c0
testl %eax, %eax
js 0x4121
cmpl $0x3ff, %eax            # imm = 0x3FF
jge 0x4178
testl %eax, %eax
je 0x4133
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
addq %rax, %rcx
movl %ecx, %edx
cmpb $0xa, (%rbx,%rdx)
cmovneq %rax, %rcx
movl %ecx, %eax
jmp 0x4135
xorl %r15d, %r15d
cmpb $0x3f, %r13b
je 0x4163
leaq 0x13c8(%rip), %rdi      # 0x54f9
jmp 0x417f
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
cmpl $0x2, 0x51cc(%rip)      # 0x930c
jl 0x4156
leaq 0x13d9(%rip), %rdi      # 0x5522
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x418b
movl %ebp, %edi
callq 0x2280
movl $0x1, %r15d
movl %r15d, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x138d(%rip), %rdi      # 0x550c
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x2de4
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: make_dir
static void make_dir(char *path)
{
  char *sep = (path[0] == '/' ? path+1 : path);

  for (;;)
    {
      sep = strchr(sep, '/');
      if (sep)
	*sep = 0;

      if (!dir_exists(path) && mkdir(path, 0777) < 0)
	die("Cannot create directory %s: %m\n", path);

      if (!sep)
	return;
      *sep++ = '/';
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %edi, %edi
cmpb $0x2f, (%rbx)
sete %dil
addq %rbx, %rdi
leaq 0x8(%rsp), %r14
movl $0xf000, %ebp           # imm = 0xF000
movl $0x2f, %esi
callq 0x21f0
movq %rax, %r15
testq %rax, %rax
je 0x428b
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2320
testl %eax, %eax
js 0x42a7
movl 0x20(%rsp), %eax
andl %ebp, %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x42b8
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x20b0
testl %eax, %eax
js 0x42d7
testq %r15, %r15
je 0x42c9
movq %r15, %rdi
incq %rdi
movb $0x2f, (%r15)
jmp 0x4275
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1363(%rip), %rdi      # 0x5641
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2de4
// File: /workspace/github_c_makefile_star2_O1/silverneko[P]miku/isolate/isolate.c
// Function: rmtree_helper
static int rmtree_helper(const char *fpath, const struct stat *sb,
    int typeflag, struct FTW *ftwbuf)
{
  if (S_ISDIR(sb->st_mode))
    {
      if (rmdir(fpath) < 0)
	die("Cannot rmdir %s: %m", fpath);
    }
  else
    {
      if (unlink(fpath) < 0)
	die("Cannot unlink %s: %m", fpath);
    }
  return FTW_CONTINUE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsi), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x430d
callq 0x2170
testl %eax, %eax
jns 0x4316
leaq 0x13e8(%rip), %rdi      # 0x56f3
jmp 0x4321
callq 0x2070
testl %eax, %eax
js 0x431a
xorl %eax, %eax
popq %rbx
retq
leaq 0x13e6(%rip), %rdi      # 0x5707
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2de4