LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_file.c
// Function: bcore_file_find_descend
bl_t bcore_file_find_descend( sc_t folder, sc_t path, st_s* result )
{
    BLM_INIT();
    st_s* st_folder = BLM_A_PUSH( st_s_create_sc( folder ) );
    st_s* st_result = BLM_A_PUSH( st_s_create() );

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

            BLM_RETURNV( bl_t, true );
        }

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

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

    BLM_RETURNV( bl_t, false );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xb6e65(%rip), %rax     # 0x117dd0
movq (%rax), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x717f5
movq %r15, %rdi
callq 0x8ed62
movq %r12, %rdi
movq %rax, %rsi
callq 0x71a4d
movq %rax, %r15
xorl %eax, %eax
callq 0x8eb65
movq %r12, %rdi
movq %rax, %rsi
callq 0x71a4d
movq %rax, %r12
leaq 0x490cb(%rip), %r13     # 0xaa078
movq 0x8(%r15), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x8e7af
movq 0x8(%r12), %rdi
callq 0x60eaa
movl %eax, %ebp
testb %al, %al
jne 0x6100c
movq 0x10(%r15), %rax
cmpq $0x1, %rax
je 0x60fe6
testq %rax, %rax
je 0x6101c
movq 0x8(%r15), %rdi
jmp 0x60fef
movq 0x8(%r15), %rdi
cmpb $0x2f, (%rdi)
je 0x6101c
callq 0x60c15
movq %rax, %rbp
movq %r15, %rdi
movq %rax, %rsi
callq 0x8e4fd
movq %rbp, %rdi
callq 0x8edd4
jmp 0x60fad
testq %rbx, %rbx
je 0x6101c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8e4fd
leaq 0x8(%rsp), %rdi
callq 0x71b64
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_item_s_create_plain
bcore_self_item_s* bcore_self_item_s_create_plain( u2_t caps, tp_t type, tp_t name )
{
    bcore_self_item_s* o = bcore_self_item_s_create();
    o->caps  = caps;
    o->type  = type;
    o->name  = name;
    return o;
}

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

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

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

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rsi
movq %rax, %rdi
callq 0x61447
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x61447
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x6145c
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x61447
movq 0x18(%rbx), %rcx
pushq $0x8
popq %rdx
movabsq $0x100000001b3, %rsi    # imm = 0x100000001B3
subq $0x1, %rdx
jb 0x61445
movzbl %cl, %edi
xorq %rax, %rdi
imulq %rsi, %rdi
shrq $0x8, %rcx
movq %rdi, %rax
jmp 0x6142c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_item_s_cmp
s2_t bcore_self_item_s_cmp( const bcore_self_item_s* o1, const bcore_self_item_s* o2 )
{
    if( o1->type       != o2->type       ) return ( o1->type < o2->type ) ? 1 : -1;
    if( o1->name       != o2->name       ) return ( o1->name < o2->name ) ? 1 : -1;
    if( o1->caps       != o2->caps       ) return ( o1->caps < o2->caps ) ? 1 : -1;
    if( o1->flags.data != o2->flags.data ) return ( o1->flags.data < o2->flags.data ) ? 1 : -1;
    if( o1->default_u3 != o2->default_u3 ) return ( o1->default_u3 < o2->default_u3 ) ? 1 : -1;
    return 0;
}

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r15
jae 0x631bc
movq (%rdi,%r15,8), %rdi
callq 0x61193
incq %r15
jmp 0x631a5
callq 0x60272
leaq 0x10(%rbx), %r8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
xorl %r15d, %r15d
pushq $0x8
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x60263
movq %rax, (%rbx)
movq 0x8(%r14), %rax
cmpq %rax, %r15
jae 0x63207
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x611e8
movq (%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x631e6
movq %rax, 0x8(%rbx)
movb 0x18(%r14), %al
movb %al, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_body_s_push_d
bcore_self_item_s* bcore_self_body_s_push_d( bcore_self_body_s* o, bcore_self_item_s* item )
{
    if( o->size == o->space )
    {
        bcore_self_item_s** old_data = o->data;
        o->data = bcore_u_alloc( sizeof( bcore_self_item_s* ), NULL, o->space > 0 ? o->space * 2 : 1, &o->space );
        for( uz_t i = 0; i < o->size; i++ ) o->data[ i ] = old_data[ i ];
        bcore_release( old_data );
    }
    o->data[ o->size ] = item;
    o->size++;
    return o->data[ o->size -1 ];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
jne 0x63312
leaq 0x10(%rbx), %rcx
movq (%rbx), %r15
leaq (%rax,%rax), %rsi
testq %rax, %rax
pushq $0x1
popq %rdx
cmovneq %rsi, %rdx
xorl %r12d, %r12d
pushq $0x8
popq %rdi
xorl %esi, %esi
callq 0x6025e
movq %rax, (%rbx)
cmpq 0x8(%rbx), %r12
jae 0x63306
movq (%r15,%r12,8), %rax
movq (%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x632f0
movq %r15, %rdi
callq 0x60272
movq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq %r14, (%rcx,%rax,8)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq (%rax,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %eax, %eax
callq 0x8eb65
movq %rax, %rbx
leaq 0x5e3e8(%rip), %rsi     # 0xc1757
movq %rax, %rdi
xorl %eax, %eax
callq 0x8f42b
leaq 0x5e087(%rip), %rsi     # 0xc1407
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
leaq 0x5e3d8(%rip), %r15     # 0xc1769
leaq 0x5e3e1(%rip), %r12     # 0xc1779
pushq $0xa
popq %rbp
xorl %r13d, %r13d
cmpq 0x8(%r14), %r13
jae 0x633dd
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x8f42b
movq (%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x61260
movq %rax, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x8fe10
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8f2e5
incq %r13
jmp 0x6339e
leaq 0x5e0ad(%rip), %rsi     # 0xc1491
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_self_body_s_cmp
s2_t bcore_self_body_s_cmp( const bcore_self_body_s* o1, const bcore_self_body_s* o2 )
{
    if( o1->size != o2->size ) return ( o1->size < o2->size ) ? 1 : -1;
    for( uz_t i = 0; i < o1->size; i++ )
    {
        s2_t c = bcore_self_item_s_cmp( o1->data[ i ], o2->data[ i ] );
        if( c != 0 ) return c;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r12
movq 0x8(%rsi), %rax
cmpq %rax, %r12
jne 0x63475
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x63480
movq (%r15), %rax
movq (%rax,%r13,8), %rdi
movq (%r14), %rax
movq (%rax,%r13,8), %rsi
callq 0x6149b
incq %r13
testl %eax, %eax
je 0x63452
movl %eax, %ebx
jmp 0x63480
xorl %ebx, %ebx
cmpq %rax, %r12
adcl $-0x1, %ebx
orl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x71db6
movq %rax, %r13
xorl %eax, %eax
callq 0x8eb65
movq %rax, %r12
testq %r13, %r13
jne 0x6356a
leaq 0x5e2a5(%rip), %rdi     # 0xc17f5
leaq 0x5de67(%rip), %rsi     # 0xc13be
leaq 0x5e245(%rip), %rcx     # 0xc17a3
movl $0x584, %edx            # imm = 0x584
xorl %eax, %eax
callq 0x60186
leaq 0x4789e(%rip), %rsi     # 0xaae0f
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x87cf1
movq 0x30(%r15), %rax
testq %rax, %rax
je 0x635d0
xorl %r13d, %r13d
cmpq 0x8(%rax), %r13
jae 0x635d0
movq (%rax), %rax
movq (%rax,%r13,8), %rbp
movq %r12, %rdi
callq 0x8f0c3
movq %rbp, %rdi
movq %r12, %rsi
callq 0x62f6b
testb %al, %al
je 0x635c7
movq 0x8(%r12), %rcx
movq %r14, %rdi
leaq 0x5e259(%rip), %rsi     # 0xc1816
movq %rbx, %rdx
xorl %eax, %eax
callq 0x87cf1
incq %r13
movq 0x30(%r15), %rax
jmp 0x6358a
movq %r12, %rdi
callq 0x8edd4
leaq 0x470c3(%rip), %rsi     # 0xaa6a2
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 0x87cf1
// File: /workspace/github_c_makefile_star2_O2/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 0x71db6
testq %rax, %rax
jne 0x63714
leaq 0x5e180(%rip), %rdi     # 0xc187a
leaq 0x5dcbd(%rip), %rsi     # 0xc13be
leaq 0x5e09b(%rip), %rcx     # 0xc17a3
movl $0x5b3, %edx            # imm = 0x5B3
xorl %eax, %eax
callq 0x60186
leaq 0x5dced(%rip), %rsi     # 0xc1408
movq %rbx, %rdi
xorl %eax, %eax
callq 0x87cf1
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x6374f
xorl %r15d, %r15d
cmpq 0x8(%rax), %r15
jae 0x6374f
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x62f6b
incq %r15
movq 0x30(%r14), %rax
jmp 0x63731
leaq 0x5dd3c(%rip), %rsi     # 0xc1492
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x87cf1
// File: /workspace/github_c_makefile_star2_O2/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 0x71db6
movq %rax, %r14
testq %rax, %rax
jne 0x637a8
leaq 0x5e119(%rip), %rdi     # 0xc18a7
leaq 0x5dc29(%rip), %rsi     # 0xc13be
leaq 0x5e007(%rip), %rcx     # 0xc17a3
movl $0x5c5, %edx            # imm = 0x5C5
xorl %eax, %eax
callq 0x60186
leaq 0x5e114(%rip), %rsi     # 0xc18c3
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x87cf1
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6351a
leaq 0x48494(%rip), %rsi     # 0xabc68
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x87cf1
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
testq %rcx, %rcx
je 0x63953
movq 0x8(%rcx), %rdx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x63953
movq (%rcx), %rax
movq (%rax,%rdi,8), %rax
incq %rdi
cmpq %rsi, 0x8(%rax)
jne 0x6393d
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
testq %rcx, %rcx
je 0x63980
movq 0x8(%rcx), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x63980
movq (%rcx), %rax
movq (%rax,%rsi,8), %rax
movl 0x10(%rax), %edi
addl $-0x6, %edi
incq %rsi
cmpl $0x7, %edi
ja 0x63965
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
testq %rcx, %rcx
je 0x639c1
movq 0x8(%rcx), %rdx
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x639c1
movq (%rcx), %rax
movq (%rax,%rdi,8), %rax
cmpq %rsi, 0x8(%rax)
jne 0x639bc
movl 0x10(%rax), %r8d
addl $-0x6, %r8d
cmpl $0x8, %r8d
jb 0x639c3
incq %rdi
jmp 0x6399c
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x71db6
leaq 0x4732c(%rip), %rdi     # 0xaad7c
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8ec7d
movq %rax, %r13
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x61370
movq %r12, %rdi
movq %rax, %rsi
callq 0x639c4
movq %rax, %rbx
movq %r13, %rdi
callq 0x8edd4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x637ec
movq %r13, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x63afd
callq 0x63233
andq $0x0, 0x30(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8eb65
movq %rax, %rbx
leaq 0x5de0f(%rip), %rsi     # 0xc1934
movq %rax, %rdi
xorl %eax, %eax
callq 0x8f42b
leaq 0x5d8d1(%rip), %rsi     # 0xc1407
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x6133a
leaq 0x5ddee(%rip), %rsi     # 0xc1941
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x8f42b
movq 0x20(%r14), %rdx
leaq 0x5dde7(%rip), %rsi     # 0xc1955
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
leaq 0x5dde6(%rip), %rsi     # 0xc1965
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x63bb4
callq 0x63350
leaq 0x5dbdb(%rip), %rdx     # 0xc1779
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x8fe10
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8f2e5
leaq 0x5d8d6(%rip), %rsi     # 0xc1491
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x63846
movq %rax, %r14
callq 0x61245
movq %rax, %r15
movl $0x6, 0x10(%rax)
movq %rbx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x639f2
movq %r15, %rdi
callq 0x61193
movq 0x30(%r14), %rdi
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
callq 0x63400
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x63846
movq %rax, %r14
callq 0x61245
movq %rax, %r15
movl $0x8, 0x10(%rax)
movq %rbx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x639f2
movq %r15, %rdi
callq 0x61193
movq 0x30(%r14), %rdi
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
callq 0x63400
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x63846
movq %rax, %r15
callq 0x61245
movq %rax, %r12
movl $0xb, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x639f2
movq %r12, %rdi
callq 0x61193
movq 0x30(%r15), %rdi
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
callq 0x63400
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x63846
movq %rax, %r15
callq 0x61245
movq %rax, %r12
movl $0xc, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x639f2
movq %r12, %rdi
callq 0x61193
movq 0x30(%r15), %rdi
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
callq 0x63400
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x63846
movq %rax, %r14
callq 0x61245
movq %rax, %r15
movl $0xd, 0x10(%rax)
andq $0x0, (%rax)
movq %rbx, 0x18(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x639f2
movq %r15, %rdi
callq 0x61193
movq 0x30(%r14), %rdi
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
callq 0x63400
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8ed77
movq %rax, %r15
movq 0x8(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x64356
movq %rax, %rbx
movq %r15, %rdi
callq 0x8edd4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0x61447
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x61447
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x61447
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x64441
movq %rax, %rsi
popq %rbx
jmp 0x63400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x64489
movq 0x10(%rdi), %rcx
movq 0x10(%rsi), %rdx
cmpq %rdx, %rcx
jne 0x64489
movq 0x18(%rdi), %rcx
movq 0x18(%rsi), %rdx
cmpq %rdx, %rcx
jne 0x64489
movq 0x30(%rdi), %rdi
movq 0x30(%rsi), %rsi
cmpq %rsi, %rdi
je 0x64495
testq %rdi, %rdi
je 0x64498
testq %rsi, %rsi
jne 0x63431
pushq $-0x1
jmp 0x6449a
xorl %eax, %eax
cmpq %rdx, %rcx
adcl $-0x1, %eax
orl $0x1, %eax
retq
xorl %eax, %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x30(%rdi), %rbp
testq %rbp, %rbp
je 0x64534
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
cmpq 0x8(%rbp), %rbx
jae 0x64534
movq (%rbp), %rax
movq (%rax,%rbx,8), %r13
cmpl $0xe, 0x10(%r13)
jne 0x6452f
testq %r15, %r15
je 0x644df
cmpq %r15, (%r13)
jne 0x6452f
testq %r14, %r14
je 0x644ea
cmpq %r14, 0x8(%r13)
jne 0x6452f
movq 0x18(%r13), %rdi
testq %rdi, %rdi
jne 0x64548
movq 0x8(%r12), %rdi
callq 0x6133a
movq %rax, %r13
movq %r14, %rdi
callq 0x6133a
leaq 0x5d4ab(%rip), %rdi     # 0xc19ba
leaq 0x5cea8(%rip), %rsi     # 0xc13be
movl $0x785, %edx            # imm = 0x785
leaq 0x5d4ed(%rip), %rcx     # 0xc1a0f
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x60031
incq %rbx
jmp 0x644bf
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66518
movq %rax, %rbx
testq %rax, %rax
jne 0x64536
movq 0x18(%r13), %rdi
callq 0x6133a
movq 0x18(%r13), %r9
leaq 0x5d451(%rip), %rdi     # 0xc19ba
leaq 0x5ce4e(%rip), %rsi     # 0xc13be
leaq 0x5d460(%rip), %rcx     # 0xc19d7
xorl %ebx, %ebx
movl $0x780, %edx            # imm = 0x780
movq %rax, %r8
xorl %eax, %eax
callq 0x60031
jmp 0x64536
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
testq %rcx, %rcx
je 0x64706
movq 0x8(%rcx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x64706
movq (%rcx), %rax
movq (%rax,%r8,8), %rax
cmpl $0x1, 0x10(%rax)
jne 0x64701
testq %rsi, %rsi
je 0x646f6
cmpq %rsi, (%rax)
jne 0x64701
testq %rdx, %rdx
je 0x64709
cmpq %rdx, 0x8(%rax)
je 0x64709
incq %r8
jmp 0x646da
xorl %eax, %eax
retq
addq $0x18, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x99730
testb %al, %al
jne 0x64808
xorl %eax, %eax
callq 0x8eb65
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x99730
movq 0x8(%rbx), %rdi
callq 0x6133a
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x6133a
movq 0x8(%r14), %rcx
movq %rcx, (%rsp)
leaq 0x5d355(%rip), %rdi     # 0xc1b35
leaq 0x5cbd7(%rip), %rsi     # 0xc13be
leaq 0x5d364(%rip), %rcx     # 0xc1b52
movl $0x7d4, %edx            # imm = 0x7D4
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x60031
movq %r14, %rdi
callq 0x8edd4
movq 0x30(%rbx), %rdi
addq $0x10, %rsp
testq %rdi, %rdi
je 0x6481f
popq %rbx
popq %r14
popq %r15
jmp 0x63495
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb3516(%rip), %rsi     # 0x117da8
testq %rsi, %rsi
je 0x648ab
leaq 0x1344(%rip), %rdi      # 0x65be2
callq 0x60277
andq $0x0, 0xb34fd(%rip)     # 0x117da8
movq 0xb34fe(%rip), %rsi     # 0x117db0
testq %rsi, %rsi
je 0x648cb
leaq 0x13a5(%rip), %rdi      # 0x65c63
callq 0x60277
andq $0x0, 0xb34e5(%rip)     # 0x117db0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb34ce(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97ae2
movq 0xb34be(%rip), %rax     # 0x117da8
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x6721a
movl %eax, %ebp
movq 0xb34aa(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97b12
testb %bpl, %bpl
je 0x64910
movb $0x1, %al
jmp 0x64946
movq 0xb3499(%rip), %rdi     # 0x117db0
addq $0x8, %rdi
callq 0x97ae2
movq 0xb3489(%rip), %rax     # 0x117db0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x6721a
movl %eax, %ebx
movq 0xb3475(%rip), %rdi     # 0x117db0
addq $0x8, %rdi
callq 0x97b12
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb3457(%rip), %rdi     # 0x117db0
addq $0x8, %rdi
callq 0x97ae2
movq 0xb3447(%rip), %rax     # 0x117db0
movq (%rax), %rdi
callq 0x672c6
movq %rax, %r14
xorl %r15d, %r15d
testq %rax, %rax
cmovleq %r15, %r14
xorl %ebx, %ebx
cmpq %r15, %r14
je 0x649a4
movq 0xb3424(%rip), %rax     # 0x117db0
movq (%rax), %rdi
movq %r15, %rsi
callq 0x672cb
cmpq $0x1, %rax
sbbq $-0x1, %rbx
incq %r15
jmp 0x64980
movq 0xb33fd(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97ae2
movq 0xb33ed(%rip), %rax     # 0x117da8
movq (%rax), %rdi
callq 0x672c6
movq %rax, %r14
xorl %r15d, %r15d
testq %rax, %rax
cmovleq %r15, %r14
cmpq %r15, %r14
je 0x64a0b
movq 0xb33cc(%rip), %rax     # 0x117da8
movq (%rax), %rdi
movq %r15, %rsi
callq 0x672cb
testq %rax, %rax
je 0x64a06
movq 0xb33bd(%rip), %rcx     # 0x117db0
movq (%rcx), %rdi
movq %rax, %rsi
callq 0x6721a
xorb $0x1, %al
movzbl %al, %eax
addq %rax, %rbx
incq %r15
jmp 0x649d0
movq 0xb339e(%rip), %rdi     # 0x117db0
addq $0x8, %rdi
callq 0x97b12
movq 0xb3386(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97b12
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb336a(%rip), %rdi     # 0x117db0
addq $0x8, %rdi
callq 0x97ae2
movq 0xb335a(%rip), %rax     # 0x117db0
movq (%rax), %rdi
callq 0x672c6
movq %rax, %r14
xorl %r15d, %r15d
testq %rax, %rax
cmovleq %r15, %r14
cmpq %r15, %r14
je 0x64a97
movq 0xb3339(%rip), %rax     # 0x117db0
movq (%rax), %rdi
movq %r15, %rsi
callq 0x672cb
testq %rax, %rax
je 0x64a92
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5baa8
incq %r15
jmp 0x64a6b
movq 0xb330a(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97ae2
movq 0xb32fa(%rip), %rax     # 0x117da8
movq (%rax), %rdi
callq 0x672c6
movq %rax, %r14
xorl %r15d, %r15d
testq %rax, %rax
cmovleq %r15, %r14
cmpq %r15, %r14
je 0x64b08
movq 0xb32d9(%rip), %rax     # 0x117da8
movq (%rax), %rdi
movq %r15, %rsi
callq 0x672cb
testq %rax, %rax
je 0x64b03
movq %rax, %r12
movq 0xb32c7(%rip), %rax     # 0x117db0
movq (%rax), %rdi
movq %r12, %rsi
callq 0x6721a
testb %al, %al
jne 0x64b03
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5baa8
incq %r15
jmp 0x64ac3
movq 0xb32a1(%rip), %rdi     # 0x117db0
addq $0x8, %rdi
callq 0x97b12
movq 0xb3289(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x97b12
// File: /workspace/github_c_makefile_star2_O2/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 0x64b33
movq %rax, %rbx
testq %rax, %rax
jne 0x64cf9
movq %r14, %rdi
callq 0x71db6
leaq 0x5cf7e(%rip), %rdi     # 0xc1c44
leaq 0x5c6f1(%rip), %rsi     # 0xc13be
testq %rax, %rax
je 0x64ce3
leaq 0x5cfb2(%rip), %rcx     # 0xc1c8b
movl $0x92e, %edx            # imm = 0x92E
movq %rax, %r8
jmp 0x64cf2
leaq 0x5cf6f(%rip), %rcx     # 0xc1c59
movl $0x92a, %edx            # imm = 0x92A
movq %r14, %r8
xorl %eax, %eax
callq 0x60031
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x64785
movq 0x8(%rbx), %r14
movq 0xb308d(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97ae2
movq 0xb307d(%rip), %rax     # 0x117da8
movq (%rax), %rdi
movq %r14, %rsi
callq 0x6721a
testb %al, %al
je 0x64d69
movq %r14, %rdi
callq 0x6133a
leaq 0x5cf63(%rip), %rdi     # 0xc1cac
leaq 0x5c66e(%rip), %rsi     # 0xc13be
leaq 0x5cf6f(%rip), %rcx     # 0xc1cc6
movl $0x93c, %edx            # imm = 0x93C
movq %rax, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x60031
movq %rbx, %rdi
callq 0x64c93
movq 0xb3030(%rip), %rax     # 0x117da8
movq (%rax), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x66bf0
movq 0xb3018(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97b12
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8ed77
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x64de5
movq %rax, %r14
movq %rbx, %rdi
callq 0x8edd4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x64ea3
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 0x8eb93
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x64de5
movq %rax, %r14
movq %rbx, %rdi
callq 0x8edd4
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x64b33
testq %rax, %rax
je 0x64f7d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x64443
testl %eax, %eax
je 0x64f6f
movq 0x8(%rbx), %rdi
callq 0x6133a
movq %rax, %r15
movq 0x8(%rbx), %r12
movq %r14, %rdi
callq 0x63b0c
movq 0x8(%rax), %r13
movq %rbx, %rdi
callq 0x63b0c
movq %rax, %r10
leaq 0x5cd9d(%rip), %rdi     # 0xc1ce4
leaq 0x5c470(%rip), %rsi     # 0xc13be
leaq 0x5cda7(%rip), %rcx     # 0xc1cfc
movl $0x989, %edx            # imm = 0x989
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
pushq 0x8(%r10)
pushq %r13
callq 0x60031
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x63886
addq $0x8, %r14
jmp 0x64fe6
movq %rbx, %rdi
callq 0x64785
movq 0x8(%rbx), %r14
movq 0xb2e18(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97ae2
movq %rbx, %rdi
callq 0x64c93
movq 0xb2e00(%rip), %rax     # 0x117da8
movq (%rax), %rdi
movq %r14, %rsi
callq 0x6721a
testb %al, %al
jne 0x64fcf
movq 0xb2dea(%rip), %rax     # 0x117da8
movq (%rax), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x66bf0
addq $0x8, %rbx
movq 0xb2dce(%rip), %rdi     # 0x117da8
addq $0x8, %rdi
callq 0x97b12
movq %rbx, %r14
movq (%r14), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8ed77
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x65033
movq %rax, %r14
movq %rbx, %rdi
callq 0x8edd4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_flect.c
// Function: bcore_flect_type_parse_fa
tp_t bcore_flect_type_parse_fa( sc_t format, ... )
{
    va_list args;
    va_start( args, format );
    st_s* string = st_s_create_fv( format, args );
    va_end( args );
    tp_t type = bcore_flect_type_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 0x650f1
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 0x8ec4c
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x65033
movq %rax, %r14
movq %rbx, %rdi
callq 0x8edd4
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq