LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_sr_s_clear
bcore_arr_sr_s* bcore_arr_sr_s_clear( bcore_arr_sr_s* o )
{
    if( o->space == 0 )
    {
        o->data = NULL; // in case array is referencing external data
        o->size = 0;
    }

    for( uz_t i = 0; i < o->size; i++ ) sr_down( o->data[ i ] );
    o->size = 0;
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpq $0x0, 0x18(%rdi)
je 0xbaf7c
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xbaf83
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rcx
movq 0x10(%rcx,%r15), %rdx
movq %rdx, 0x30(%rsp)
movups (%rcx,%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
testb $0x2, %dl
je 0xbaf6e
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
movq 0x10(%rbx), %rax
incq %r12
addq $0x18, %r15
cmpq %rax, %r12
jb 0xbaf36
jmp 0xbaf83
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_sr_s_push
sr_s* bcore_arr_sr_s_push( bcore_arr_sr_s* o )
{
    if( o->size > o->space ) bcore_arr_sr_s_make_strong( o );
    if( o->size == o->space )
    {
        o->data = bcore_un_alloc( sizeof( sr_s ), o->data, o->space, o->space > 0 ? o->space * 2 : 1, &o->space );
    }
    o->data[ o->size++ ] = sr_null();
    return &o->data[ o->size - 1 ];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
jbe 0xbb1d9
movq %rbx, %rdi
callq 0xbb110
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
movq 0x8(%rbx), %rax
cmpq %rdx, %rcx
jne 0xbb20b
leaq 0x18(%rbx), %r8
leaq (%rdx,%rdx), %rsi
testq %rdx, %rdx
movl $0x1, %ecx
cmovneq %rsi, %rcx
movl $0x18, %edi
movq %rax, %rsi
callq 0xbe7da
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x18, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_sr_s_push_sr
sr_s* bcore_arr_sr_s_push_sr( bcore_arr_sr_s* o, sr_s v )
{
    if( o->size > o->space ) bcore_arr_sr_s_make_strong( o );
    if( o->size == o->space )
    {
        o->data = bcore_un_alloc( sizeof( sr_s ), o->data, o->space, o->space > 0 ? o->space * 2 : 1, &o->space );
    }
    o->data[ o->size++ ] = v;
    return &o->data[ o->size - 1 ];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
jbe 0xbb261
movq %rbx, %rdi
callq 0xbb110
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
leaq 0x20(%rsp), %r14
movq 0x8(%rbx), %rax
cmpq %rdx, %rcx
jne 0xbb298
leaq 0x18(%rbx), %r8
leaq (%rdx,%rdx), %rsi
testq %rdx, %rdx
movl $0x1, %ecx
cmovneq %rsi, %rcx
movl $0x18, %edi
movq %rax, %rsi
callq 0xbe7da
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rax,%rcx,8)
movups (%r14), %xmm0
movups %xmm0, (%rax,%rcx,8)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x18, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_sr_s_push_tp
sr_s* bcore_arr_sr_s_push_tp( bcore_arr_sr_s* o, tp_t type )
{
    if( o->size > o->space ) bcore_arr_sr_s_make_strong( o );
    if( o->size == o->space )
    {
        o->data = bcore_un_alloc( sizeof( sr_s ), o->data, o->space, o->space > 0 ? o->space * 2 : 1, &o->space );
    }
    o->data[ o->size++ ] = sr_create( type );
    return &o->data[ o->size - 1 ];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r13
movq 0x18(%rdi), %rdx
cmpq %rdx, %r13
jbe 0xbb2fd
movq %rbx, %rdi
callq 0xbb110
movq 0x10(%rbx), %r13
movq 0x18(%rbx), %rdx
movq 0x8(%rbx), %r15
cmpq %rdx, %r13
jne 0xbb332
leaq 0x18(%rbx), %r8
leaq (%rdx,%rdx), %rax
testq %rdx, %rdx
movl $0x1, %ecx
cmovneq %rax, %rcx
movl $0x18, %edi
movq %r15, %rsi
callq 0xbe7da
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %r13
leaq 0x1(%r13), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x10743a
movq %rax, %r12
testq %r14, %r14
je 0xbb354
movq %r14, %rdi
callq 0x1074f1
jmp 0xbb356
xorl %eax, %eax
leaq (,%r13,2), %rcx
addq %r13, %rcx
movq %r12, (%r15,%rcx,8)
movq %rax, 0x8(%r15,%rcx,8)
movq $0x2, 0x10(%r15,%rcx,8)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq -0x18(%rax,%rcx,8), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_sr_s_to_arr_st
const bcore_arr_sr_s* bcore_arr_sr_s_to_arr_st( const bcore_arr_sr_s* o, bcore_arr_st_s* arr )
{
    bcore_arr_st_s_clear( arr );
    bcore_arr_st_s_set_size( arr, o->size );
    for( uz_t i = 0; i < o->size; i++ )
    {
        if( sr_s_type( &o->data[ i ] ) == TYPEOF_st_s ) arr->data[ i ] = st_s_clone( ( const st_s* )o->data[ i ].o );
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb9bf4
movq 0x10(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb9c41
movq 0x10(%r14), %rax
cmpq %r15, %rax
jae 0xbb90c
movq 0x8(%r14), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xbb8f8
movq %r15, 0x10(%r14)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xbb966
movl $0x1, %r15d
xorl %r12d, %r12d
movabsq $-0x503db0e6e1c2e704, %r13 # imm = 0xAFC24F191E3D18FC
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0xbb95a
movq (%rcx,%r15,8), %rdx
testq %rdx, %rdx
je 0xbb95a
cmpq %r13, 0x8(%rdx)
jne 0xbb95a
movq -0x8(%rcx,%r15,8), %rdi
callq 0x10a2da
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x10(%rbx), %rax
incq %r12
addq $0x3, %r15
cmpq %rax, %r12
jb 0xbb92c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_ymd_s_from_cday
bcore_cday_ymd_s* bcore_cday_ymd_s_from_cday( bcore_cday_ymd_s* o, s2_t cday )
{
    s2_t lyr = cday / ( 365 * 4 + 1 );
    s2_t ldy = cday - lyr * ( 365 * 4 + 1 );
    s2_t qyr = ldy / 365;
    qyr = ( qyr > 3 ) ? 3 : qyr;
    s2_t yr = ( lyr * 4 ) + qyr;
    s2_t dy = ldy - qyr * 365;
    s2_t mt = 3;

    s2_t dtbl[] = { 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 };

    for( s2_t i = 0; i < 11; i++ )
    {
        if( dtbl[ i ] > dy ) break;
        dy -= dtbl[ i ];
        mt++;
    }

    o->d   = dy + 1;
    o->m = ( mt <= 12 ) ? mt : mt - 12;
    o->y  = 1900 + yr + ( ( mt <= 12 ) ? 0 : 1 );

    return o;
}

// Assembly:
movq %rdi, %rax
movslq %esi, %rdx
imulq $0x166db073, %rdx, %rcx # imm = 0x166DB073
movq %rcx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rcx
sarl $0x7, %ecx
addl %esi, %ecx
imull $0xfffffa4b, %ecx, %esi # imm = 0xFFFFFA4B
addl %esi, %edx
movslq %edx, %rdi
imulq $-0x4c73064f, %rdi, %rdx # imm = 0xB38CF9B1
shrq $0x20, %rdx
addl %edi, %edx
movl %edx, %esi
shrl $0x1f, %esi
sarl $0x8, %edx
addl %esi, %edx
cmpl $0x3, %edx
movl $0x3, %esi
cmovgel %esi, %edx
imull $0xfffffe93, %edx, %r10d # imm = 0xFFFFFE93
addl %edi, %r10d
xorl %r8d, %r8d
leaq 0x85aec(%rip), %r9      # 0x142d70
movl %r10d, %edi
subl (%r8,%r9), %edi
jl 0xbd2a3
incl %esi
addq $0x4, %r8
movl %edi, %r10d
cmpq $0x2c, %r8
jne 0xbd287
movl $0xe, %esi
jmp 0xbd2a6
movl %r10d, %edi
incl %edi
leal -0xc(%rsi), %r8d
cmpl $0xd, %esi
cmovbl %esi, %r8d
movl %edi, 0x10(%rax)
leal (%rdx,%rcx,4), %ecx
sbbl $-0x1, %ecx
movl %r8d, 0xc(%rax)
addl $0x76c, %ecx            # imm = 0x76C
movl %ecx, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_cday.c
// Function: bcore_cday_ymd_s_to_cday
s2_t bcore_cday_ymd_s_to_cday( const bcore_cday_ymd_s* o )
{
    bcore_cday_ymd_s_check_plausibility( o );

    s2_t yr = o->y - 1900;
    s2_t leap_days = 1 + ( yr / 4 );
    if( ( o->m < 3 ) && ( yr % 4 == 0 ) ) leap_days--;

    s2_t sum = yr * 365 + leap_days;

    switch( o->m - 1 )
    {
        case 11: sum += 30;
        case 10: sum += 31;
        case  9: sum += 30;
        case  8: sum += 31;
        case  7: sum += 31;
        case  6: sum += 30;
        case  5: sum += 31;
        case  4: sum += 30;
        case  3: sum += 31;
        case  2: sum += 28;
        case  1: sum += 31;
        case  0:
        default: break;
    }

    sum += o->d - 1;

    if( sum < 60 ) ERR( "Lowest possible cday '0' subceeded. 0 is mapped to 01.03.1900" );
    sum -= 60;

    return sum;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbceb0
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
leal -0x76c(%rax), %edx
movl %eax, %esi
addl $0xfffff897, %esi       # imm = 0xFFFFF897
testl %edx, %edx
cmovnsl %edx, %esi
sarl $0x2, %esi
cmpl $0x3, %ecx
setge %dil
testb $0x3, %al
setne %al
orb %dil, %al
movzbl %al, %edi
imull $0x16d, %edx, %eax      # imm = 0x16D
addl %edi, %eax
addl %esi, %eax
addl $-0x2, %ecx
cmpl $0xa, %ecx
ja 0xbd53b
leaq 0x8582f(%rip), %rdx     # 0x142d40
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
addl $0x1e, %eax
addl $0x1f, %eax
addl $0x1e, %eax
addl $0x1f, %eax
addl $0x1f, %eax
addl $0x1e, %eax
addl $0x1f, %eax
addl $0x1e, %eax
addl $0x1f, %eax
addl $0x1c, %eax
addl $0x1f, %eax
movl 0x10(%rbx), %ecx
leal (%rax,%rcx), %ebx
decl %ebx
cmpl $0x3b, %ebx
jg 0xbd569
leaq 0x859c9(%rip), %rdi     # 0x142f18
leaq 0x858ab(%rip), %rsi     # 0x142e01
leaq 0x859d4(%rip), %rcx     # 0x142f31
movl $0x8e, %edx
xorl %eax, %eax
callq 0xbe592
addl $-0x3c, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5c95a
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xc(%r14)
movq %r14, %rdi
callq 0xbd4c1
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 0xbd4c1
cltq
subq %r14, %rax
jge 0xbd68b
cmpl $0x4, %ebp
je 0xbd6d3
cmpl $0x5, %ebp
jne 0xbd6da
movl 0x10(%rsp), %ecx
decl %ecx
andl $0x3, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
adcl $0x34, %eax
jmp 0xbd6df
movabsq $0x4924924924924925, %rcx # imm = 0x4924924924924925
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq %rdx
addq %rdx, %rax
incq %rax
cmpq $0x35, %rax
jne 0xbd6df
movl $0x35, %eax
cmpl $0x3, %ebp
je 0xbd6df
movl 0x10(%rsp), %eax
andl $0x3, %eax
xorl $0x2, %ebp
orl %eax, %ebp
movl $0x35, %ecx
movl $0x1, %eax
cmovel %ecx, %eax
jmp 0xbd6df
movl $0x35, %eax
jmp 0xbd6df
movl $0x34, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5c95a
movq %r14, %rdi
movl %ebx, %esi
callq 0xbd226
movq %r14, %rdi
callq 0xbd5e8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5cb8d
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x109427
movq %r14, %rdi
movq %r15, %rsi
callq 0xbd2ca
movq %r14, %rdi
callq 0xbd4c1
movl %eax, %ebx
movq %r14, %rdi
callq 0x5cc38
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5cb8d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbd2ca
movq %r14, %rdi
callq 0xbd4c1
movl %eax, %ebx
movq %r14, %rdi
callq 0x5cc38
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbd8d1
cmpl $0xfad9a401, %ecx       # imm = 0xFAD9A401
movl $0xfad9a400, %edx       # imm = 0xFAD9A400
movl $0xfad9a400, %esi       # imm = 0xFAD9A400
cmovael %ecx, %esi
xorl %edi, %edi
cmpl %edx, %ecx
setb %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)
cmpl $0x5265c00, %ecx        # imm = 0x5265C00
jl 0xbd912
movl 0x8(%rax), %edx
xorl %esi, %esi
movl %ecx, %edi
subl $0xa4cb7ff, %edi        # imm = 0xA4CB7FF
cmovbl %esi, %edi
addl $0x5265bff, %edi        # imm = 0x5265BFF
imulq $0x31b5d43b, %rdi, %rsi # imm = 0x31B5D43B
shrq $0x38, %rsi
addl %esi, %edx
incl %edx
imull $0xfad9a400, %esi, %esi # imm = 0xFAD9A400
addl $0xfad9a400, %ecx       # imm = 0xFAD9A400
addl %esi, %ecx
movl %edx, 0x8(%rax)
movl %ecx, 0xc(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbd75c
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
movswl %ax, %ecx
imull $0xffff8889, %ecx, %ecx # imm = 0xFFFF8889
shrl $0x10, %ecx
addl %eax, %ecx
movzwl %cx, %ecx
movswl %cx, %esi
shrl $0xf, %ecx
sarl $0x5, %esi
addl %ecx, %esi
movswl %si, %ecx
imull $0x3c, %esi, %esi
subl %esi, %eax
movswl %ax, %r8d
leaq 0x855f5(%rip), %rsi     # 0x142f9d
movq %r14, %rdi
xorl %eax, %eax
callq 0xfe6d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbd80f
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 0x855d4(%rip), %rsi     # 0x142fd2
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x100150
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_O3/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 0x109d97
movq %rax, %r14
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0xd3d0
movq %rbx, %rdi
callq 0xd4f0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10a028
// File: /workspace/github_c_makefile_star2_O3/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 0x109d97
movq %rax, %r14
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0xd3d0
movl $0xa, %edi
movq %rbx, %rsi
callq 0xd200
movq %rbx, %rdi
callq 0xd4f0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10a028
// File: /workspace/github_c_makefile_star2_O3/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 0xbe5e4
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 0xcf9e8(%rip), %r15     # 0x18dfe0
movq (%r15), %rdi
leaq 0x84de7(%rip), %rsi     # 0x1433e9
movq %r10, %r8
xorl %eax, %eax
callq 0xd430
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_O3/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 0xbe74b
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 0xcf881(%rip), %r15     # 0x18dfe0
movq (%r15), %rdi
leaq 0x84c80(%rip), %rsi     # 0x1433e9
movq %r10, %r8
xorl %eax, %eax
callq 0xd430
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 0xbe1bc
callq 0xd0d0
// File: /workspace/github_c_makefile_star2_O3/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 0xbe923
testq %rbx, %rbx
je 0xbe949
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 0x110e57
movq %rax, %rdi
testq %rbx, %rbx
je 0xbe949
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4a0
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbe996
movq (%rsp), %rax
movq %rax, (%r14)
testq %rbx, %rbx
je 0xbe9a3
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x109d97
movq %rax, %r14
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xbeb67
movq %r14, %rdi
callq 0x10a028
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x84722(%rip), %rdi     # 0x143408
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x109dca
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10a85f
movq 0x8(%r12), %rdx
leaq 0x85f62(%rip), %rsi     # 0x144c75
movq %rbx, %rdi
xorl %eax, %eax
callq 0xbec3c
movq %r12, %rdi
callq 0x10a028
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdce40(%rip), %rax     # 0x19bdd0
movq (%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xd6675
xorl %eax, %eax
callq 0x109c82
movabsq $-0x503db0e6e1c2e704, %rsi # imm = 0xAFC24F191E3D18FC
movq %r14, %rdi
movq %rax, %rdx
callq 0xd67bd
movq %rax, %r14
xorl %edi, %edi
movq %rax, %rsi
callq 0xbeeca
movl %eax, %ebp
xorb $0x1, %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0xbefea
movq 0x8(%r14), %rdx
leaq 0x8f088(%rip), %rsi     # 0x14e068
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfe6d6
movq %rsp, %rdi
callq 0xd6d2c
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdfce3
movabsq $-0x69a05654ee793a14, %rcx # imm = 0x965FA9AB1186C5EC
cmpq %rcx, %rax
jne 0xbf172
cmpq $0x0, 0xdcced(%rip)     # 0x19bd98
je 0xbf172
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xbf0c3
cmpl $0x0, (%rax)
js 0xbf15b
callq 0xbeb26
testq %rax, %rax
jle 0xbf15b
leaq 0x8435e(%rip), %rdi     # 0x143436
leaq 0x8437a(%rip), %rsi     # 0x143459
leaq 0x84389(%rip), %rcx     # 0x14346f
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xd6be
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
movq %rsp, %rdi
movq $0x0, (%rdi)
movq %rax, %rsi
callq 0xbeeca
testb %al, %al
je 0xbf153
leaq 0x895fc(%rip), %r12     # 0x148715
leaq 0x8438c(%rip), %r14     # 0x1434ac
movq %rsp, %r15
movq (%rsp), %rdi
callq 0xd6ec4
testq %rax, %rax
cmoveq %r12, %rax
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xbe425
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbeeca
testb %al, %al
jne 0xbf123
movq %rbx, %rdi
callq 0x10a028
movq 0xdcc36(%rip), %rdi     # 0x19bd98
callq 0x5e088
movq $0x0, 0xdcc26(%rip) # 0x19bd98
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xddb10(%rip), %rax     # 0x19ccc8
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 0xbf20e
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0xbf20e
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0xbf20e
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0xbf217
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0xbf23e
movabsq $-0x7e8ee9b9b4bbaa8, %rdi # imm = 0xF817116464B44558
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0xdda95(%rip), %rdi     # 0x19ccc8
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r12, %rdi
movq %r14, %rsi
callq 0xffe4a
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x10a028
xorl %r15d, %r15d
movq %r15, 0x30(%rbx)
movq 0x28(%rbx), %rdi
callq 0x10a028
movq %r15, 0x28(%rbx)
testq %r14, %r14
je 0xbf2a5
movq %r14, %rdi
callq 0xbf2b1
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xbf2a5
cmpq $0x0, 0x18(%rbx)
je 0xbf2a5
movq 0x10(%rbx), %rdx
cmpb $0x2f, (%rdx)
je 0xbf2a5
movq 0x8(%rax), %rsi
leaq 0x6ddde(%rip), %rdi     # 0x12d078
xorl %eax, %eax
callq 0x109dca
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x109f0e
movq %rax, %rbx
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2f, %ecx
callq 0x10a99d
movq 0x8(%rbx), %rcx
cmpb $0x2f, (%rcx,%rax)
jne 0xbf2ef
movb $0x0, (%rcx,%rax)
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0xbf30d
jmp 0xbf2fa
movb $0x0, (%rcx)
movq $0x0, 0x10(%rbx)
cmpb $0x2f, (%r14)
jne 0xbf30d
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x10a448
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbf467
movq %rdi, %r14
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
leaq 0x8414a(%rip), %r15     # 0x1434d9
movq %r14, %r13
movzbl (%r13), %eax
cmpl $0x2e, %eax
je 0xbf3c4
cmpl $0x2f, %eax
je 0xbf3aa
testl %eax, %eax
jne 0xbf3e0
jmp 0xbf447
cmpb $0x2f, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0xbf3aa
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x10a448
jmp 0xbf392
movzbl 0x1(%r13), %ecx
cmpl $0x2e, %ecx
je 0xbf3d9
cmpl $0x2f, %ecx
jne 0xbf3e0
addq $0x2, %r13
jmp 0xbf392
cmpb $0x2f, 0x2(%r13)
je 0xbf3f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x10a448
incq %r13
jmp 0xbf392
movq 0x10(%rbx), %rax
cmpq $0x2, %rax
jb 0xbf433
movq 0x8(%rbx), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
jne 0xbf433
movq %rbx, %rdi
callq 0x10a519
movq 0x8(%rbx), %rdi
callq 0xbf2b1
movq %rax, %r12
movq %rbx, %rdi
callq 0x10a028
movq %r12, %rdi
movl $0x2f, %esi
callq 0x10a448
movq %r12, %rbx
jmp 0xbf43e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10a6fa
addq $0x3, %r13
jmp 0xbf392
movq 0x8(%rbx), %rax
cmpb $0x2f, (%rax)
jne 0xbf469
cmpb $0x2f, (%r14)
je 0xbf469
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10ac40
jmp 0xbf469
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x109f0e
movq %rax, %r14
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2e, %ecx
callq 0x10a99d
movq %rax, %r15
movq 0x8(%r14), %rax
xorl %r12d, %r12d
cmpb $0x2e, (%rax,%r15)
sete %r12b
movq %r14, %rdi
callq 0x10a028
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_O3/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 0x109f0e
movq %rax, %r14
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2f, %ecx
callq 0x10a99d
movq %rax, %r15
movq %r14, %rdi
callq 0x10a028
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_O3/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 0x109f0e
movq %rax, %rbx
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
movl $0x2e, %ecx
callq 0x10a99d
movq 0x8(%rbx), %rcx
cmpb $0x2e, (%rcx,%rax)
jne 0xbf549
movb $0x0, (%rcx,%rax)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbf2b1
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xbf4cf
movq %rax, %rdi
callq 0x109f0e
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a028
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
callq 0xd460
movb $0x1, %bl
testl %eax, %eax
je 0xbf60b
leaq 0x83eeb(%rip), %rsi     # 0x1434dd
movq %r14, %rdi
callq 0xd170
testq %rax, %rax
je 0xbf609
movq %rax, %rdi
callq 0xd390
jmp 0xbf60b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
leaq 0xdc77c(%rip), %rax     # 0x19bdd0
movq (%rax), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xd6675
movq %r15, %rdi
callq 0x109f0e
movq %r12, %rdi
movq %rax, %rsi
callq 0xd6a3c
movq %rax, %r15
xorl %eax, %eax
callq 0x109c82
movq %r12, %rdi
movq %rax, %rsi
callq 0xd6a3c
movq %rax, %r12
movq 0x8(%r15), %rdx
leaq 0x6d9de(%rip), %rsi     # 0x12d078
movq %rax, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x1097fd
movq 0x8(%r12), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd460
testl %eax, %eax
je 0xbf724
leaq 0x6d9b7(%rip), %r13     # 0x12d078
leaq 0x38(%rsp), %rbp
movq 0x10(%r15), %rax
cmpq $0x1, %rax
je 0xbf6db
testq %rax, %rax
je 0xbf73a
movq 0x8(%r15), %rdi
jmp 0xbf6e4
movq 0x8(%r15), %rdi
cmpb $0x2f, (%rdi)
je 0xbf73a
callq 0xbf2b1
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x1094fa
movq %rbx, %rdi
callq 0x10a028
movq 0x8(%r15), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x1097fd
movq 0x8(%r12), %rdi
movq %rbp, %rsi
callq 0xd460
testl %eax, %eax
jne 0xbf6c6
movb $0x1, %bpl
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xbf73c
movq %r12, %rsi
callq 0x1094fa
jmp 0xbf73c
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0xd6d2c
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbf9c1
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %esi
callq 0xbe802
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf8d3
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
je 0xbf9c1
leaq -0x114(%rip), %rdi      # 0xbf8a8
jmp 0xbe7ee
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbe7b1
movq %rax, %r15
movl $0x28, %esi
movq %rax, %rdi
callq 0xbe802
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_O3/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 0xbe7b1
movq %rax, %r13
movl $0x28, %esi
movq %rax, %rdi
callq 0xbe802
movl $0xe, 0x10(%r13)
movq %r12, %rdi
callq 0xd7476
movq %rax, (%r13)
movq %r15, %rdi
callq 0xd7476
movq %rax, 0x8(%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc6f6e
movq %rax, 0x18(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbfdb4
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xbfdb4
movl 0x10(%rdi), %ecx
movl 0x10(%rsi), %edx
cmpl %edx, %ecx
jne 0xbfdc0
movl 0x14(%rdi), %ecx
movl 0x14(%rsi), %edx
cmpl %edx, %ecx
jne 0xbfdc0
movq 0x18(%rdi), %rcx
movq 0x18(%rsi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0xbfdbf
xorl %eax, %eax
cmpq %rdx, %rcx
adcl $-0x1, %eax
orl $0x1, %eax
retq
xorl %eax, %eax
cmpl %edx, %ecx
jmp 0xbfdb9
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xc2b01
xorl %r15d, %r15d
leaq -0x3239(%rip), %r14     # 0xbf8a8
movq (%rbx), %rcx
movq (%rcx,%r15,8), %rsi
testq %rsi, %rsi
je 0xc2af9
movq %r14, %rdi
callq 0xbe7ee
movq 0x8(%rbx), %rax
incq %r15
cmpq %rax, %r15
jb 0xc2ae1
movq (%rbx), %rdi
callq 0xbe7e9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xc2b5e
xorl %r12d, %r12d
leaq -0x3296(%rip), %r15     # 0xbf8a8
movq (%rbx), %rcx
movq (%rcx,%r12,8), %rsi
testq %rsi, %rsi
je 0xc2b56
movq %r15, %rdi
callq 0xbe7ee
movq 0x8(%rbx), %rax
incq %r12
cmpq %rax, %r12
jb 0xc2b3e
movq (%rbx), %rdi
callq 0xbe7e9
leaq 0x10(%rbx), %r8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
xorl %r15d, %r15d
movl $0x8, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbe7da
movq %rax, (%rbx)
cmpq $0x0, 0x8(%r14)
je 0xc2bb9
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0xbf93d
movq (%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x8(%r14), %r15
cmpq %r15, %r12
jb 0xc2b9a
movq %r15, 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_O3/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 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
jne 0xc2d12
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 0xbe7d5
movq %rax, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0xc2d06
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movq (%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq 0x8(%rbx), %rax
jb 0xc2cf2
movq %r15, %rdi
callq 0xbe7e9
movq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq %r14, (%rcx,%rax,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