LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x109c82
movq %rax, %rbx
leaq 0x80c60(%rip), %rsi     # 0x1439c7
movq %rax, %rdi
xorl %eax, %eax
callq 0x10a7d0
leaq 0x808ff(%rip), %rsi     # 0x143677
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
cmpq $0x0, 0x8(%r14)
je 0xc2dda
leaq 0x80c49(%rip), %r15     # 0x1439d9
leaq 0x80c52(%rip), %r12     # 0x1439e9
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x10a7d0
movq (%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0xbf9e4
movq %rax, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x10b279
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a641
incq %r13
cmpq 0x8(%r14), %r13
jb 0xc2d9a
leaq 0x80920(%rip), %rsi     # 0x143701
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
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_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 %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq 0x8(%rsi), %rcx
cmpq %rcx, %rbx
jne 0xc2e69
testq %rbx, %rbx
je 0xc2e65
movq (%rdi), %r14
movq (%rsi), %r15
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
movq (%r15,%r12,8), %rsi
callq 0xbfd79
testl %eax, %eax
jne 0xc2e74
incq %r12
cmpq %r12, %rbx
jne 0xc2e4c
xorl %eax, %eax
jmp 0xc2e74
xorl %eax, %eax
cmpq %rcx, %rbx
adcl $-0x1, %eax
orl $0x1, %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_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 0xd6ec4
movq %rax, %r13
xorl %eax, %eax
callq 0x109c82
movq %rax, %r12
testq %r13, %r13
jne 0xc2f63
leaq 0x80b1c(%rip), %rdi     # 0x143a65
leaq 0x806de(%rip), %rsi     # 0x14362e
leaq 0x80abc(%rip), %rcx     # 0x143a13
movl $0x584, %edx            # imm = 0x584
xorl %eax, %eax
callq 0xbe6f9
leaq 0x6aea5(%rip), %rsi     # 0x12de0f
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xfe6d6
movq 0x30(%r15), %rax
testq %rax, %rax
je 0xc2fce
cmpq $0x0, 0x8(%rax)
je 0xc2fce
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %rbp
movq %r12, %rdi
callq 0x10a41a
movq %rbp, %rdi
movq %r12, %rsi
callq 0xc28d6
testb %al, %al
je 0xc2fc1
movq 0x8(%r12), %rcx
movq %r14, %rdi
leaq 0x80acf(%rip), %rsi     # 0x143a86
movq %rbx, %rdx
xorl %eax, %eax
callq 0xfe6d6
incq %r13
movq 0x30(%r15), %rax
cmpq 0x8(%rax), %r13
jb 0xc2f8a
movq %r12, %rdi
callq 0x10a028
leaq 0x6a6c5(%rip), %rsi     # 0x12d6a2
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 0xfe6d6
// File: /workspace/github_c_makefile_star2_O3/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 0xd6ec4
testq %rax, %rax
jne 0xc3117
leaq 0x809ed(%rip), %rdi     # 0x143aea
leaq 0x8052a(%rip), %rsi     # 0x14362e
leaq 0x80908(%rip), %rcx     # 0x143a13
movl $0x5b3, %edx            # imm = 0x5B3
xorl %eax, %eax
callq 0xbe6f9
leaq 0x8055a(%rip), %rsi     # 0x143678
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfe6d6
movq 0x30(%r14), %rax
testq %rax, %rax
je 0xc3157
cmpq $0x0, 0x8(%rax)
je 0xc3157
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0xc28d6
incq %r15
movq 0x30(%r14), %rax
cmpq 0x8(%rax), %r15
jb 0xc313b
leaq 0x805a4(%rip), %rsi     # 0x143702
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xfe6d6
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_struct_to_sink
void bcore_self_s_struct_to_sink( const bcore_self_s* o, sz_t indent, 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, "#rn{ }typedef struct #<sc_t>\n", indent, name );
    bcore_self_s_struct_body_to_sink( o, indent, sink );
    bcore_sink_a_push_fa( sink, " #<sc_t>;\n", name );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
callq 0xd6ec4
movq %rax, %r14
testq %rax, %rax
jne 0xc31b0
leaq 0x80981(%rip), %rdi     # 0x143b17
leaq 0x80491(%rip), %rsi     # 0x14362e
leaq 0x8086f(%rip), %rcx     # 0x143a13
movl $0x5c5, %edx            # imm = 0x5C5
xorl %eax, %eax
callq 0xbe6f9
leaq 0x8097c(%rip), %rsi     # 0x143b33
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xfe6d6
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc2f13
leaq 0x6ba8c(%rip), %rsi     # 0x12ec68
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfe6d6
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_get_item_by_name
const bcore_self_item_s* bcore_self_s_get_item_by_name( const bcore_self_s* o, tp_t name )
{
    if( !o->body ) return NULL;
    ASSERT( o->body );
    for( uz_t i = 0; i < o->body->size; i++ )
    {
        const bcore_self_item_s* item = o->body->data[ i ];
        if( item->name == name ) return item;
    }
    return NULL;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xc33b1
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xc33b1
movq (%rax), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %rax
cmpq %rsi, 0x8(%rax)
je 0xc33b3
incq %rdi
cmpq %rdi, %rcx
jne 0xc339f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_get_first_array_item
const bcore_self_item_s* bcore_self_s_get_first_array_item( const bcore_self_s* o )
{
    if( !o->body ) return NULL;
    ASSERT( o->body );
    for( uz_t i = 0; i < o->body->size; i++ )
    {
        const bcore_self_item_s* item = o->body->data[ i ];
        if( bcore_flect_caps_is_array( item->caps ) ) return item;
    }
    return NULL;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xc33e2
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xc33e2
movq (%rax), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rax
movl 0x10(%rax), %edi
addl $-0x6, %edi
cmpl $0x7, %edi
jbe 0xc33e4
incq %rsi
cmpq %rsi, %rcx
jne 0xc33cb
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_get_first_anonymous_array_item
const bcore_self_item_s* bcore_self_s_get_first_anonymous_array_item( const bcore_self_s* o )
{
    if( !o->body ) return NULL;
    ASSERT( o->body );
    for( uz_t i = 0; i < o->body->size; i++ )
    {
        const bcore_self_item_s* item = o->body->data[ i ];
        if( item->name == TYPEOF_ && bcore_flect_caps_is_array( item->caps ) ) return item;
    }
    return NULL;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xc3426
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xc3426
movq (%rax), %rdx
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
xorl %edi, %edi
movq (%rdx,%rdi,8), %rax
cmpq %rsi, 0x8(%rax)
jne 0xc341e
movl 0x10(%rax), %r8d
addl $-0x6, %r8d
cmpl $0x8, %r8d
jb 0xc3428
incq %rdi
cmpq %rdi, %rcx
jne 0xc3406
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_push_ns_func
bcore_self_item_s* bcore_self_s_push_ns_func( bcore_self_s* o, fp_t func, sc_t type, sc_t name )
{
    st_s* fname = st_s_create_fa( "#<sc_t>_#<sc_t>", nameof( o->type ), name );
    bcore_self_item_s* ret = bcore_self_s_push_d( o, bcore_self_item_s_create_func( fname->sc, func, type, name ) );
    st_s_discard( fname );
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
callq 0xd6ec4
leaq 0x6a8ac(%rip), %rdi     # 0x12dd7c
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x109dca
movq %rax, %r13
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xbfb4d
movq %r12, %rdi
movq %rax, %rsi
callq 0xc3429
movq %rax, %rbx
movq %r13, %rdi
callq 0x10a028
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_flect.c
// Function: bcore_self_s_init_plain
void bcore_self_s_init_plain( bcore_self_s* o, tp_t type, tp_t trait, uz_t size, uz_t align )
{
    bcore_self_s_init( o );
    o->type  = type;
    o->trait = trait;
    o->size  = size;
    o->align = align;
    if( o->body ) bcore_self_body_s_discard( o->body );
    o->body = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x38, %esi
callq 0xbe802
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%rbx)
movq %r13, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0xc3596
leaq -0xacb(%rip), %rdi      # 0xc2ac6
callq 0xbe7ee
movq $0x0, 0x30(%rbx)
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_s_show
st_s* bcore_self_s_show( const bcore_self_s* o )
{
    st_s* s = st_s_create();
    st_s_pushf( s, "bcore_self_s" );
    st_s_pushf( s, "\n{" );
    st_s_pushf( s, "\n    type:  %x '%s'", o->type, ifnameof( o->type ) );
    st_s_pushf( s, "\n    size:  %zu", o->size );
    st_s_pushf( s, "\n    body: " );
    if( o->body ) st_s_push_st_d( s, st_s_replace_char_sc( bcore_self_body_s_show( o->body ), '\n', "\n    " ) );
    st_s_pushf( s, "\n}" );
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
leaq 0x805e3(%rip), %rsi     # 0x143ba4
movq %rax, %rdi
xorl %eax, %eax
callq 0x10a7d0
leaq 0x800a5(%rip), %rsi     # 0x143677
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x85123(%rip), %rcx     # 0x148715
cmovneq %rax, %rcx
leaq 0x805b4(%rip), %rsi     # 0x143bb1
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10a7d0
movq 0x20(%r14), %rdx
leaq 0x805b0(%rip), %rsi     # 0x143bc5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
leaq 0x805af(%rip), %rsi     # 0x143bd5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0xc365d
callq 0xc2d4a
leaq 0x803a4(%rip), %rdx     # 0x1439e9
movq %rax, %rdi
movl $0xa, %esi
callq 0x10b279
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a641
leaq 0x8009d(%rip), %rsi     # 0x143701
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
movq %rbx, %rax
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_s_create_array_dyn_solid_static
bcore_self_s* bcore_self_s_create_array_dyn_solid_static( tp_t item_type )
{
    bcore_self_s* o = bcore_self_s_create();
    bcore_self_item_s* item = bcore_self_item_s_create();
    item->caps = BCORE_CAPS_ARRAY_DYN_SOLID_STATIC;
    item->type = item_type;
    bcore_self_s_push( o, item );
    bcore_self_item_s_discard( item );
    o->type = bcore_self_body_s_fold_tp( o->body, bcore_tp_init() );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movabsq $-0x340d631b7bdddcdb, %rbx # imm = 0xCBF29CE484222325
movl $0x38, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r12
movl $0x28, %esi
movq %rax, %rdi
callq 0xbe802
movl $0x6, 0x10(%r12)
movq %r15, (%r12)
movq %r12, %rdi
callq 0xbf93d
movq %r14, %rdi
movq %rax, %rsi
callq 0xc3429
leaq -0x3eb1(%rip), %rdi     # 0xbf8a8
movq %r12, %rsi
callq 0xbe7ee
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xc378b
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xbfbd9
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xc3774
movq %rbx, 0x8(%r14)
movq %r14, %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_s_create_array_dyn_link_static
bcore_self_s* bcore_self_s_create_array_dyn_link_static( tp_t item_type )
{
    bcore_self_s* o = bcore_self_s_create();
    bcore_self_item_s* item = bcore_self_item_s_create();
    item->caps = BCORE_CAPS_ARRAY_DYN_LINK_STATIC;
    item->type = item_type;
    bcore_self_s_push( o, item );
    bcore_self_item_s_discard( item );
    o->type = bcore_self_body_s_fold_tp( o->body, bcore_tp_init() );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movabsq $-0x340d631b7bdddcdb, %rbx # imm = 0xCBF29CE484222325
movl $0x38, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r12
movl $0x28, %esi
movq %rax, %rdi
callq 0xbe802
movl $0x8, 0x10(%r12)
movq %r15, (%r12)
movq %r12, %rdi
callq 0xbf93d
movq %r14, %rdi
movq %rax, %rsi
callq 0xc3429
leaq -0x3f76(%rip), %rdi     # 0xbf8a8
movq %r12, %rsi
callq 0xbe7ee
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xc3850
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xbfbd9
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xc3839
movq %rbx, 0x8(%r14)
movq %r14, %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_s_create_array_fix_solid_static
bcore_self_s* bcore_self_s_create_array_fix_solid_static( tp_t item_type, uz_t size )
{
    bcore_self_s* o = bcore_self_s_create();
    bcore_self_item_s* item = bcore_self_item_s_create();
    item->caps = BCORE_CAPS_ARRAY_FIX_SOLID_STATIC;
    item->type = item_type;
    item->array_fix_size = size;
    bcore_self_s_push( o, item );
    bcore_self_item_s_discard( item );
    o->type = bcore_self_body_s_fold_tp( o->body, bcore_tp_init() );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
movabsq $-0x340d631b7bdddcdb, %rbx # imm = 0xCBF29CE484222325
movl $0x38, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r13
movl $0x28, %esi
movq %rax, %rdi
callq 0xbe802
movl $0xb, 0x10(%r13)
movq %r12, (%r13)
movq %r15, 0x18(%r13)
movq %r13, %rdi
callq 0xbf93d
movq %r14, %rdi
movq %rax, %rsi
callq 0xc3429
leaq -0x4041(%rip), %rdi     # 0xbf8a8
movq %r13, %rsi
callq 0xbe7ee
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xc391b
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xbfbd9
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xc3904
movq %rbx, 0x8(%r14)
movq %r14, %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_s_create_array_fix_link_static
bcore_self_s* bcore_self_s_create_array_fix_link_static( tp_t item_type, uz_t size )
{
    bcore_self_s* o = bcore_self_s_create();
    bcore_self_item_s* item = bcore_self_item_s_create();
    item->caps = BCORE_CAPS_ARRAY_FIX_LINK_STATIC;
    item->type = item_type;
    item->array_fix_size = size;
    bcore_self_s_push( o, item );
    bcore_self_item_s_discard( item );
    o->type = bcore_self_body_s_fold_tp( o->body, bcore_tp_init() );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
movabsq $-0x340d631b7bdddcdb, %rbx # imm = 0xCBF29CE484222325
movl $0x38, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r13
movl $0x28, %esi
movq %rax, %rdi
callq 0xbe802
movl $0xc, 0x10(%r13)
movq %r12, (%r13)
movq %r15, 0x18(%r13)
movq %r13, %rdi
callq 0xbf93d
movq %r14, %rdi
movq %rax, %rsi
callq 0xc3429
leaq -0x410c(%rip), %rdi     # 0xbf8a8
movq %r13, %rsi
callq 0xbe7ee
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xc39e6
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xbfbd9
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xc39cf
movq %rbx, 0x8(%r14)
movq %r14, %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_s_create_array_fix_link_aware
bcore_self_s* bcore_self_s_create_array_fix_link_aware( uz_t size )
{
    bcore_self_s* o = bcore_self_s_create();
    bcore_self_item_s* item = bcore_self_item_s_create();
    item->caps = BCORE_CAPS_ARRAY_FIX_LINK_AWARE;
    item->type = 0;
    item->array_fix_size = size;
    bcore_self_s_push( o, item );
    bcore_self_item_s_discard( item );
    o->type = bcore_self_body_s_fold_tp( o->body, bcore_tp_init() );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movabsq $-0x340d631b7bdddcdb, %rbx # imm = 0xCBF29CE484222325
movl $0x38, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r12
movl $0x28, %esi
movq %rax, %rdi
callq 0xbe802
movl $0xd, 0x10(%r12)
movq $0x0, (%r12)
movq %r15, 0x18(%r12)
movq %r12, %rdi
callq 0xbf93d
movq %r14, %rdi
movq %rax, %rsi
callq 0xc3429
leaq -0x41da(%rip), %rdi     # 0xbf8a8
movq %r12, %rsi
callq 0xbe7ee
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xc3ab4
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xbfbd9
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xc3a9d
movq %rbx, 0x8(%r14)
movq %r14, %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_s_build_parse_nasc
bcore_self_s* bcore_self_s_build_parse_nasc( const sc_t* nasc, uz_t size_of, uz_t align_of )
{
    st_s* st = st_s_create_nasc( nasc );
    bcore_self_s* ret = bcore_self_s_build_parse_sc( st->sc, size_of, align_of );
    st_s_discard( st );
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x109f46
movq %rax, %r15
movq 0x8(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc447e
movq %rax, %rbx
movq %r15, %rdi
callq 0x10a028
movq %rbx, %rax
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_s_fold_tp
tp_t bcore_self_s_fold_tp( const bcore_self_s* o, tp_t tp )
{
    tp = bcore_tp_fold_tp( tp, o->type );
    tp = bcore_tp_fold_tp( tp, o->trait );
    tp = bcore_tp_fold_tp( tp, o->parent );
    if( o->body ) tp = bcore_self_body_s_fold_tp( o->body, tp );
    return tp;
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r8
movl $0xff, %edx
movq %rax, %r9
andq %rdx, %r9
xorq %rsi, %r9
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
imulq %rcx, %r9
movl %eax, %r10d
shrl $0x8, %r10d
movl $0xff, %esi
andl %esi, %r10d
xorq %r9, %r10
imulq %rcx, %r10
movl %eax, %r9d
shrl $0x10, %r9d
andl %esi, %r9d
xorq %r10, %r9
imulq %rcx, %r9
movl %eax, %r10d
shrl $0x18, %r10d
xorq %r9, %r10
imulq %rcx, %r10
movq %rax, %r9
shrq $0x20, %r9
andq %rdx, %r9
xorq %r10, %r9
imulq %rcx, %r9
movq %rax, %r10
shrq $0x28, %r10
andq %rdx, %r10
xorq %r9, %r10
imulq %rcx, %r10
movq %rax, %r9
shrq $0x30, %r9
andq %rdx, %r9
xorq %r10, %r9
imulq %rcx, %r9
shrq $0x38, %rax
xorq %r9, %rax
imulq %rcx, %rax
movq %r8, %r9
andq %rdx, %r9
xorq %rax, %r9
imulq %rcx, %r9
movl %r8d, %eax
shrl $0x8, %eax
andl %esi, %eax
xorq %r9, %rax
imulq %rcx, %rax
movl %r8d, %r9d
shrl $0x10, %r9d
andl %esi, %r9d
xorq %rax, %r9
imulq %rcx, %r9
movl %r8d, %eax
shrl $0x18, %eax
xorq %r9, %rax
imulq %rcx, %rax
movq %r8, %r9
shrq $0x20, %r9
andq %rdx, %r9
xorq %rax, %r9
imulq %rcx, %r9
movq %r8, %rax
shrq $0x28, %rax
andq %rdx, %rax
xorq %r9, %rax
imulq %rcx, %rax
movq %r8, %r9
shrq $0x30, %r9
andq %rdx, %r9
xorq %rax, %r9
imulq %rcx, %r9
shrq $0x38, %r8
xorq %r9, %r8
imulq %rcx, %r8
movq 0x18(%rdi), %rax
movq %rax, %r9
andq %rdx, %r9
xorq %r8, %r9
imulq %rcx, %r9
movl %eax, %r8d
shrl $0x8, %r8d
andl %esi, %r8d
xorq %r9, %r8
imulq %rcx, %r8
movl %eax, %r9d
shrl $0x10, %r9d
andl %esi, %r9d
xorq %r8, %r9
imulq %rcx, %r9
movl %eax, %esi
shrl $0x18, %esi
xorq %r9, %rsi
imulq %rcx, %rsi
movq %rax, %r8
shrq $0x20, %r8
andq %rdx, %r8
xorq %rsi, %r8
imulq %rcx, %r8
movq %rax, %rsi
shrq $0x28, %rsi
andq %rdx, %rsi
xorq %r8, %rsi
imulq %rcx, %rsi
movq %rax, %r8
shrq $0x30, %r8
andq %rdx, %r8
xorq %rsi, %r8
imulq %rcx, %r8
shrq $0x38, %rax
xorq %r8, %rax
imulq %rcx, %rax
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0xc46dc
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rcx), %rbx
testq %rbx, %rbx
je 0xc46d7
movq (%rcx), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
movq %rax, %rsi
callq 0xbfbd9
incq %r15
cmpq %r15, %rbx
jne 0xc46c3
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_s_cmp
s2_t bcore_self_s_cmp( const bcore_self_s* o1, const bcore_self_s* o2 )
{
    if( o1->type   != o2->type   ) return ( o1->type   < o2->type   ) ? 1 : -1;
    if( o1->trait  != o2->trait  ) return ( o1->trait  < o2->trait  ) ? 1 : -1;
    if( o1->parent != o2->parent ) return ( o1->parent < o2->parent ) ? 1 : -1;
    if( o1->body   != o2->body   )
    {
        if( !o1->body ) return  1;
        if( !o2->body ) return -1;
        return bcore_self_body_s_cmp( o1->body, o2->body );
    }
    return 0;
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xc4725
movq 0x10(%rdi), %rcx
movq 0x10(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xc4725
movq 0x18(%rdi), %rcx
movq 0x18(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xc4725
movq 0x30(%rdi), %rdi
movq 0x30(%rsi), %rsi
cmpq %rsi, %rdi
je 0xc4731
testq %rdi, %rdi
je 0xc4734
testq %rsi, %rsi
jne 0xc2e29
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %eax, %eax
cmpq %rdx, %rcx
adcl $-0x1, %eax
orl $0x1, %eax
retq
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_try_external_fp
fp_t bcore_self_s_try_external_fp( const bcore_self_s* o, tp_t type, tp_t name )
{
    if( !o->body ) return NULL;
    const bcore_self_body_s* body = o->body;
    for( uz_t i = 0; i < body->size; i++ )
    {
        const bcore_self_item_s* item = body->data[ i ];
        if( ( item->caps == BCORE_CAPS_EXTERNAL_FUNC ) &&
            ( type == 0 || item->type == type        ) &&
            ( name == 0 || item->name == name        ) )
        {
            if( item->default_tp )
            {
                fp_t fp = bcore_function_get( item->default_tp );
                if( !fp ) ERR( "Function '%s' (%"PRItp_t") not registered in function manager.", ifnameof(item->default_tp ), item->default_tp );
                return fp;
            }
            else
            {
                ERR( "Object '%s': Function '%s' declared but not assigned.", ifnameof( o->type ), ifnameof( name ) );
            }
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movq 0x30(%rdi), %rbx
testq %rbx, %rbx
je 0xc47fc
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xc47fc
movq %rdx, %r15
movq %rsi, %r12
leaq 0x83fa5(%rip), %r14     # 0x148715
xorl %r13d, %r13d
movq (%rbx), %rcx
movq (%rcx,%r13,8), %rbp
cmpl $0xe, 0x10(%rbp)
jne 0xc47f0
testq %r12, %r12
je 0xc478b
cmpq %r12, (%rbp)
jne 0xc47f0
testq %r15, %r15
je 0xc4796
cmpq %r15, 0x8(%rbp)
jne 0xc47f0
movq 0x18(%rbp), %rdi
testq %rdi, %rdi
jne 0xc4810
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xd6ec4
movq %rax, %rbp
testq %rax, %rax
cmoveq %r14, %rbp
movq %r15, %rdi
callq 0xd6ec4
testq %rax, %rax
cmoveq %r14, %rax
leaq 0x7f45e(%rip), %rdi     # 0x143c2a
leaq 0x7ee5b(%rip), %rsi     # 0x14362e
movl $0x785, %edx            # imm = 0x785
leaq 0x7f4a0(%rip), %rcx     # 0x143c7f
movq %rbp, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xbe592
movq 0x8(%rbx), %rax
incq %r13
cmpq %rax, %r13
jb 0xc4773
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xc6e3c
movq %rax, %rbx
testq %rax, %rax
jne 0xc47fe
movq 0x18(%rbp), %rdi
callq 0xd6ec4
testq %rax, %rax
cmovneq %rax, %r14
movq 0x18(%rbp), %r9
leaq 0x7f3f2(%rip), %rdi     # 0x143c2a
leaq 0x7edef(%rip), %rsi     # 0x14362e
leaq 0x7f401(%rip), %rcx     # 0x143c47
xorl %ebx, %ebx
movl $0x780, %edx            # imm = 0x780
movq %r14, %r8
xorl %eax, %eax
callq 0xbe592
jmp 0xc47fe
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_try_const
vc_t bcore_self_s_try_const( const bcore_self_s* o, tp_t type, tp_t name ) // returns NULL when not found
{
    if( !o->body ) return NULL;
    const bcore_self_body_s* body = o->body;
    for( uz_t i = 0; i < body->size; i++ )
    {
        const bcore_self_item_s* item = body->data[ i ];
        if( ( item->caps == BCORE_CAPS_SOLID_STATIC ) &&
            ( type == 0 || item->type == type       ) &&
            ( name == 0 || item->name == name       ) )
        {
            return &item->default_u3; // u3 maximally aligned and representative for all default types
        }
    }
    return NULL;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xc4a1e
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xc4a1e
movq (%rax), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %rax
cmpl $0x1, 0x10(%rax)
jne 0xc4a16
testq %rsi, %rsi
je 0xc4a0b
cmpq %rsi, (%rax)
jne 0xc4a16
testq %rdx, %rdx
je 0xc4a21
cmpq %rdx, 0x8(%rax)
je 0xc4a21
incq %r8
cmpq %r8, %rcx
jne 0xc49f7
xorl %eax, %eax
retq
addq $0x18, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_check_integrity
void bcore_self_s_check_integrity( const bcore_self_s* o )
{
    if( !bcore_trait_supported( o->trait, o, NULL ) )
    {
        st_s* log = st_s_create();
        bcore_trait_supported( o->trait, o, log );
        ERR( "Reflection '%s' is of trait '%s' but does not support it.\nReason: %s\n", ifnameof( o->type ), ifnameof( o->trait ), log->sc );
        st_s_discard( log );
    }
    if( o->body ) bcore_self_body_s_check_integrity( o->body );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x116c98
testb %al, %al
jne 0xc4b57
xorl %eax, %eax
callq 0x109c82
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x116c98
movq 0x8(%rbx), %rdi
callq 0xd6ec4
movq %rax, %r15
testq %rax, %rax
leaq 0x83c09(%rip), %r12     # 0x148715
cmoveq %r12, %r15
movq 0x10(%rbx), %rdi
callq 0xd6ec4
testq %rax, %rax
cmovneq %rax, %r12
movq 0x8(%r14), %rax
movq %rax, (%rsp)
leaq 0x7f276(%rip), %rdi     # 0x143da5
leaq 0x7eaf8(%rip), %rsi     # 0x14362e
leaq 0x7f285(%rip), %rcx     # 0x143dc2
movl $0x7d4, %edx            # imm = 0x7D4
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0xbe592
movq %r14, %rdi
callq 0x10a028
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
je 0xc4b7f
cmpq $0x0, 0x8(%rbx)
je 0xc4b7f
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xbfe37
incq %r14
cmpq 0x8(%rbx), %r14
jb 0xc4b6a
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_discard_flect_maps
void bcore_discard_flect_maps()
{
    if( self_map_s_g )
    {
        self_map_s_discard( self_map_s_g );
        self_map_s_g = NULL;
    }
    if( creator_map_s_g )
    {
        creator_map_s_discard( creator_map_s_g );
        creator_map_s_g = NULL;
    }
}

// Assembly:
pushq %rax
movq 0xd71ac(%rip), %rsi     # 0x19bda8
testq %rsi, %rsi
je 0xc4c18
leaq 0x141b(%rip), %rdi      # 0xc6023
callq 0xbe7ee
movq $0x0, 0xd7190(%rip) # 0x19bda8
movq 0xd7191(%rip), %rsi     # 0x19bdb0
testq %rsi, %rsi
je 0xc4c3b
leaq 0x148d(%rip), %rdi      # 0xc60b8
callq 0xbe7ee
movq $0x0, 0xd7175(%rip) # 0x19bdb0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_exists
bl_t bcore_flect_exists( tp_t type )
{
    assert( self_map_s_g != NULL );
    bl_t exists = false;

    bcore_mutex_s_lock( &self_map_s_g->mutex );
    exists = bcore_hmap_u3vd_s_exists( self_map_s_g->hmap, type );
    bcore_mutex_s_unlock( &self_map_s_g->mutex );
    if( exists ) return true;

    assert( creator_map_s_g != NULL );
    bcore_mutex_s_lock( &creator_map_s_g->mutex );
    exists = bcore_hmap_u3vd_s_exists( creator_map_s_g->hmap, type );
    bcore_mutex_s_unlock( &creator_map_s_g->mutex );
    return exists;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd715e(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142c9
movq 0xd714e(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xc8069
movl %eax, %ebp
movq 0xd713a(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142fb
testb %bpl, %bpl
je 0xc4c80
movb $0x1, %al
jmp 0xc4cb6
movq 0xd7129(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
callq 0x1142c9
movq 0xd7119(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xc8069
movl %eax, %ebx
movq 0xd7105(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
callq 0x1142fb
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_size
sz_t bcore_flect_size()
{
    sz_t count = 0;
    bcore_mutex_s_lock( &creator_map_s_g->mutex );
    {
        sz_t size = bcore_hmap_u3vd_s_size( creator_map_s_g->hmap );
        for( sz_t i = 0; i < size; i++ )
        {
            tp_t type = bcore_hmap_u3vd_s_idx_key( creator_map_s_g->hmap, i );
            if( type ) count++;
        }
    }

    bcore_mutex_s_lock( &self_map_s_g->mutex );
    {
        sz_t size = bcore_hmap_u3vd_s_size( self_map_s_g->hmap );
        for( sz_t i = 0; i < size; i++ )
        {
            tp_t type = bcore_hmap_u3vd_s_idx_key( self_map_s_g->hmap, i );
            if( type && !bcore_hmap_u3vd_s_exists( creator_map_s_g->hmap, type ) )
            {
                 count++;
            }
        }
    }

    bcore_mutex_s_unlock( &creator_map_s_g->mutex );
    bcore_mutex_s_unlock( &self_map_s_g->mutex );

    return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xd70e7(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
callq 0x1142c9
movq 0xd70d7(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
callq 0xc81d8
testq %rax, %rax
jle 0xc4d12
movq %rax, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0xd70bb(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
movq %r15, %rsi
callq 0xc81dd
cmpq $0x1, %rax
sbbq $-0x1, %rbx
incq %r15
cmpq %r15, %r14
jne 0xc4cee
jmp 0xc4d14
xorl %ebx, %ebx
movq 0xd708d(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142c9
movq 0xd707d(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
callq 0xc81d8
testq %rax, %rax
jle 0xc4d77
movq %rax, %r14
xorl %r15d, %r15d
movq 0xd7063(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
movq %r15, %rsi
callq 0xc81dd
testq %rax, %rax
je 0xc4d6f
movq 0xd7054(%rip), %rcx     # 0x19bdb0
movq (%rcx), %rdi
movq %rax, %rsi
callq 0xc8069
xorb $0x1, %al
movzbl %al, %eax
addq %rax, %rbx
incq %r15
cmpq %r15, %r14
jne 0xc4d3e
movq 0xd7032(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
callq 0x1142fb
movq 0xd701a(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142fb
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_push_all_types
void bcore_flect_push_all_types( bcore_arr_tp_s* arr )
{
    bcore_mutex_s_lock( &creator_map_s_g->mutex );
    {
        sz_t size = bcore_hmap_u3vd_s_size( creator_map_s_g->hmap );
        for( sz_t i = 0; i < size; i++ )
        {
            tp_t type = bcore_hmap_u3vd_s_idx_key( creator_map_s_g->hmap, i );
            if( type ) bcore_arr_tp_s_push( arr, type );
        }
    }

    bcore_mutex_s_lock( &self_map_s_g->mutex );
    {
        sz_t size = bcore_hmap_u3vd_s_size( self_map_s_g->hmap );
        for( sz_t i = 0; i < size; i++ )
        {
            tp_t type = bcore_hmap_u3vd_s_idx_key( self_map_s_g->hmap, i );
            if( type && !bcore_hmap_u3vd_s_exists( creator_map_s_g->hmap, type ) )
            {
                bcore_arr_tp_s_push( arr, type );
            }
        }
    }

    bcore_mutex_s_unlock( &creator_map_s_g->mutex );
    bcore_mutex_s_unlock( &self_map_s_g->mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd6ffe(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
callq 0x1142c9
movq 0xd6fee(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
callq 0xc81d8
testq %rax, %rax
jle 0xc4dff
movq %rax, %r14
xorl %r15d, %r15d
movq 0xd6fd4(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
movq %r15, %rsi
callq 0xc81dd
testq %rax, %rax
je 0xc4df7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb90d3
incq %r15
cmpq %r15, %r14
jne 0xc4dd5
movq 0xd6fa2(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142c9
movq 0xd6f92(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
callq 0xc81d8
testq %rax, %rax
jle 0xc4e6c
movq %rax, %r14
xorl %r15d, %r15d
movq 0xd6f78(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
movq %r15, %rsi
callq 0xc81dd
testq %rax, %rax
je 0xc4e64
movq %rax, %r12
movq 0xd6f66(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
movq %r12, %rsi
callq 0xc8069
testb %al, %al
jne 0xc4e64
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb90d3
incq %r15
cmpq %r15, %r14
jne 0xc4e29
movq 0xd6f3d(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
callq 0x1142fb
movq 0xd6f25(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1142fb
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_get_self
const bcore_self_s* bcore_flect_get_self( tp_t type )
{
    const bcore_self_s* self = bcore_flect_try_self( type );
    if( !self )
    {
        const char* name = bcore_name_try_name( type );
        if( !name )
        {
            ERR( "type '0x%x'; has neither name nor self-reflection", type );
        }
        else
        {
            ERR( "type '%s' has no self-reflection", name );
        }
    }
    return self;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xc4e97
movq %rax, %rbx
testq %rax, %rax
jne 0xc507e
movq %r14, %rdi
callq 0xd6ec4
leaq 0x7ee69(%rip), %rdi     # 0x143eb4
leaq 0x7e5dc(%rip), %rsi     # 0x14362e
testq %rax, %rax
je 0xc5068
leaq 0x7ee9d(%rip), %rcx     # 0x143efb
movl $0x92e, %edx            # imm = 0x92E
movq %rax, %r8
jmp 0xc5077
leaq 0x7ee5a(%rip), %rcx     # 0x143ec9
movl $0x92a, %edx            # imm = 0x92A
movq %r14, %r8
xorl %eax, %eax
callq 0xbe592
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_define_self_d
tp_t bcore_flect_define_self_d( bcore_self_s* self )
{
    assert( self_map_s_g != NULL );
    bcore_self_s_check_integrity( self );
    tp_t type = self->type;
    bcore_mutex_s_lock( &self_map_s_g->mutex );
    if( bcore_hmap_u3vd_s_exists( self_map_s_g->hmap, type ) ) ERR( "'%s' (%"PRItp_t") is already defined", ifnameof( type ), type );
    bcore_flect_set_trait( self );
    bcore_hmap_u3vd_s_set( self_map_s_g->hmap, type, self, true );
    bcore_mutex_s_unlock( &self_map_s_g->mutex );
    return self->type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xc4ac0
movq 0x8(%rbx), %r14
movq 0xd6d08(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142c9
movq 0xd6cf8(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
movq %r14, %rsi
callq 0xc8069
testb %al, %al
je 0xc50f9
movq %r14, %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x83644(%rip), %r8      # 0x148715
cmovneq %rax, %r8
leaq 0x7ee40(%rip), %rdi     # 0x143f1c
leaq 0x7e54b(%rip), %rsi     # 0x14362e
leaq 0x7ee4c(%rip), %rcx     # 0x143f36
movl $0x93c, %edx            # imm = 0x93C
movq %r14, %r9
xorl %eax, %eax
callq 0xbe592
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x1168a7
movq 0xd6c9b(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xc77e4
movq 0xd6c81(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142fb
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_define_parse_nasc
tp_t bcore_flect_define_parse_nasc( const sc_t* nasc )
{
    st_s* st = st_s_create_nasc( nasc );
    tp_t ret = bcore_flect_define_parse_sc( st->sc );
    st_s_discard( st );
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x109f46
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xc517e
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_flect.c
// Function: bcore_flect_define_parse_fa
tp_t bcore_flect_define_parse_fa( sc_t format, ... )
{
    va_list args;
    va_start( args, format );
    st_s* string = st_s_createvf( format, args );
    va_end( args );
    tp_t type = bcore_flect_define_parse_sc( string->sc );
    st_s_discard( string );
    return type;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xc5264
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, %rsi
movq %r10, 0x10(%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x109cb2
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xc517e
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a028
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_type_self_d
tp_t bcore_flect_type_self_d( bcore_self_s* self )
{
    const bcore_self_s* self_l = bcore_flect_try_self( self->type );
    if( self_l )
    {
        if( bcore_self_s_cmp( self_l, self ) != 0 )
        {
            ERR( "Attempt to register a different reflection under type = '%s' (%"PRItp_t")\nRegistered:\n%s\nNew:\n%s\n",
                 ifnameof( self->type ), self->type,
                 bcore_self_s_show( self_l )->sc,
                 bcore_self_s_show( self )->sc );
        }
        bcore_self_s_discard( self );
        return self_l->type;
    }
    else
    {
        flect_define_self_reentrant_d( self );
        return self->type;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xc4e97
testq %rax, %rax
je 0xc5356
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc46dd
testl %eax, %eax
je 0xc5341
movq 0x8(%rbx), %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x83424(%rip), %r15     # 0x148715
cmovneq %rax, %r15
movq 0x8(%rbx), %r12
movq %r14, %rdi
callq 0xc35a8
movq 0x8(%rax), %r13
movq %rbx, %rdi
callq 0xc35a8
movq %rax, %r10
leaq 0x7ec3d(%rip), %rdi     # 0x143f54
leaq 0x7e310(%rip), %rsi     # 0x14362e
leaq 0x7ec47(%rip), %rcx     # 0x143f6c
movl $0x989, %edx            # imm = 0x989
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
pushq 0x8(%r10)
pushq %r13
callq 0xbe592
addq $0x10, %rsp
leaq -0x2137(%rip), %rdi     # 0xc3211
movq %rbx, %rsi
callq 0xbe7ee
addq $0x8, %r14
jmp 0xc53c6
movq %rbx, %rdi
callq 0xc4ac0
movq 0x8(%rbx), %r14
movq 0xd6a3f(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142c9
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x1168a7
movq 0xd6a22(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
movq %r14, %rsi
callq 0xc8069
testb %al, %al
jne 0xc53af
movq 0xd6a0c(%rip), %rax     # 0x19bda8
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xc77e4
addq $0x8, %rbx
movq 0xd69ee(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142fb
movq %rbx, %r14
movq (%r14), %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_flect_type_parse_nasc
tp_t bcore_flect_type_parse_nasc( const sc_t* nasc )
{
    st_s* st = st_s_create_nasc( nasc );
    tp_t ret = bcore_flect_type_parse_sc( st->sc );
    st_s_discard( st );
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x109f46
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xc5415
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_flect.c
// Function: bcore_flect_define_creator
void bcore_flect_define_creator( tp_t type, bcore_flect_create_self_fp creator )
{
    assert( creator_map_s_g != NULL );
    bcore_mutex_s_lock( &creator_map_s_g->mutex );
    if( bcore_hmap_u3vd_s_exists( creator_map_s_g->hmap, type ) ) ERR( "'%s' (%"PRItp_t") is already defined", ifnameof( type ), type );
    bcore_hmap_u3vd_s_setf( creator_map_s_g->hmap, type, ( fp_t )creator );
    bcore_mutex_s_unlock( &creator_map_s_g->mutex );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd685a(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
callq 0x1142c9
movq 0xd684a(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xc8069
testb %al, %al
je 0xc55af
movq %r14, %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x8318e(%rip), %r8      # 0x148715
cmovneq %rax, %r8
leaq 0x7ea35(%rip), %rdi     # 0x143fc7
leaq 0x7e095(%rip), %rsi     # 0x14362e
leaq 0x7e996(%rip), %rcx     # 0x143f36
movl $0x9c7, %edx            # imm = 0x9C7
movq %r14, %r9
xorl %eax, %eax
callq 0xbe592
movq 0xd67fa(%rip), %rax     # 0x19bdb0
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc7c48
movq 0xd67e5(%rip), %rdi     # 0x19bdb0
addq $0x8, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1142fb
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_push_item_d
void bcore_flect_push_item_d( tp_t type, bcore_self_item_s* item )
{
    bool allowed = false;
    if( item->caps == BCORE_CAPS_EXTERNAL_FUNC ) allowed = true;
    if( item->flags.f_const                    ) allowed = true;
    if( !allowed )
    {
        WRN_fa( "Extending type '#<sc_t>': item configuration is not allowed.", ifnameof( type ) );
        return;
    }

    bcore_self_s* self = bcore_flect_try_d_self( type );

    if( nameof( self->type ) == NULL )
    {
        WRN_fa( "Extending anonymous type is not allowed.", ifnameof( type ) );
        return;
    }

    if( self )
    {
        bcore_mutex_s_lock( &self_map_s_g->mutex );
        bcore_self_s_push_d( self, item );
        bcore_mutex_s_unlock( &self_map_s_g->mutex );
        bcore_self_s_check_integrity( self );
    }
    else
    {
        WRN_fa( "Extending type '#<sc_t>': Type is not defined.", ifnameof( type ) );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
testb $0x10, 0x14(%rsi)
jne 0xc5627
cmpl $0xe, 0x10(%rbx)
je 0xc5627
movq %r15, %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x83111(%rip), %r8      # 0x148715
cmovneq %rax, %r8
leaq 0x7e9d3(%rip), %rdi     # 0x143fe2
leaq 0x7e018(%rip), %rsi     # 0x14362e
leaq 0x7e9dd(%rip), %rcx     # 0x143ffa
movl $0x9d5, %edx            # imm = 0x9D5
jmp 0xc56a8
movq %r15, %rdi
callq 0xc4e97
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xd6ec4
testq %rax, %rax
je 0xc5678
movq 0xd6761(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142c9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc3429
movq 0xd6746(%rip), %rdi     # 0x19bda8
addq $0x8, %rdi
callq 0x1142fb
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc4ac0
movq %r15, %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x8308b(%rip), %r8      # 0x148715
cmovneq %rax, %r8
leaq 0x7e94d(%rip), %rdi     # 0x143fe2
leaq 0x7df92(%rip), %rsi     # 0x14362e
leaq 0x7e994(%rip), %rcx     # 0x144037
movl $0x9dd, %edx            # imm = 0x9DD
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xd6be