LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xe0cbc
movq %rax, %r14
testq %rax, %rax
jne 0xcd29a
leaq 0x81857(%rip), %rdi     # 0x14ead7
leaq 0x81367(%rip), %rsi     # 0x14e5ee
leaq 0x81745(%rip), %rcx     # 0x14e9d3
movl $0x5c5, %edx            # imm = 0x5C5
xorl %eax, %eax
callq 0xc825d
leaq 0x81852(%rip), %rsi     # 0x14eaf3
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x109273
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xccff7
leaq 0x6c9a2(%rip), %rsi     # 0x139c68
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109273
// File: /workspace/github_c_makefile_star2_O1/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 0xcd49d
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xcd49d
movq (%rax), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
cmpq %rsi, 0x8(%r8)
cmoveq %r8, %rax
je 0xcd49f
incq %rdi
cmpq %rdi, %rcx
jne 0xcd487
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcd4d5
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xcd4d5
movq (%rax), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movl 0x10(%rdi), %r8d
addl $-0x6, %r8d
cmpl $0x8, %r8d
cmovbq %rdi, %rax
jb 0xcd4d7
incq %rsi
cmpq %rsi, %rcx
jne 0xcd4b7
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcd529
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xcd529
movq (%rax), %rdx
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
cmpq %rsi, 0x8(%r8)
jne 0xcd519
movl 0x10(%r8), %r9d
addl $-0x6, %r9d
cmpl $0x8, %r9d
jae 0xcd519
xorl %r9d, %r9d
movq %r8, %rax
jmp 0xcd51c
movb $0x1, %r9b
testb %r9b, %r9b
je 0xcd52b
incq %rdi
cmpq %rdi, %rcx
jne 0xcd4f9
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe0cbc
leaq 0x6b7aa(%rip), %rdi     # 0x138d7c
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x114d03
movq %rax, %r13
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc96c5
movq %r12, %rdi
movq %rax, %rsi
callq 0xcd52c
movq %rax, %rbx
movq %r13, %rdi
callq 0x114f61
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xc8366
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 0xcd698
leaq -0xadd(%rip), %rdi      # 0xccbb6
callq 0xc8352
movq $0x0, 0x30(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_s_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 0x114bbb
movq %rax, %rbx
leaq 0x814a1(%rip), %rsi     # 0x14eb64
movq %rax, %rdi
xorl %eax, %eax
callq 0x1156f6
leaq 0x80f63(%rip), %rsi     # 0x14e637
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x85ffb(%rip), %rcx     # 0x1536ef
cmovneq %rax, %rcx
leaq 0x81472(%rip), %rsi     # 0x14eb71
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1156f6
movq 0x20(%r14), %rdx
leaq 0x8146e(%rip), %rsi     # 0x14eb85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
leaq 0x8146d(%rip), %rsi     # 0x14eb95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0xcd75f
callq 0xcce2a
leaq 0x81262(%rip), %rdx     # 0x14e9a9
movq %rax, %rdi
movl $0xa, %esi
callq 0x116181
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11556c
leaq 0x80f5b(%rip), %rsi     # 0x14e6c1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xc8315
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r12
movl $0x28, %esi
movq %rax, %rdi
callq 0xc8366
movl $0x6, 0x10(%r12)
movq %r15, (%r12)
movq %r12, %rdi
callq 0xc94b5
movq %r14, %rdi
movq %rax, %rsi
callq 0xcd52c
leaq -0x443b(%rip), %rdi     # 0xc9420
movq %r12, %rsi
callq 0xc8352
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xcd88d
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xc9751
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xcd876
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xc8315
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r12
movl $0x28, %esi
movq %rax, %rdi
callq 0xc8366
movl $0x8, 0x10(%r12)
movq %r15, (%r12)
movq %r12, %rdi
callq 0xc94b5
movq %r14, %rdi
movq %rax, %rsi
callq 0xcd52c
leaq -0x4500(%rip), %rdi     # 0xc9420
movq %r12, %rsi
callq 0xc8352
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xcd952
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xc9751
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xcd93b
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xc8315
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r13
movl $0x28, %esi
movq %rax, %rdi
callq 0xc8366
movl $0xb, 0x10(%r13)
movq %r12, (%r13)
movq %r15, 0x18(%r13)
movq %r13, %rdi
callq 0xc94b5
movq %r14, %rdi
movq %rax, %rsi
callq 0xcd52c
leaq -0x45cb(%rip), %rdi     # 0xc9420
movq %r13, %rsi
callq 0xc8352
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xcda1d
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xc9751
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xcda06
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xc8315
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r13
movl $0x28, %esi
movq %rax, %rdi
callq 0xc8366
movl $0xc, 0x10(%r13)
movq %r12, (%r13)
movq %r15, 0x18(%r13)
movq %r13, %rdi
callq 0xc94b5
movq %r14, %rdi
movq %rax, %rsi
callq 0xcd52c
leaq -0x4696(%rip), %rdi     # 0xc9420
movq %r13, %rsi
callq 0xc8352
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xcdae8
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xc9751
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xcdad1
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xc8315
movq %rax, %r14
movl $0x38, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $-0x4b706df6ad0a9f1, %rax # imm = 0xFB48F920952F560F
movq %rax, (%r14)
movl $0x28, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r12
movl $0x28, %esi
movq %rax, %rdi
callq 0xc8366
movl $0xd, 0x10(%r12)
movq $0x0, (%r12)
movq %r15, 0x18(%r12)
movq %r12, %rdi
callq 0xc94b5
movq %r14, %rdi
movq %rax, %rsi
callq 0xcd52c
leaq -0x4764(%rip), %rdi     # 0xc9420
movq %r12, %rsi
callq 0xc8352
movq 0x30(%r14), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xcdbb6
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0xc9751
movq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0xcdb9f
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0x114e7f
movq %rax, %r15
movq 0x8(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xce5c6
movq %rax, %rbx
movq %r15, %rdi
callq 0x114f61
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xce824
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rcx), %rbx
testq %rbx, %rbx
je 0xce81f
movq (%rcx), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
movq %rax, %rsi
callq 0xc9751
incq %r15
cmpq %r15, %rbx
jne 0xce80b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_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 0xce86d
movq 0x10(%rdi), %rcx
movq 0x10(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xce86d
movq 0x18(%rdi), %rcx
movq 0x18(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xce86d
movq 0x30(%rdi), %rdi
movq 0x30(%rsi), %rsi
cmpq %rsi, %rdi
je 0xce879
testq %rdi, %rdi
je 0xce87c
testq %rsi, %rsi
jne 0xccf09
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_O1/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
subq $0x18, %rsp
movq 0x30(%rdi), %rbp
testq %rbp, %rbp
je 0xce9b5
cmpq $0x0, 0x8(%rbp)
je 0xce9b5
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
xorl %r15d, %r15d
movq (%rbp), %rax
movq (%rax,%r15,8), %r13
movb $0x1, %r12b
cmpl $0xe, 0x10(%r13)
jne 0xce9a3
testq %r14, %r14
je 0xce8db
cmpq %r14, (%r13)
jne 0xce9a3
testq %rbx, %rbx
je 0xce8ea
cmpq %rbx, 0x8(%r13)
jne 0xce9a3
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0xce90a
callq 0xd103c
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xce961
xorl %r12d, %r12d
jmp 0xce9a3
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xe0cbc
movq %rax, %r13
testq %rax, %rax
leaq 0x84dca(%rip), %rax     # 0x1536ef
cmoveq %rax, %r13
movq %rbx, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x84db4(%rip), %rcx     # 0x1536ef
cmoveq %rcx, %rax
leaq 0x802a4(%rip), %rdi     # 0x14ebea
leaq 0x7fca1(%rip), %rsi     # 0x14e5ee
movl $0x785, %edx            # imm = 0x785
leaq 0x802e6(%rip), %rcx     # 0x14ec3f
movq %r13, %r8
movq %rax, %r9
jmp 0xce99c
movq 0x18(%r13), %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x84d7b(%rip), %rcx     # 0x1536ef
cmoveq %rcx, %rax
movq 0x18(%r13), %r9
xorl %r12d, %r12d
leaq 0x80264(%rip), %rdi     # 0x14ebea
leaq 0x7fc61(%rip), %rsi     # 0x14e5ee
movl $0x780, %edx            # imm = 0x780
leaq 0x8026e(%rip), %rcx     # 0x14ec07
movq %rax, %r8
xorl %eax, %eax
callq 0xc80f6
testb %r12b, %r12b
je 0xce9c6
incq %r15
cmpq 0x8(%rbp), %r15
jb 0xce8b6
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
jmp 0xce9b7
// File: /workspace/github_c_makefile_star2_O1/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 0xceba5
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xceba5
movq (%rax), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r10
movb $0x1, %r9b
cmpl $0x1, 0x10(%r10)
jne 0xceb98
testq %rsi, %rsi
je 0xceb83
cmpq %rsi, (%r10)
jne 0xceb98
testq %rdx, %rdx
je 0xceb8e
cmpq %rdx, 0x8(%r10)
jne 0xceb98
addq $0x18, %r10
xorl %r9d, %r9d
movq %r10, %rax
testb %r9b, %r9b
je 0xceba7
incq %r8
cmpq %r8, %rcx
jne 0xceb6b
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x121fa6
testb %al, %al
jne 0xcecd9
xorl %eax, %eax
callq 0x114bbb
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x121fa6
movq 0x8(%rbx), %rdi
callq 0xe0cbc
movq %rax, %r15
testq %rax, %rax
leaq 0x84a61(%rip), %r12     # 0x1536ef
cmoveq %r12, %r15
movq 0x10(%rbx), %rdi
callq 0xe0cbc
testq %rax, %rax
cmovneq %rax, %r12
movq 0x8(%r14), %rax
movq %rax, (%rsp)
leaq 0x800b4(%rip), %rdi     # 0x14ed65
leaq 0x7f936(%rip), %rsi     # 0x14e5ee
leaq 0x800c3(%rip), %rcx     # 0x14ed82
movl $0x7d4, %edx            # imm = 0x7D4
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0xc80f6
movq %r14, %rdi
callq 0x114f61
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
je 0xced01
cmpq $0x0, 0x8(%rbx)
je 0xced01
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xc99af
incq %r14
cmpq 0x8(%rbx), %r14
jb 0xcecec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_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 0xda02a(%rip), %rsi     # 0x1a8da8
testq %rsi, %rsi
je 0xced9a
leaq 0x1486(%rip), %rdi      # 0xd0210
callq 0xc8352
movq $0x0, 0xda00e(%rip) # 0x1a8da8
movq 0xda00f(%rip), %rsi     # 0x1a8db0
testq %rsi, %rsi
je 0xcedbd
leaq 0x14f8(%rip), %rdi      # 0xd02a5
callq 0xc8352
movq $0x0, 0xd9ff3(%rip) # 0x1a8db0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9fdc(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f515
movq 0xd9fcc(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xd2280
movl %eax, %ebp
movq 0xd9fb8(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f547
testb %bpl, %bpl
je 0xcee02
movb $0x1, %al
jmp 0xcee38
movq 0xd9fa7(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
callq 0x11f515
movq 0xd9f97(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xd2280
movl %eax, %ebx
movq 0xd9f83(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
callq 0x11f547
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9f65(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
callq 0x11f515
movq 0xd9f55(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
callq 0xd23f5
testq %rax, %rax
jle 0xcee94
movq %rax, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0xd9f39(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
movq %r15, %rsi
callq 0xd23fa
cmpq $0x1, %rax
sbbq $-0x1, %rbx
incq %r15
cmpq %r15, %r14
jne 0xcee70
jmp 0xcee96
xorl %ebx, %ebx
movq 0xd9f0b(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f515
movq 0xd9efb(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
callq 0xd23f5
testq %rax, %rax
jle 0xceef9
movq %rax, %r14
xorl %r15d, %r15d
movq 0xd9ee1(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
movq %r15, %rsi
callq 0xd23fa
testq %rax, %rax
je 0xceef1
movq 0xd9ed2(%rip), %rcx     # 0x1a8db0
movq (%rcx), %rdi
movq %rax, %rsi
callq 0xd2280
xorb $0x1, %al
movzbl %al, %eax
addq %rax, %rbx
incq %r15
cmpq %r15, %r14
jne 0xceec0
movq 0xd9eb0(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
callq 0x11f547
movq 0xd9e98(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f547
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_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 0xd9e7c(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
callq 0x11f515
movq 0xd9e6c(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
callq 0xd23f5
testq %rax, %rax
jle 0xcef81
movq %rax, %r14
xorl %r15d, %r15d
movq 0xd9e52(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
movq %r15, %rsi
callq 0xd23fa
testq %rax, %rax
je 0xcef79
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc2b6f
incq %r15
cmpq %r15, %r14
jne 0xcef57
movq 0xd9e20(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f515
movq 0xd9e10(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
callq 0xd23f5
testq %rax, %rax
jle 0xcefee
movq %rax, %r14
xorl %r15d, %r15d
movq 0xd9df6(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
movq %r15, %rsi
callq 0xd23fa
testq %rax, %rax
je 0xcefe6
movq %rax, %r12
movq 0xd9de4(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
movq %r12, %rsi
callq 0xd2280
testb %al, %al
jne 0xcefe6
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc2b6f
incq %r15
cmpq %r15, %r14
jne 0xcefab
movq 0xd9dbb(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
callq 0x11f547
movq 0xd9da3(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11f547
// File: /workspace/github_c_makefile_star2_O1/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 0xcf019
movq %rax, %rbx
testq %rax, %rax
jne 0xcf1f8
movq %r14, %rdi
callq 0xe0cbc
leaq 0x7fcaf(%rip), %rdi     # 0x14ee74
leaq 0x7f422(%rip), %rsi     # 0x14e5ee
testq %rax, %rax
je 0xcf1e2
leaq 0x7fce3(%rip), %rcx     # 0x14eebb
movl $0x92e, %edx            # imm = 0x92E
movq %rax, %r8
jmp 0xcf1f1
leaq 0x7fca0(%rip), %rcx     # 0x14ee89
movl $0x92a, %edx            # imm = 0x92A
movq %r14, %r8
xorl %eax, %eax
callq 0xc80f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcec42
movq 0x8(%rbx), %r14
movq 0xd9b8e(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f515
movq 0xd9b7e(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
movq %r14, %rsi
callq 0xd2280
testb %al, %al
je 0xcf273
movq %r14, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x844a4(%rip), %r8      # 0x1536ef
cmovneq %rax, %r8
leaq 0x7fc86(%rip), %rdi     # 0x14eedc
leaq 0x7f391(%rip), %rsi     # 0x14e5ee
leaq 0x7fc92(%rip), %rcx     # 0x14eef6
movl $0x93c, %edx            # imm = 0x93C
movq %r14, %r9
xorl %eax, %eax
callq 0xc80f6
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x121b6d
movq 0xd9b21(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xd1a23
movq 0xd9b07(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f547
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x114e7f
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xcf2f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x114f61
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0xcf3de
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 0x114beb
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xcf2f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x114f61
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf019
testq %rax, %rax
je 0xcf4d5
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xce825
testl %eax, %eax
je 0xcf4bb
movq 0x8(%rbx), %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x84284(%rip), %r15     # 0x1536ef
cmovneq %rax, %r15
movq 0x8(%rbx), %r12
movq %r14, %rdi
callq 0xcd6aa
movq 0x8(%rax), %r13
movq %rbx, %rdi
callq 0xcd6aa
movq %rax, %r10
leaq 0x7fa83(%rip), %rdi     # 0x14ef14
leaq 0x7f156(%rip), %rsi     # 0x14e5ee
leaq 0x7fa8d(%rip), %rcx     # 0x14ef2c
movl $0x989, %edx            # imm = 0x989
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
pushq 0x8(%r10)
pushq %r13
callq 0xc80f6
addq $0x10, %rsp
testq %rbx, %rbx
je 0xcf4cf
leaq -0x21cc(%rip), %rdi     # 0xcd2fb
movq %rbx, %rsi
callq 0xc8352
addq $0x8, %r14
jmp 0xcf545
movq %rbx, %rdi
callq 0xcec42
movq 0x8(%rbx), %r14
movq 0xd98c0(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f515
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x121b6d
movq 0xd98a3(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
movq %r14, %rsi
callq 0xd2280
testb %al, %al
jne 0xcf52e
movq 0xd988d(%rip), %rax     # 0x1a8da8
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xd1a23
addq $0x8, %rbx
movq 0xd986f(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f547
movq %rbx, %r14
movq (%r14), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_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 0xd96db(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
callq 0x11f515
movq 0xd96cb(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xd2280
testb %al, %al
je 0xcf72e
movq %r14, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x83fe9(%rip), %r8      # 0x1536ef
cmovneq %rax, %r8
leaq 0x7f876(%rip), %rdi     # 0x14ef87
leaq 0x7eed6(%rip), %rsi     # 0x14e5ee
leaq 0x7f7d7(%rip), %rcx     # 0x14eef6
movl $0x9c7, %edx            # imm = 0x9C7
movq %r14, %r9
xorl %eax, %eax
callq 0xc80f6
movq 0xd967b(%rip), %rax     # 0x1a8db0
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd1e73
movq 0xd9666(%rip), %rdi     # 0x1a8db0
addq $0x8, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f547
// File: /workspace/github_c_makefile_star2_O1/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 0xcf7a6
cmpl $0xe, 0x10(%rbx)
je 0xcf7a6
movq %r15, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x83f6c(%rip), %r8      # 0x1536ef
cmovneq %rax, %r8
leaq 0x7f814(%rip), %rdi     # 0x14efa2
leaq 0x7ee59(%rip), %rsi     # 0x14e5ee
leaq 0x7f81e(%rip), %rcx     # 0x14efba
movl $0x9d5, %edx            # imm = 0x9D5
jmp 0xcf85e
movq %r15, %rdi
callq 0xcf019
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xe0cbc
testq %rax, %rax
je 0xcf7fc
testq %r14, %r14
je 0xcf82e
movq 0xd95dd(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f515
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcd52c
movq 0xd95c2(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f547
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xcec42
movq %r15, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x83ee1(%rip), %r8      # 0x1536ef
cmovneq %rax, %r8
leaq 0x7f789(%rip), %rdi     # 0x14efa2
leaq 0x7edce(%rip), %rsi     # 0x14e5ee
leaq 0x7f7d0(%rip), %rcx     # 0x14eff7
movl $0x9dd, %edx            # imm = 0x9DD
jmp 0xcf85e
movq %r15, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x83eaf(%rip), %r8      # 0x1536ef
cmovneq %rax, %r8
leaq 0x7f757(%rip), %rdi     # 0x14efa2
leaq 0x7ed9c(%rip), %rsi     # 0x14e5ee
leaq 0x7f7c7(%rip), %rcx     # 0x14f020
movl $0x9ea, %edx            # imm = 0x9EA
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xd684
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_push_ns_func
void bcore_flect_push_ns_func( tp_t type, fp_t func, sc_t func_type, sc_t func_name )
{
    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_ns_func( self, func, func_type, func_name );
        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 %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0xcf019
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xe0cbc
testq %rax, %rax
je 0xcf8dc
testq %rbx, %rbx
je 0xcf90e
movq 0xd9507(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f515
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xcd5ad
movq 0xd94e6(%rip), %rdi     # 0x1a8da8
addq $0x8, %rdi
callq 0x11f547
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcec42
movq %r13, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x83e01(%rip), %r8      # 0x1536ef
cmovneq %rax, %r8
leaq 0x7f756(%rip), %rdi     # 0x14f04f
leaq 0x7ecee(%rip), %rsi     # 0x14e5ee
leaq 0x7f6f0(%rip), %rcx     # 0x14eff7
movl $0x9f6, %edx            # imm = 0x9F6
jmp 0xcf93e
movq %r13, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x83dcf(%rip), %r8      # 0x1536ef
cmovneq %rax, %r8
leaq 0x7f724(%rip), %rdi     # 0x14f04f
leaq 0x7ecbc(%rip), %rsi     # 0x14e5ee
leaq 0x7f6e7(%rip), %rcx     # 0x14f020
movl $0xa03, %edx            # imm = 0xA03
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd684
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_parse_all_flects
void bcore_flect_parse_all_flects()
{
    bcore_arr_tp_s* type_arr = bcore_arr_tp_s_create();
    bcore_flect_push_all_types( type_arr );
    for( sz_t i = 0; i < type_arr->size; i++ ) bcore_flect_get_self( type_arr->data[ i ] );
    bcore_arr_tp_s_discard( type_arr );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0xc29b3
movq %rax, %rbx
movq %rax, %rdi
callq 0xcef22
cmpq $0x0, 0x10(%rbx)
je 0xcf984
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xcf1a2
incq %r14
cmpq 0x10(%rbx), %r14
jb 0xcf96e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc29e2
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: self_map_s_down
static void self_map_s_down( self_map_s* o )
{
    bcore_mutex_s_lock( &o->mutex );
    if( o->hmap )
    {
        // We manually detach objects here to keep hmap from invoking
        // perspective management, which may (already) be down at this point.
        uz_t hmap_size = bcore_hmap_u3vd_s_size( o->hmap );
        for( uz_t i = 0; i < hmap_size; i++ )
        {
            if( bcore_hmap_u3vd_s_idx_holds( o->hmap, i ) )
            {
                tp_t key = bcore_hmap_u3vd_s_idx_key( o->hmap, i );
                bcore_self_s_discard( bcore_hmap_u3vd_s_detach_h( o->hmap, key ) );
            }
        }
        bcore_hmap_u3vd_s_discard( o->hmap );
    }
    bcore_mutex_s_unlock( &o->mutex );
    bcore_mutex_s_down( &o->mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x11f515
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd028c
callq 0xd23f5
testq %rax, %rax
je 0xd0284
movq %rax, %r15
xorl %r12d, %r12d
leaq -0x2f4c(%rip), %r13     # 0xcd2fb
movq (%r14), %rdi
movq %r12, %rsi
callq 0xd2407
testb %al, %al
je 0xd027c
movq (%r14), %rdi
movq %r12, %rsi
callq 0xd23fa
movq (%r14), %rdi
movq %rax, %rsi
callq 0xd2251
testq %rax, %rax
je 0xd027c
movq %r13, %rdi
movq %rax, %rsi
callq 0xc8352
incq %r12
cmpq %r12, %r15
jne 0xd0247
movq (%r14), %rdi
callq 0xd1861
movq %rbx, %rdi
callq 0x11f547
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11f3ee
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: creator_map_s_down
static void creator_map_s_down( creator_map_s* o )
{
    bcore_mutex_s_lock( &o->mutex );
    bcore_hmap_u3vd_s_discard( o->hmap );
    bcore_mutex_s_unlock( &o->mutex );
    bcore_mutex_s_down( &o->mutex );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x11f515
movq (%rbx), %rdi
callq 0xd1861
movq %r14, %rdi
callq 0x11f547
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f3ee