LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_ymd_s_to_wnum
s2_t bcore_cday_ymd_s_to_wnum( const bcore_cday_ymd_s* o )
{
    bcore_cday_ymd_s ymd_l;
    bcore_cday_ymd_s_init( &ymd_l );
    ymd_l.y = o->y;
    ymd_l.m = 1;
    ymd_l.d = 1;

    sz_t first_cday = bcore_cday_ymd_s_to_cday( &ymd_l );
    sz_t first_wday = bcore_cday_to_wday( first_cday );

    // monday of week of first_cday
    sz_t mo1_cday = first_cday - first_wday;
    if( first_wday > 3 ) mo1_cday += 7;

    sz_t cur_cday = bcore_cday_ymd_s_to_cday( o );

    if( cur_cday < mo1_cday ) // last week of last year
    {
        if( first_wday == 4 ) return 53;
        if( first_wday == 5 ) return ( ( ymd_l.y - 1 ) % 4 ) == 0 ? 53 : 52;
        return 52;
    }
    else
    {
        sz_t wnum = 1 + ( cur_cday - mo1_cday ) / 7;
        if( wnum == 53 )
        {
            if( ( first_wday == 3 ) || ( ( ( ymd_l.y % 4 ) == 0 ) && ( first_wday == 2 ) ) )
            {
                return 53;
            }
            else
            {
                return 1;
            }
        }
        return wnum;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x626a4
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xc(%r14)
movq %r14, %rdi
callq 0xc7024
cltq
leal 0x3(%rax), %ecx
movslq %ecx, %rcx
imulq $-0x6db6db6d, %rcx, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %eax, %ecx
addl $0x3, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x2, %ecx
addl %edx, %ecx
leal (,%rcx,8), %edx
subl %edx, %ecx
leal (%rax,%rcx), %ebp
addl $0x3, %ebp
movslq %ebp, %rcx
subq %rcx, %rax
leaq 0x7(%rax), %r14
cmpl $0x4, %ecx
cmovlq %rax, %r14
movq %rbx, %rdi
callq 0xc7024
cltq
subq %r14, %rax
jge 0xc71ee
cmpl $0x4, %ebp
je 0xc7236
cmpl $0x5, %ebp
jne 0xc723d
movl 0x10(%rsp), %ecx
decl %ecx
andl $0x3, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
adcl $0x34, %eax
jmp 0xc7242
movabsq $0x4924924924924925, %rcx # imm = 0x4924924924924925
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq %rdx
addq %rdx, %rax
incq %rax
cmpq $0x35, %rax
jne 0xc7242
movl $0x35, %eax
cmpl $0x3, %ebp
je 0xc7242
movl 0x10(%rsp), %eax
andl $0x3, %eax
xorl $0x2, %ebp
orl %eax, %ebp
movl $0x35, %ecx
movl $0x1, %eax
cmovel %ecx, %eax
jmp 0xc7242
movl $0x35, %eax
jmp 0xc7242
movl $0x34, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_to_wnum
s2_t bcore_cday_to_wnum( s2_t cday )
{
    bcore_cday_ymd_s ymd_l;
    bcore_cday_ymd_s_init( &ymd_l );
    bcore_cday_ymd_s_from_cday( &ymd_l, cday );
    s2_t wnum = bcore_cday_ymd_s_to_wnum( &ymd_l );
    return wnum;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0x626a4
movq %r14, %rdi
movl %ebx, %esi
callq 0xc6d98
movq %r14, %rdi
callq 0xc714b
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_from_sc
s2_t bcore_cday_from_sc( sc_t sc )
{
    bcore_cday_ymd_s* ymd = bcore_cday_ymd_s_create();
    bcore_cday_ymd_s_from_sc( ymd, sc );
    s2_t cday = bcore_cday_ymd_s_to_cday( ymd );
    bcore_cday_ymd_s_discard( ymd );
    return cday;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x628e6
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11436d
movq %r14, %rdi
movq %r15, %rsi
callq 0xc6e3c
movq %r14, %rdi
callq 0xc7024
movl %eax, %ebx
movq %r14, %rdi
callq 0x62995
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_from_source
s2_t bcore_cday_from_source( bcore_source* source )
{
    bcore_cday_ymd_s* ymd = bcore_cday_ymd_s_create();
    bcore_cday_ymd_s_from_source( ymd, source );
    s2_t cday = bcore_cday_ymd_s_to_cday( ymd );
    bcore_cday_ymd_s_discard( ymd );
    return cday;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x628e6
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc6e3c
movq %r14, %rdi
callq 0xc7024
movl %eax, %ebx
movq %r14, %rdi
callq 0x62995
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_utc_s_from_system
bcore_cday_utc_s* bcore_cday_utc_s_from_system( bcore_cday_utc_s* o )
{
    u3_t stime = ( u3_t )time( NULL );
    s2_t epoch_days = stime / ( 24 * 3600 );
    s2_t seconds    = stime % ( 24 * 3600 );
    o->cday = bcore_cday_of_epoch() + epoch_days;
    o->ms = seconds * 1000;
    return o;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0xd4d0
movq %rax, %rcx
movabsq $-0x3dd1baf98d76b549, %rdx # imm = 0xC22E450672894AB7
mulq %rdx
shrq $0x10, %rdx
imull $0x15180, %edx, %eax    # imm = 0x15180
subl %eax, %ecx
addl $0x63a4, %edx           # imm = 0x63A4
movl %edx, 0x8(%rbx)
imull $0x3e8, %ecx, %eax      # imm = 0x3E8
movl %eax, 0xc(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_utc_s_normalize
bcore_cday_utc_s* bcore_cday_utc_s_normalize( bcore_cday_utc_s* o )
{
    s2_t range = 24 * 3600 * 1000;
    while( o->ms <      0 ) { o->cday--; o->ms += range; }
    while( o->ms >= range ) { o->cday++; o->ms -= range; }
    return o;
}

// Assembly:
movq %rdi, %rax
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
jns 0xc7434
cmpl $0xfad9a401, %ecx       # imm = 0xFAD9A401
movl $0xfad9a400, %edx       # imm = 0xFAD9A400
movl $0xfad9a400, %esi       # imm = 0xFAD9A400
cmovgel %ecx, %esi
xorl %edi, %edi
cmpl %edx, %ecx
setl %dil
subl %ecx, %esi
subl %edi, %esi
imulq $0x31b5d43b, %rsi, %rdx # imm = 0x31B5D43B
shrq $0x38, %rdx
addl %edi, %edx
imull $0x5265c00, %edx, %esi  # imm = 0x5265C00
notl %edx
addl $0x5265c00, %ecx        # imm = 0x5265C00
addl %esi, %ecx
addl %edx, 0x8(%rax)
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %ecx
cmpl $0x5265c00, %ecx        # imm = 0x5265C00
jl 0xc7479
movl $0xa4cb7ff, %edx        # imm = 0xA4CB7FF
cmpl %edx, %ecx
cmovll %ecx, %edx
negl %edx
addl %ecx, %edx
addl $0x5265bff, %edx        # imm = 0x5265BFF
imulq $0x31b5d43b, %rdx, %rdx # imm = 0x31B5D43B
shrq $0x38, %rdx
imull $0xfad9a400, %edx, %esi # imm = 0xFAD9A400
movl 0x8(%rax), %edi
addl %edi, %edx
incl %edx
addl $0xfad9a400, %ecx       # imm = 0xFAD9A400
addl %esi, %ecx
movl %edx, 0x8(%rax)
movl %ecx, 0xc(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_utc_s_to_sink
const bcore_cday_utc_s* bcore_cday_utc_s_to_sink( const bcore_cday_utc_s* o, bcore_sink* sink )
{
    bcore_cday_to_sink( o->cday, sink );
    s2_t secs = o->ms / 1000;
    s2_t hh = secs / 3600;
    secs = secs % 3600;
    s2_t mm = secs / 60;
    secs = secs % 60;
    s2_t ss = secs;
    bcore_sink_a_push_fa( sink, "T#pl2'0'{#<s2_t>}:#pl2'0'{#<s2_t>}:#pl2'0'{#<s2_t>}Z", hh, mm, ss );
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edi
callq 0xc72bf
movslq 0xc(%rbx), %rax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x6, %ecx
addl %edx, %ecx
imulq $0x4a90be59, %rax, %rdx # imm = 0x4A90BE59
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x20, %rdx
sarl $0x14, %edx
addl %eax, %edx
movslq %ecx, %rax
imulq $-0x6e5d4c3b, %rax, %rcx # imm = 0x91A2B3C5
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %esi
shrl $0x1f, %esi
sarl $0xb, %ecx
addl %esi, %ecx
imull $0xe10, %ecx, %ecx      # imm = 0xE10
subl %ecx, %eax
movslq %eax, %r8
imulq $-0x77777777, %r8, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %r8d, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0x5, %ecx
addl %eax, %ecx
imull $0x3c, %ecx, %eax
subl %eax, %r8d
leaq 0x86a55(%rip), %rsi     # 0x14df5d
movq %r14, %rdi
xorl %eax, %eax
callq 0x109273
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_utc_s_from_source
bcore_cday_utc_s* bcore_cday_utc_s_from_source( bcore_cday_utc_s* o, bcore_source* source )
{
    o->cday = bcore_cday_from_source( source );
    s2_t hh = 0;
    s2_t mm = 0;
    s2_t ss = 0;
    bcore_source_a_parse_fa( source, "T#-?'0'#<s2_t*>:#-?'0'#<s2_t*>:#-?'0'#<s2_t*>Z", &hh, &mm, &ss );
    o->ms = ( hh * 3600 + mm * 60 + ss ) * 1000;
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc7372
movl %eax, 0x8(%rbx)
xorl %eax, %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
leaq 0x8(%rsp), %r12
movl %eax, (%r12)
leaq 0x4(%rsp), %r13
movl %eax, (%r13)
leaq 0x86a34(%rip), %rsi     # 0x14df92
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x10ad37
imull $0xe10, (%r15), %eax    # imm = 0xE10
imull $0x3c, (%r12), %ecx
addl %eax, %ecx
addl (%r13), %ecx
imull $0x3e8, %ecx, %eax      # imm = 0x3E8
movl %eax, 0xc(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_write_fv
void bcore_write_fv( FILE* file, sc_t format, va_list args )
{
    st_s* s = st_s_create_fv( format, args );
    fwrite( s->sc, 1, s->size, file );
    fflush( file );
    st_s_discard( s );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x114cd0
movq %rax, %r14
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0xd3c0
movq %rbx, %rdi
callq 0xd4e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x114f61
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_writeln_fv
void bcore_writeln_fv( FILE* file, sc_t format, va_list args )
{
    st_s* s = st_s_create_fv( format, args );
    fwrite( s->sc, 1, s->size, file );
    fwrite( "\n", 1, 1, file );
    fflush( file );
    st_s_discard( s );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x114cd0
movq %rax, %r14
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0xd3c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0xd200
movq %rbx, %rdi
callq 0xd4e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x114f61
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_err
void bcore_err( sc_t format, ... )
{
    va_list args;
    va_start( args, format );
    bcore_wrnv( format, args );
    va_end( args );
    bcore_abort();
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xc80b2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0xd2f07(%rip), %rbx     # 0x19afe0
movq (%rbx), %rdi
movq %r10, %rsi
callq 0xd1e0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0xd200
callq 0xd0d0
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_ext_err
void bcore_ext_err( sc_t func, sc_t file, int line, sc_t format, ... )
{
    fprintf( stderr, "error:%s:%i:0 in function %s:\n", file, line, func );
    va_list args;
    va_start( args, format );
    bcore_wrnv( format, args );
    va_end( args );
    bcore_abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %rbx
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r10
testb %al, %al
je 0xc8148
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %r14
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0xd2e84(%rip), %r15     # 0x19afe0
movq (%r15), %rdi
leaq 0x86243(%rip), %rsi     # 0x14e3a9
movq %r10, %r8
xorl %eax, %eax
callq 0xd420
movq %rsp, %rdx
movq %r14, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xd1e0
movq (%r15), %rsi
movl $0xa, %edi
callq 0xd200
callq 0xd0d0
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_ext_err_fa
void bcore_ext_err_fa( sc_t func, sc_t file, int line, sc_t format, ... )
{
    fprintf( stderr, "error:%s:%i:0 in function %s:\n", file, line, func );
    va_list args;
    va_start( args, format );
    bcore_writeln_fv( stderr, format, args );
    va_end( args );
    bcore_abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %rbx
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r10
testb %al, %al
je 0xc82af
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %r14
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0xd2d1d(%rip), %r15     # 0x19afe0
movq (%r15), %rdi
leaq 0x860dc(%rip), %rsi     # 0x14e3a9
movq %r10, %r8
xorl %eax, %eax
callq 0xd420
movq %rsp, %rdx
movq %r14, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xc7d20
callq 0xd0d0
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_memmove
vd_t bcore_memmove( vd_t dst, vc_t src, uz_t size )
{
    if( !dst )
    {
        dst = bcore_memcpy( dst, src, size );
    }
    else
    {
        if( size > 0 ) memmove( dst, src, size );

    }
    return dst;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0xc8497
testq %rbx, %rbx
je 0xc84bd
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd2f0
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x11c0e8
movq %rax, %rdi
testq %rbx, %rbx
je 0xc84bd
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd490
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_get_time
void bcore_get_time( u3_t* seconds, u3_t* microseconds )
{
    struct timeval t = { 0 };
    gettimeofday( &t, NULL );
    if( seconds ) *seconds = t.tv_sec;
    if( microseconds ) *microseconds = t.tv_usec;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0xd140
testq %r14, %r14
je 0xc850a
movq (%rsp), %rax
movq %rax, (%r14)
testq %rbx, %rbx
je 0xc8517
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_error_manager.c
// Function: bcore_error_push_fv
er_t bcore_error_push_fv( er_t id, sc_t format, va_list args )
{
    st_s* msg = st_s_create_fv( format, args );
    er_t ret = bcore_error_push_sc( id, msg->sc );
    st_s_discard( msg );
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x114cd0
movq %rax, %r14
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xc86db
movq %r14, %rdi
callq 0x114f61
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_error_manager.c
// Function: bcore_error_push_ffl_fv
er_t bcore_error_push_ffl_fv( er_t id, sc_t func, sc_t file, sz_t line, sc_t format, va_list args )
{
    st_s* msg = st_s_create_fa( "error:#<sc_t>:#<sz_t>:0 in function #<sc_t>:\n", file, line, func );
    st_s_push_fv( msg, format, args );
    bcore_error_push_fa( id, "#<sc_t>", msg->sc );
    st_s_discard( msg );
    return id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x85b6e(%rip), %rdi     # 0x14e3c8
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x114d03
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x115785
movq 0x8(%r12), %rdx
leaq 0x873dd(%rip), %rsi     # 0x14fc64
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc87b0
movq %r12, %rdi
callq 0x114f61
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_error_manager.c
// Function: bcore_error_pop_to_sink
bl_t bcore_error_pop_to_sink( bcore_sink* sink )
{
    BLM_INIT();
    st_s* s = BLM_CREATE( st_s );
    bl_t success = bcore_error_pop_st( NULL, s );
    if( success && sink ) bcore_sink_a_push_fa( sink, "#<sc_t>\n", s->sc );
    BLM_RETURNV( bl_t, success );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xe02cc(%rip), %rax     # 0x1a8dd0
movq (%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xe0431
xorl %eax, %eax
callq 0x114bbb
movabsq $-0x503db0e6e1c2e704, %rsi # imm = 0xAFC24F191E3D18FC
movq %r14, %rdi
movq %rax, %rdx
callq 0xe0582
movq %rax, %r14
xorl %edi, %edi
movq %rax, %rsi
callq 0xc8a3e
movl %eax, %ebp
xorb $0x1, %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0xc8b5e
movq 0x8(%r14), %rdx
leaq 0x904b4(%rip), %rsi     # 0x159008
movq %rbx, %rdi
xorl %eax, %eax
callq 0x109273
movq %rsp, %rdi
callq 0xe0b30
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_error_manager.c
// Function: bcore_error_manager_signal_handler
vd_t bcore_error_manager_signal_handler( const bcore_signal_s* o )
{
    switch( bcore_signal_s_handle_type( o, btypeof( "bcore_error_manager" ) ) )
    {
        case TYPEOF_init0:
        {
        }
        break;

        case TYPEOF_init1:
        {
        }
        break;

        case TYPEOF_down1:
        {
            if( context_g )
            {
                s2_t verbosity = o->object ? *( s2_t* )o->object : 0;
                if( verbosity >= 0 && bcore_error_stack_size() > 0 )
                {
                    WRN_fa( "Error Manager: Stack is not empty!\nList of remaining errors:" );
                    st_s* msg = st_s_create();
                    er_t id = 0;
                    while( bcore_error_pop_st( &id, msg ) )
                    {
                        bcore_wrn_fa( "\n#<sc_t>: #<sc_t>\n", ifnameof( id ), msg->sc );
                    }
                    st_s_discard( msg );
                }
                bcore_error_manager_context_s_detach( &context_g );
            }
        }
        break;

        default: break;
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x31cbdf7c3004c3b3, %rsi # imm = 0x31CBDF7C3004C3B3
callq 0xe9c93
movabsq $-0x69a05654ee793a14, %rcx # imm = 0x965FA9AB1186C5EC
cmpq %rcx, %rax
jne 0xc8ce6
cmpq $0x0, 0xe0179(%rip)     # 0x1a8d98
je 0xc8ce6
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xc8c37
cmpl $0x0, (%rax)
js 0xc8ccf
callq 0xc869a
testq %rax, %rax
jle 0xc8ccf
leaq 0x857aa(%rip), %rdi     # 0x14e3f6
leaq 0x857c6(%rip), %rsi     # 0x14e419
leaq 0x857d5(%rip), %rcx     # 0x14e42f
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xd684
xorl %eax, %eax
callq 0x114bbb
movq %rax, %rbx
movq %rsp, %rdi
movq $0x0, (%rdi)
movq %rax, %rsi
callq 0xc8a3e
testb %al, %al
je 0xc8cc7
leaq 0x8aa62(%rip), %r12     # 0x1536ef
leaq 0x857d8(%rip), %r14     # 0x14e46c
movq %rsp, %r15
movq (%rsp), %rdi
callq 0xe0cbc
testq %rax, %rax
cmoveq %r12, %rax
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xc7f89
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc8a3e
testb %al, %al
jne 0xc8c97
movq %rbx, %rdi
callq 0x114f61
movq 0xe00c2(%rip), %rdi     # 0x1a8d98
callq 0x63e6d
movq $0x0, 0xe00b2(%rip) # 0x1a8d98
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_path_s_source
void bcore_file_path_s_source( bcore_file_path_s* o, bcore_source* source )
{
    sc_t file = bcore_source_a_get_file( source );
    st_s_detach( &o->full );
    st_s_detach( &o->root );
    if( file )
    {
        o->root = bcore_file_folder_path( file );
        if( o->root && o->name.size > 0 && o->name.sc[ 0 ] != '/' )
        {
            o->full = st_s_create_fa( "#<sc_t>/#<sc_t>", o->root->sc, o->name.sc );
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0xe0f9c(%rip), %rax     # 0x1a9cc8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0xc8d86
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0xc8d86
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0xc8d86
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0xc8e29
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0xc8db6
movabsq $-0x7e8ee9b9b4bbaa8, %rdi # imm = 0xF817116464B44558
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0xe0f1d(%rip), %rdi     # 0x1a9cc8
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %r14, %rsi
callq 0x10aa35
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x114f61
xorl %r15d, %r15d
movq %r15, 0x30(%rbx)
movq 0x28(%rbx), %rdi
callq 0x114f61
movq %r15, 0x28(%rbx)
testq %r14, %r14
je 0xc8e1d
movq %r14, %rdi
callq 0xc8e31
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xc8e1d
cmpq $0x0, 0x18(%rbx)
je 0xc8e1d
movq 0x10(%rbx), %rdx
cmpb $0x2f, (%rdx)
je 0xc8e1d
movq 0x8(%rax), %rsi
leaq 0x6f266(%rip), %rdi     # 0x138078
xorl %eax, %eax
callq 0x114d03
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0xc8d8a
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_folder_path
st_s* bcore_file_folder_path( sc_t path )
{
    st_s* s = st_s_create_sc( path );
    sz_t idx = st_s_find_char( s, -1, 0, '/' );
    if( s->data[ idx ] == '/' )
    {
        s->data[ idx ] = 0;
        s->size = idx;
    }
    else
    {
        s->data[ 0 ] = 0;
        s->size = 0;
    }

    // preserve explicit root folder
    if( s->size == 0 && path[ 0 ] == '/' ) st_s_push_char( s, '/' );

    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x114e47
movq %rax, %rbx
xorl %r15d, %r15d
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2f, %ecx
callq 0x1158c3
movq 0x8(%rbx), %rcx
cmpb $0x2f, (%rcx,%rax)
cmoveq %rax, %r15
movb $0x0, (%rcx,%r15)
movq %r15, 0x10(%rbx)
testq %r15, %r15
jne 0xc8e87
cmpb $0x2f, (%r14)
jne 0xc8e87
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x115381
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_path_minimized
st_s* bcore_file_path_minimized( sc_t path )
{
    if( !path ) return NULL;
    st_s* s = st_s_create();
    sc_t sc = path;
    while( *sc != 0 )
    {
        if( sc[0] == '/' )
        {
            while( sc[ 1 ] == '/' ) sc++;
            st_s_push_char( s, '/' );
            sc++;
        }
        else if( sc[0] == '.' && sc[1] == '/' )
        {
            sc += 2;
        }
        else if( sc[0] == '.' && sc[1] == '.' && sc[2] == '/' )
        {
            if( s->size > 1 && s->sc[ s->size - 1 ] == '/' )
            {
                st_s_pop_char( s );
                st_s_attach( &s, bcore_file_folder_path( s->sc ) );
                st_s_push_char( s, '/' );
            }
            else
            {
                st_s_push_sc( s, "../" );
            }
            sc += 3;
        }
        else
        {
            st_s_push_char( s, *sc );
            sc++;
        }
    }

    // if path is relative, ensure that s stays relative
    if( s->sc[ 0 ] == '/' && path[ 0 ] != '/' ) st_s_remove( s, 0, 1 );

    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xc8fe1
movq %rdi, %r14
xorl %eax, %eax
callq 0x114bbb
movq %rax, %rbx
leaq 0x85592(%rip), %r15     # 0x14e499
movq %r14, %r13
movzbl (%r13), %eax
cmpl $0x2e, %eax
je 0xc8f4b
cmpl $0x2f, %eax
je 0xc8f31
testl %eax, %eax
je 0xc8fc1
movsbl %al, %esi
movq %rbx, %rdi
callq 0x115381
incq %r13
jmp 0xc8f0a
cmpb $0x2f, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0xc8f31
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x115381
jmp 0xc8f0a
cmpb $0x2f, 0x1(%r13)
jne 0xc8f58
addq $0x2, %r13
jmp 0xc8f0a
cmpb $0x2e, %al
jne 0xc8f21
cmpb $0x2e, 0x1(%r13)
jne 0xc8f21
cmpb $0x2f, 0x2(%r13)
jne 0xc8f21
movq 0x10(%rbx), %rax
cmpq $0x2, %rax
jb 0xc8fad
movq 0x8(%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
jne 0xc8fad
movq %rbx, %rdi
callq 0x115450
movq 0x8(%rbx), %rdi
callq 0xc8e31
movq %rax, %r12
movq %rbx, %rdi
callq 0x114f61
movq %r12, %rdi
movl $0x2f, %esi
callq 0x115381
movq %r12, %rbx
jmp 0xc8fb8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x115620
addq $0x3, %r13
jmp 0xc8f0a
movq 0x8(%rbx), %rax
cmpb $0x2f, (%rax)
jne 0xc8fe3
cmpb $0x2f, (%r14)
je 0xc8fe3
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x115b5f
jmp 0xc8fe3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_extension
sc_t bcore_file_extension( sc_t path )
{
    st_s* s = st_s_create_sc( path );
    sz_t idx = st_s_find_char( s, -1, 0, '.' );
    if( s->data[ idx ] == '.' ) idx++;
    st_s_discard( s );
    return path + idx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x114e47
movq %rax, %r14
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2e, %ecx
callq 0x1158c3
movq %rax, %r15
movq 0x8(%r14), %rax
xorl %r12d, %r12d
cmpb $0x2e, (%rax,%r15)
sete %r12b
movq %r14, %rdi
callq 0x114f61
addq %r15, %rbx
addq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_name
sc_t bcore_file_name( sc_t path )
{
    st_s* s = st_s_create_sc( path );
    sz_t idx = st_s_find_char( s, -1, 0, '/' );
    st_s_discard( s );
    if( path[ idx ] == '/' ) return path + idx + 1;
    return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x114e47
movq %rax, %r14
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2f, %ecx
callq 0x1158c3
movq %rax, %r15
movq %r14, %rdi
callq 0x114f61
leaq (%rbx,%r15), %rax
incq %rax
cmpb $0x2f, -0x1(%rax)
cmoveq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_strip_extension
st_s* bcore_file_strip_extension( sc_t path )
{
    st_s* s = st_s_create_sc( path );
    sz_t idx = st_s_find_char( s, -1, 0, '.' );
    if( s->data[ idx ] == '.' )
    {
        s->data[ idx ] = 0;
        s->size = idx;
    }
    return s;
}

// Assembly:
pushq %rbx
callq 0x114e47
movq %rax, %rbx
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2e, %ecx
callq 0x1158c3
movq 0x8(%rbx), %rcx
cmpb $0x2e, (%rcx,%rax)
jne 0xc90c3
movb $0x0, (%rcx,%rax)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_folder_name
st_s* bcore_file_folder_name( sc_t path )
{
    st_s* s1 = bcore_file_folder_path( path );
    st_s* s2 = st_s_create_sc( bcore_file_name( s1->sc ) );
    st_s_discard( s1 );
    return s2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0xc8e31
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xc9049
movq %rax, %rdi
callq 0x114e47
movq %rax, %r14
movq %rbx, %rdi
callq 0x114f61
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_touch
bl_t bcore_file_touch( sc_t name )
{
    if( bcore_file_exists( name ) ) return true;
    vd_t handle = fopen( name, "wb" );
    if( !handle ) return false;
    fclose( handle );
    return true;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
callq 0xd450
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
je 0xc9184
leaq 0x85333(%rip), %rsi     # 0x14e49d
movq %rbx, %rdi
callq 0xd170
movq %rax, %rdi
testq %rax, %rax
setne %al
je 0xc9184
callq 0xd380
movb $0x1, %al
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_find_descend
bl_t bcore_file_find_descend( sc_t folder, sc_t path, st_s* result )
{
    BLM_INIT();
    st_s* st_folder = BLM_A_PUSH( st_s_create_sc( folder ) );
    st_s* st_result = BLM_A_PUSH( st_s_create() );

    for(;;)
    {
        st_s_copy_fa( st_result, "#<sc_t>/#<sc_t>", st_folder->sc, path );
        if( bcore_file_exists( st_result->sc ) )
        {
            if( result ) st_s_copy( result, st_result );
            //bcore_msg_fa( "#<sc_t>\n", result->sc );

            BLM_RETURNV( bl_t, true );
        }

        if( st_folder->size == 0 || ( st_folder->size == 1 && st_folder->sc[ 0 ] == '/' ) ) break;

        {
            st_s* st_new = bcore_file_folder_path( st_folder->sc );
            st_s_copy( st_folder, st_new );
            st_s_discard( st_new );
        }
    }

    BLM_RETURNV( bl_t, false );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xdfc07(%rip), %rax     # 0x1a8dd0
movq (%rax), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xe0431
movq %rbx, %rdi
callq 0x114e47
movq %r12, %rdi
movq %rax, %rsi
callq 0xe081c
movq %rax, %r15
xorl %eax, %eax
callq 0x114bbb
movq %r12, %rdi
movq %rax, %rsi
callq 0xe081c
movq %rax, %r12
movq 0x8(%r15), %rdx
leaq 0x6ee69(%rip), %rsi     # 0x138078
movq %rax, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x114736
movq 0x8(%r12), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd450
testl %eax, %eax
sete %bl
je 0xc929f
leaq 0x6ee3f(%rip), %r13     # 0x138078
leaq 0x38(%rsp), %rbp
movq 0x10(%r15), %rax
cmpq $0x1, %rax
je 0xc924f
testq %rax, %rax
jne 0xc9258
jmp 0xc92b0
movq 0x8(%r15), %rax
cmpb $0x2f, (%rax)
je 0xc92b0
movq 0x8(%r15), %rdi
callq 0xc8e31
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x114440
movq %rbx, %rdi
callq 0x114f61
movq 0x8(%r15), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x114736
movq 0x8(%r12), %rdi
movq %rbp, %rsi
callq 0xd450
testl %eax, %eax
sete %bl
jne 0xc923e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc92b0
movq %r12, %rsi
callq 0x114440
leaq 0x8(%rsp), %rdi
callq 0xe0b30
andb $0x1, %bl
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_item_s_move
BCORE_DEFINE_FUNCTION_MOVE (     bcore_self_item_s )
BCORE_DEFINE_FUNCTION_CREATE(    bcore_self_item_s )
BCORE_DEFINE_FUNCTION_DISCARD(   bcore_self_item_s )
BCORE_DEFINE_FUNCTION_CLONE(     bcore_self_item_s )

//----------------------------------------------------------------------------------------------------------------------

st_s* bcore_self_item_s_show( const bcore_self_item_s* o )
{
    st_s* s = st_s_create();
    st_s_push_fa( s, "bcore_self_item_s" );
    st_s_push_fa( s, "\n{" );
    st_s_push_fa( s, "\n    type    : #<tp_t> '#<sc_t>'", o->type, ifnameof( o->type ) );
    st_s_push_fa( s, "\n    name    : #<tp_t> '#<sc_t>'", o->name, ifnameof( o->name ) );
    st_s_push_fa( s, "\n    flags   : #<tp_t>",  o->flags );
    st_s_push_fa( s, "\n    caps    : #<sc_t>",  bcore_flect_caps_e_sc( o->caps ) );
    st_s_push_fa( s, "\n    default : #<s3_t>",  o->default_s3 );
    st_s_pushf( s, "\n}" );
    return s;
}

// Assembly:
cmpq %rsi, %rdi
je 0xc9539
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %esi
callq 0xc8366
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc944b
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
je 0xc9539
leaq -0x114(%rip), %rdi      # 0xc9420
jmp 0xc8352
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_item_s_create_plain
bcore_self_item_s* bcore_self_item_s_create_plain( u2_t caps, tp_t type, tp_t name )
{
    bcore_self_item_s* o = bcore_self_item_s_create();
    o->caps  = caps;
    o->type  = type;
    o->name  = name;
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0x28, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r15
movl $0x28, %esi
movq %rax, %rdi
callq 0xc8366
movl %ebp, 0x10(%r15)
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_item_s_create_func
bcore_self_item_s* bcore_self_item_s_create_func( sc_t fname, fp_t func, sc_t type, sc_t name )
{
    bcore_self_item_s* o = bcore_self_item_s_create();
    o->caps  = BCORE_CAPS_EXTERNAL_FUNC;
    o->type  = entypeof( type );
    o->name  = entypeof( name );
    o->default_tp = bcore_function_set_sc( fname, func );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r13
movl $0x28, %esi
movq %rax, %rdi
callq 0xc8366
movl $0xe, 0x10(%r13)
movq %r12, %rdi
callq 0xe1270
movq %rax, (%r13)
movq %r15, %rdi
callq 0xe1270
movq %rax, 0x8(%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd1173
movq %rax, 0x18(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_item_s_fold_tp
tp_t bcore_self_item_s_fold_tp( const bcore_self_item_s* o, tp_t tp )
{
    tp = bcore_tp_fold_tp( tp, o->type );
    tp = bcore_tp_fold_tp( tp, o->name );
    tp = bcore_tp_fold_u2( tp, o->caps );
    tp = bcore_tp_fold_tp( tp, o->flags.data );

    umax_t v = o->default_umax;
    for( uz_t i = 0; i < sizeof( umax_t ); i++ )
    {
        tp = bcore_tp_fold_u0( tp, v );
        v >>= 8;
    }
    return tp;
}

// Assembly:
pushq %rbp
pushq %rbx
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
movq (%rdi), %r9
movq 0x8(%rdi), %r8
movl $0xff, %edx
movq %r9, %r10
andq %rdx, %r10
xorq %rsi, %r10
imulq %rcx, %r10
movl %r9d, %esi
shrl $0x8, %esi
movl $0xff, %eax
andl %eax, %esi
xorq %r10, %rsi
imulq %rcx, %rsi
movl %r9d, %r10d
shrl $0x10, %r10d
andl %eax, %r10d
xorq %rsi, %r10
imulq %rcx, %r10
movl %r9d, %esi
shrl $0x18, %esi
xorq %r10, %rsi
imulq %rcx, %rsi
movq %r9, %r10
shrq $0x20, %r10
andq %rdx, %r10
xorq %rsi, %r10
imulq %rcx, %r10
movq %r9, %rsi
shrq $0x28, %rsi
andq %rdx, %rsi
xorq %r10, %rsi
imulq %rcx, %rsi
movq %r9, %r10
shrq $0x30, %r10
andq %rdx, %r10
xorq %rsi, %r10
imulq %rcx, %r10
shrq $0x38, %r9
xorq %r10, %r9
imulq %rcx, %r9
movq %r8, %rsi
andq %rdx, %rsi
xorq %r9, %rsi
imulq %rcx, %rsi
movl %r8d, %r9d
shrl $0x8, %r9d
andl %eax, %r9d
xorq %rsi, %r9
imulq %rcx, %r9
movl %r8d, %esi
shrl $0x10, %esi
andl %eax, %esi
xorq %r9, %rsi
imulq %rcx, %rsi
movl %r8d, %r9d
shrl $0x18, %r9d
xorq %rsi, %r9
imulq %rcx, %r9
movq %r8, %rsi
shrq $0x20, %rsi
andq %rdx, %rsi
xorq %r9, %rsi
imulq %rcx, %rsi
movq %r8, %r9
shrq $0x28, %r9
andq %rdx, %r9
xorq %rsi, %r9
imulq %rcx, %r9
movq %r8, %rsi
shrq $0x30, %rsi
andq %rdx, %rsi
xorq %r9, %rsi
imulq %rcx, %rsi
shrq $0x38, %r8
xorq %rsi, %r8
imulq %rcx, %r8
movl 0x10(%rdi), %ebx
movl %ebx, %esi
andl %eax, %esi
xorq %r8, %rsi
imulq %rcx, %rsi
movzbl %bh, %ebp
xorq %rsi, %rbp
imulq %rcx, %rbp
movl %ebx, %esi
shrl $0x10, %esi
andl %eax, %esi
xorq %rbp, %rsi
imulq %rcx, %rsi
shrl $0x18, %ebx
xorq %rsi, %rbx
imulq %rcx, %rbx
movl 0x14(%rdi), %esi
movq %rsi, %r8
andq %rdx, %r8
xorq %rbx, %r8
imulq %rcx, %r8
movl %esi, %edx
shrl $0x8, %edx
andl %eax, %edx
xorq %r8, %rdx
imulq %rcx, %rdx
movl %esi, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
xorq %rdx, %r8
imulq %rcx, %r8
shrl $0x18, %esi
xorq %r8, %rsi
movabsq $0xcaee32a7d4f6a63, %rax # imm = 0xCAEE32A7D4F6A63
imulq %rsi, %rax
movq 0x18(%rdi), %rdx
movl $0x8, %esi
movzbl %dl, %edi
xorq %rdi, %rax
imulq %rcx, %rax
shrq $0x8, %rdx
decq %rsi
jne 0xc98db
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_item_s_cmp
s2_t bcore_self_item_s_cmp( const bcore_self_item_s* o1, const bcore_self_item_s* o2 )
{
    if( o1->type       != o2->type       ) return ( o1->type < o2->type ) ? 1 : -1;
    if( o1->name       != o2->name       ) return ( o1->name < o2->name ) ? 1 : -1;
    if( o1->caps       != o2->caps       ) return ( o1->caps < o2->caps ) ? 1 : -1;
    if( o1->flags.data != o2->flags.data ) return ( o1->flags.data < o2->flags.data ) ? 1 : -1;
    if( o1->default_u3 != o2->default_u3 ) return ( o1->default_u3 < o2->default_u3 ) ? 1 : -1;
    return 0;
}

// Assembly:
movq (%rdi), %rcx
movq (%rsi), %rdx
cmpq %rdx, %rcx
jne 0xc992c
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xc992c
movl 0x10(%rdi), %ecx
movl 0x10(%rsi), %edx
cmpl %edx, %ecx
jne 0xc9938
movl 0x14(%rdi), %ecx
movl 0x14(%rsi), %edx
cmpl %edx, %ecx
jne 0xc9938
movq 0x18(%rdi), %rcx
movq 0x18(%rsi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0xc9937
xorl %eax, %eax
cmpq %rdx, %rcx
adcl $-0x1, %eax
orl $0x1, %eax
retq
xorl %eax, %eax
cmpl %edx, %ecx
jmp 0xc9931
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_body_s_down
void bcore_self_body_s_down( bcore_self_body_s* o )
{
    for( uz_t i = 0; i < o->size; i++ ) bcore_self_item_s_discard( o->data[ i ] );
    bcore_release( o->data );
    o->data  = NULL;
    o->size  = 0;
    o->space = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xccbec
xorl %r15d, %r15d
leaq -0x37af(%rip), %r14     # 0xc9420
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0xccbe3
movq %r14, %rdi
callq 0xc8352
incq %r15
cmpq 0x8(%rbx), %r15
jb 0xccbcf
movq (%rbx), %rdi
callq 0xc834d
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_body_s_copy
void bcore_self_body_s_copy( bcore_self_body_s* o, const bcore_self_body_s* src )
{
    for( uz_t i = 0; i < o->size; i++ ) bcore_self_item_s_discard( o->data[ i ] );
    bcore_release( o->data );
    o->data = NULL;
    o->size = 0;
    o->space = 0;

    o->data = bcore_un_alloc( sizeof( bcore_self_item_s* ), o->data, o->space, src->size, &o->space );
    for( uz_t i = 0; i < src->size; i++ ) o->data[ i ] = bcore_self_item_s_clone( src->data[ i ] );

    o->size = src->size;
    o->complete = src->complete;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xccc44
xorl %r12d, %r12d
leaq -0x3807(%rip), %r15     # 0xc9420
movq (%rbx), %rax
movq (%rax,%r12,8), %rsi
testq %rsi, %rsi
je 0xccc3b
movq %r15, %rdi
callq 0xc8352
incq %r12
cmpq 0x8(%rbx), %r12
jb 0xccc27
movq (%rbx), %rdi
callq 0xc834d
leaq 0x10(%rbx), %r8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
movl $0x8, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc833e
movq %rax, (%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xccc9e
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0xc94b5
movq (%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movq 0x8(%r14), %rax
cmpq %rax, %r15
jb 0xccc7f
movq %rax, 0x8(%rbx)
movb 0x18(%r14), %al
movb %al, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_body_s_push_d
bcore_self_item_s* bcore_self_body_s_push_d( bcore_self_body_s* o, bcore_self_item_s* item )
{
    if( o->size == o->space )
    {
        bcore_self_item_s** old_data = o->data;
        o->data = bcore_u_alloc( sizeof( bcore_self_item_s* ), NULL, o->space > 0 ? o->space * 2 : 1, &o->space );
        for( uz_t i = 0; i < o->size; i++ ) o->data[ i ] = old_data[ i ];
        bcore_release( old_data );
    }
    o->data[ o->size ] = item;
    o->size++;
    return o->data[ o->size -1 ];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jne 0xccdee
leaq 0x10(%rbx), %rcx
movq (%rbx), %r15
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x1, %edx
cmovneq %rsi, %rdx
movl $0x8, %edi
xorl %esi, %esi
callq 0xc8339
movq %rax, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0xccde6
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movq (%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq 0x8(%rbx), %rax
jb 0xccdd2
movq %r15, %rdi
callq 0xc834d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq (%rax,%rcx,8), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_body_s_show
st_s* bcore_self_body_s_show( const bcore_self_body_s* o )
{
    st_s* s = st_s_create();
    st_s_pushf( s, "bcore_self_body_s" );
    st_s_pushf( s, "\n{" );
    for( uz_t i = 0; i < o->size; i++ )
    {
        st_s_pushf( s, "\n    data[%lu]:", i );
        st_s_push_st_d( s, st_s_replace_char_sc( bcore_self_item_s_show( o->data[ i ] ), '\n', "\n    " ) );
    }
    st_s_pushf( s, "\n}" );
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %eax, %eax
callq 0x114bbb
movq %rax, %rbx
leaq 0x81b40(%rip), %rsi     # 0x14e987
movq %rax, %rdi
xorl %eax, %eax
callq 0x1156f6
leaq 0x817df(%rip), %rsi     # 0x14e637
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
cmpq $0x0, 0x8(%r14)
je 0xcceba
leaq 0x81b29(%rip), %r15     # 0x14e999
leaq 0x81b32(%rip), %r12     # 0x14e9a9
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x1156f6
movq (%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0xc955c
movq %rax, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x116181
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11556c
incq %r13
cmpq 0x8(%r14), %r13
jb 0xcce7a
leaq 0x81800(%rip), %rsi     # 0x14e6c1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_body_s_cmp
s2_t bcore_self_body_s_cmp( const bcore_self_body_s* o1, const bcore_self_body_s* o2 )
{
    if( o1->size != o2->size ) return ( o1->size < o2->size ) ? 1 : -1;
    for( uz_t i = 0; i < o1->size; i++ )
    {
        s2_t c = bcore_self_item_s_cmp( o1->data[ i ], o2->data[ i ] );
        if( c != 0 ) return c;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r14
movq 0x8(%rsi), %rax
cmpq %rax, %r14
jne 0xccf4d
testq %r14, %r14
je 0xccf49
movq (%rdi), %r15
movq (%rsi), %r12
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
movq (%r12,%r13,8), %rsi
callq 0xc98f1
testl %eax, %eax
cmovnel %eax, %ebx
jne 0xccf58
incq %r13
cmpq %r13, %r14
jne 0xccf2d
xorl %ebx, %ebx
jmp 0xccf58
xorl %ebx, %ebx
cmpq %rax, %r14
adcl $-0x1, %ebx
orl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_struct_body_to_sink
void bcore_self_s_struct_body_to_sink( const bcore_self_s* o, sz_t indent, bcore_sink* sink )
{
    sc_t name = nameof( o->type );
    st_s* buf = st_s_create();
    if( !name ) ERR_fa( "Type of reflection has no registered name." );
    bcore_sink_a_push_fa( sink, "#rn{ }{\n", indent );
    if( o->body )
    {
        for( sz_t i = 0; i < o->body->size; i++ )
        {
            const bcore_self_item_s* item = o->body->data[ i ];
            st_s_clear( buf );
            if( bcore_self_item_s_struct_to_sink( item, ( bcore_sink* )buf ) )
            {
                bcore_sink_a_push_fa( sink, "#rn{ }    #<sc_t>\n", indent, buf->sc );
            }
        }
    }
    st_s_discard( buf );
    bcore_sink_a_push_fa( sink, "#rn{ }}", indent );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0xe0cbc
movq %rax, %r13
xorl %eax, %eax
callq 0x114bbb
movq %rax, %r12
testq %r13, %r13
jne 0xcd047
leaq 0x819f8(%rip), %rdi     # 0x14ea25
leaq 0x815ba(%rip), %rsi     # 0x14e5ee
leaq 0x81998(%rip), %rcx     # 0x14e9d3
movl $0x584, %edx            # imm = 0x584
xorl %eax, %eax
callq 0xc825d
leaq 0x6bdc1(%rip), %rsi     # 0x138e0f
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x109273
cmpq $0x0, 0x30(%r15)
je 0xcd0b4
movq 0x30(%r15), %rax
cmpq $0x0, 0x8(%rax)
je 0xcd0b4
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %rbp
movq %r12, %rdi
callq 0x115353
movq %rbp, %rdi
movq %r12, %rsi
callq 0xcc9c6
testb %al, %al
je 0xcd0a7
movq 0x8(%r12), %rcx
movq %r14, %rdi
leaq 0x819a9(%rip), %rsi     # 0x14ea46
movq %rbx, %rdx
xorl %eax, %eax
callq 0x109273
incq %r13
movq 0x30(%r15), %rax
cmpq 0x8(%rax), %r13
jb 0xcd070
movq %r12, %rdi
callq 0x114f61
leaq 0x6b5df(%rip), %rsi     # 0x1386a2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x109273
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_struct_body_to_sink_single_line
void bcore_self_s_struct_body_to_sink_single_line( const bcore_self_s* o, bcore_sink* sink )
{
    sc_t name = nameof( o->type );
    if( !name ) ERR_fa( "Type of reflection has no registered name." );
    bcore_sink_a_push_fa( sink, "{" );
    if( o->body )
    {
        for( sz_t i = 0; i < o->body->size; i++ )
        {
            const bcore_self_item_s* item = o->body->data[ i ];
            bcore_self_item_s_struct_to_sink( item, sink );
        }
    }
    bcore_sink_a_push_fa( sink, "}" );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xe0cbc
testq %rax, %rax
jne 0xcd1ff
leaq 0x818c5(%rip), %rdi     # 0x14eaaa
leaq 0x81402(%rip), %rsi     # 0x14e5ee
leaq 0x817e0(%rip), %rcx     # 0x14e9d3
movl $0x5b3, %edx            # imm = 0x5B3
xorl %eax, %eax
callq 0xc825d
leaq 0x81432(%rip), %rsi     # 0x14e638
movq %rbx, %rdi
xorl %eax, %eax
callq 0x109273
cmpq $0x0, 0x30(%r14)
je 0xcd241
movq 0x30(%r14), %rax
cmpq $0x0, 0x8(%rax)
je 0xcd241
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0xcc9c6
incq %r15
movq 0x30(%r14), %rax
cmpq 0x8(%rax), %r15
jb 0xcd225
leaq 0x8147a(%rip), %rsi     # 0x14e6c2
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x109273