LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_hmap_tp_sr.c
// Function: hmap_tp_sr_s_create_self
static bcore_self_s* hmap_tp_sr_s_create_self( void )
{
    sc_t def = "\
        bcore_hmap_tp_sr_s = bcore_inst \
        { \
            aware_t _; \
            private bcore_hnode_tp_sr_s* nodes; \
            private bl_t* flags; \
            private uz_t size; \
            private uz_t depth_limit; \
            shell { bcore_hnode_tp_sr_s []; } data; } \
        }";
    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_hmap_tp_sr_s );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_hmap_tp_sr_s_init,    "bcore_fp_init",  "init"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_hmap_tp_sr_s_down,    "bcore_fp_down",  "down"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_hmap_tp_sr_s_copy,    "bcore_fp_copy",  "copy"     );
    bcore_self_s_push_ns_func( self, ( fp_t )tp_sr_s_get_data,           "bcore_fp_get",   "get_data" );
    bcore_self_s_push_ns_func( self, ( fp_t )tp_sr_s_set_data,           "bcore_fp_set",   "set_data" );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x713b4(%rip), %rdi     # 0x146959
movl $0x28, %esi
movl $0x8, %edx
callq 0xc447e
movq %rax, %rbx
leaq -0x167e(%rip), %rsi     # 0xd3f40
leaq 0x6d470(%rip), %rdx     # 0x142a35
leaq 0x6d472(%rip), %rcx     # 0x142a3e
movq %rax, %rdi
callq 0xc34ab
leaq -0x167e(%rip), %rsi     # 0xd3f5d
leaq 0x6d461(%rip), %rdx     # 0x142a43
leaq 0x61be1(%rip), %rcx     # 0x1371ca
movq %rbx, %rdi
callq 0xc34ab
leaq -0x163e(%rip), %rsi     # 0xd3fba
leaq 0x6d452(%rip), %rdx     # 0x142a51
leaq 0x68d55(%rip), %rcx     # 0x13e35b
movq %rbx, %rdi
callq 0xc34ab
leaq 0x38(%rip), %rsi        # 0xd564d
leaq 0x6e57b(%rip), %rdx     # 0x143b97
leaq 0x64773(%rip), %rcx     # 0x139d96
movq %rbx, %rdi
callq 0xc34ab
leaq 0x1ae(%rip), %rsi       # 0xd57e0
leaq 0x6e551(%rip), %rdx     # 0x143b8a
leaq 0x70347(%rip), %rcx     # 0x145987
movq %rbx, %rdi
callq 0xc34ab
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_hmap_tp_sr.c
// Function: tp_sr_s_get_data
static sr_s tp_sr_s_get_data( const bcore_hmap_tp_sr_s* o )
{
    tp_t t_data = bcore_flect_type_parse_sc( "{ bcore_hnode_tp_sr_s []; }" );
    tp_t t_node = typeof( "bcore_hnode_tp_sr_s" );
    sr_s sr = sr_cp( sr_create( t_data ), TYPEOF_bcore_array_s );
    for( uz_t i = 0; i < o->size; i++ )
    {
        if( o->nodes[ i ].key ) bcore_array_r_push( &sr, sr_twc( t_node, &o->nodes[ i ] ) );
    }
    return sr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x71410(%rip), %rdi     # 0x146a78
callq 0xc5415
movq %rax, %r15
movq %rax, %rdi
callq 0x10743a
movq %rax, %r12
testq %r15, %r15
je 0xd568d
movq %r15, %rdi
callq 0x1074f1
movq %rax, %rdi
jmp 0xd568f
xorl %edi, %edi
movabsq $-0x5073d588c3beb52e, %rsi # imm = 0xAF8C2A773C414AD2
callq 0xeb464
movq %r12, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0xd57ce
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x8(%r14), %r12
cmpq $0x0, (%r12,%r15)
je 0xd57be
addq %r15, %r12
movabsq $-0x503e425755b28170, %rdi # imm = 0xAFC1BDA8AA4D7E90
callq 0x1074f1
movq %r12, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x8(%rbx), %r12
movq 0x8(%r12), %rbp
movabsq $-0x5073d588c3beb52e, %rax # imm = 0xAF8C2A773C414AD2
cmpq %rax, %rbp
je 0xd579c
leaq 0xc6709(%rip), %rdx     # 0x19be20
movl (%rdx), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%rdx,%rax,8), %rcx
movq 0x18(%rdx,%rax,8), %rdx
andq %rbp, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
movl $0x8, %ecx
cmpq %rbp, %rdx
je 0xd576c
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %rbp, %rdx
je 0xd576c
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %rbp, %rdx
je 0xd576c
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %rbp, %rdx
jne 0xd5775
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0xd579c
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %rbp, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0xc668f(%rip), %rdi     # 0x19be20
movq %rbp, %rsi
movq %rax, %rdx
callq 0x115fac
movq (%rbx), %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0xed355
movq 0x18(%r14), %rax
incq %r13
addq $0x20, %r15
cmpq %rax, %r13
jb 0xd56c0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_hmap_tp_sr.c
// Function: tp_sr_s_set_data
static void tp_sr_s_set_data( bcore_hmap_tp_sr_s* o, sr_s data )
{
    bcore_hmap_tp_sr_s_clear( o );
    assert( sr_s_type( &data ) == bcore_flect_type_parse_sc( "{ bcore_hnode_tp_sr_s []; }" ) );
    data = sr_cp( data, TYPEOF_bcore_array_s );
    uz_t size = bcore_array_r_get_size( &data );
    if( sr_s_is_strong( &data ) )
    {
        bcore_hnode_tp_sr_s* src = bcore_array_r_get_d_data( &data );
        for( uz_t i = 0; i < size; i++ )
        {
            bcore_hmap_tp_sr_s_set( o, src[ i ].key, src[ i ].val );
            src[ i ].val = sr_null();
        }
    }
    else
    {
        const bcore_hnode_tp_sr_s* src = bcore_array_r_get_c_data( &data );
        for( uz_t i = 0; i < size; i++ )
        {
            bcore_hmap_tp_sr_s_set( o, src[ i ].key, sr_cw( src[ i ].val ) );
        }
    }
    sr_down( data );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x70(%rsp), %rbx
movabsq $-0x5073d588c3beb52e, %r15 # imm = 0xAF8C2A773C414AD2
callq 0xd46b4
movq (%rbx), %r12
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rbp
movq %r15, %rsi
callq 0xeb464
movq %rax, %r13
movq %r12, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq 0x8(%rax), %r12
cmpq %r15, %r12
je 0xd58b9
leaq 0xc65e6(%rip), %rax     # 0x19be20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xd5890
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xd5890
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xd5890
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xd5899
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xd58b9
movq %r15, %rdi
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0xc6572(%rip), %rdi     # 0x19be20
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq (%rbx), %rsi
movq %r13, %rdi
callq 0xede4d
movq %rax, %r15
testb $0x2, 0x10(%rbx)
jne 0xd591f
movq %rbx, %rdi
callq 0xf08ff
testq %r15, %r15
je 0xd596d
movq %rax, %r12
movq (%r12), %rsi
movups 0x8(%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x18(%r12), %rax
andq $-0x3, %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0xd4234
addq $0x20, %r12
decq %r15
jne 0xd58e1
jmp 0xd596d
movq %rbx, %rdi
callq 0xf0922
testq %r15, %r15
je 0xd596d
movq %rax, %r12
addq $0x8, %r12
movq -0x8(%r12), %rsi
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0xd4234
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
addq $0x20, %r12
decq %r15
jne 0xd5933
testb $0x2, 0x10(%rbx)
je 0xd5988
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_hmap_tp_sr.c
// Function: hmap_tp_sr_s_status
static st_s* hmap_tp_sr_s_status( bcore_hmap_tp_sr_s* o )
{
    st_s* string = st_s_create();
    uz_t keys = bcore_hmap_tp_sr_s_keys( o );
    st_s_pushf( string, "keys ........... %zu\n", keys );
    st_s_pushf( string, "nodes .......... %lu\n", o->size );
    st_s_pushf( string, "keys/nodes ..... %5.4f\n", o->size > 0 ? ( f3_t )( keys ) / o->size : 0 );
    return string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
movq 0x18(%r15), %rax
testq %rax, %rax
je 0xd59cd
movq 0x8(%r15), %rcx
xorl %r14d, %r14d
cmpq $0x1, (%rcx)
sbbq $-0x1, %r14
addq $0x20, %rcx
decq %rax
jne 0xd59bc
leaq 0x6fce0(%rip), %rsi     # 0x1456b4
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10a7d0
movq 0x18(%r15), %rdx
leaq 0x6fcde(%rip), %rsi     # 0x1456ca
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
movq 0x18(%r15), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0xd5a49
movq %r14, %xmm1
movq 0x618d0(%rip), %xmm2    # 0x1372e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x618d4(%rip), %xmm3    # 0x1372f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq 0x6fc90(%rip), %rsi     # 0x1456e0
movq %rbx, %rdi
movb $0x1, %al
callq 0x10a7d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_hmap_tp_st.c
// Function: hmap_tp_st_s_status
static st_s* hmap_tp_st_s_status( bcore_hmap_tp_st_s* o )
{
    st_s* string = st_s_create();
    uz_t keys = bcore_hmap_tp_st_s_keys( o );
    st_s_pushf( string, "keys ........... %zu\n", keys );
    st_s_pushf( string, "nodes .......... %lu\n", o->map.size );
    st_s_pushf( string, "keys/nodes ..... %5.4f\n", o->map.size > 0 ? ( f3_t )( keys ) / o->map.size : 0 );
    return string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
leaq 0x8(%r14), %rdi
callq 0xccae6
movq %rax, %r15
leaq 0x6f289(%rip), %rsi     # 0x1456b4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a7d0
movq 0x20(%r14), %rdx
leaq 0x6f287(%rip), %rsi     # 0x1456ca
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a7d0
movq 0x20(%r14), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0xd64a0
movq %r15, %xmm1
movq 0x60e79(%rip), %xmm2    # 0x1372e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x60e7d(%rip), %xmm3    # 0x1372f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq 0x6f239(%rip), %rsi     # 0x1456e0
movq %rbx, %rdi
movb $0x1, %al
callq 0x10a7d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_down
void bcore_life_s_down( struct bcore_life_s* o )
{
    assert( o );

    /// shut down in reverse order
    for( sz_t i = o->size - 1; i >= 0; i-- )
    {
        bcore_life_item_s_down( &o->data[ i ] );
    }

    o->data = bcore_alloc( o->data, 0 );
    o->space = 0;
    o->size = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x20(%rdi), %r15
movq %r15, %rax
decq %rax
js 0xd65f6
leaq (%r15,%r15,2), %rax
leaq -0x8(,%rax,8), %r12
movq 0x18(%rbx), %rcx
movq (%rcx,%r12), %rsi
testq %rsi, %rsi
je 0xd65ea
movq -0x10(%rcx,%r12), %rax
movq -0x8(%rcx,%r12), %rdi
testq %rdi, %rdi
je 0xd65e0
callq *%rax
jmp 0xd65ea
testq %rax, %rax
je 0xd65ea
movq %rsi, %rdi
callq *%rax
decq %r15
addq $-0x18, %r12
testq %r15, %r15
jg 0xd65c0
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xbe7b1
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push_level_item
bcore_life_item_s* bcore_life_s_push_level_item( bcore_life_s* o, sz_t nesting_level )
{
    if( o->nesting_level == nesting_level )
    {
        assert( o );
        if( !o->data )
        {
            o->space = 4;
            o->data = bcore_alloc( NULL, o->space * sizeof( bcore_life_item_s ) );
        }
        else if( o->size == o->space )
        {
            o->space = o->space * 2;
            o->data = bcore_alloc( o->data, o->space * sizeof( bcore_life_item_s ) );
        }
        bcore_life_item_s* r = &o->data[ o->size ];
        o->size++;
        bcore_life_item_s_init( r );
        return r;
    }
    else if( o->parent )
    {
        return bcore_life_s_push_level_item( o->parent, nesting_level );
    }
    else
    {
        ERR_fa( "Found no manager at nesting-level #<sz_t>", nesting_level );
    }
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r8
movq %rdi, %rbx
cmpq %r8, 0x10(%rbx)
je 0xd66f5
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xd66c0
leaq 0x704b5(%rip), %rdi     # 0x146b8b
leaq 0x704cb(%rip), %rsi     # 0x146ba8
leaq 0x704d1(%rip), %rcx     # 0x146bb5
xorl %r14d, %r14d
movl $0x84, %edx
xorl %eax, %eax
callq 0xbe6f9
jmp 0xd6755
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xd671d
movq 0x20(%rbx), %rcx
cmpq 0x28(%rbx), %rcx
jne 0xd6735
leaq (%rcx,%rcx), %rdx
movq %rdx, 0x28(%rbx)
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rsi
movq %rax, %rdi
jmp 0xd672c
movq $0x4, 0x28(%rbx)
movl $0x60, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, 0x18(%rbx)
movq 0x20(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdx
leaq (%rax,%rdx,8), %r14
incq %rcx
movq %rcx, 0x20(%rbx)
movl $0x18, %esi
movq %r14, %rdi
callq 0xbe802
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push
vd_t bcore_life_s_push( bcore_life_s* o, bcore_fp_discard discard, vd_t object )
{
    if( !object ) return NULL;
    bcore_life_item_s* item = bcore_life_s_push_item( o );
    item->down_or_discard = discard;
    item->object  = object;
    return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd6788
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xd66b6
movq %r14, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_spush
vd_t bcore_life_s_spush( bcore_life_s* o, bcore_fp_down down, vd_t object )
{
    if( !object ) return NULL;
    bcore_life_item_s* item = bcore_life_s_push_item( o );
    item->down_or_discard = down;
    item->object  = object;
    return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd67b2
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xd66b6
movq %r14, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push_typed
vd_t bcore_life_s_push_typed( bcore_life_s* o, tp_t type, vd_t object )
{
    if( !object ) return NULL;
    bcore_life_item_s* item = bcore_life_s_push_item( o );
    item->type   = type;
    item->object = object;
    item->typed_down_or_discard = ( bcore_fp_typed_down_or_discard )bcore_inst_t_discard;
    return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd67e7
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xd66b6
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq 0xe(%rip), %rcx         # 0xd67f2
movq %rcx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push_level_typed
vd_t bcore_life_s_push_level_typed( bcore_life_s* o, sz_t level, tp_t type, vd_t object )
{
    if( !object ) return NULL;
    bcore_life_item_s* item = bcore_life_s_push_level_item( o, level );
    item->type   = type;
    item->object = object;
    item->typed_down_or_discard = ( bcore_fp_typed_down_or_discard )bcore_inst_t_discard;
    return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
testq %rcx, %rcx
je 0xd68ce
movq %rdx, %r14
callq 0xd66b6
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq -0xd9(%rip), %rcx       # 0xd67f2
movq %rcx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_spush_typed
vd_t bcore_life_s_spush_typed( bcore_life_s* o, tp_t type, vd_t object )
{
    if( !object ) return NULL;
    bcore_life_item_s* item = bcore_life_s_push_item( o );
    item->type   = type;
    item->object = object;
    item->typed_down_or_discard = ( bcore_fp_typed_down_or_discard )bcore_inst_t_down;
    return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd6903
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xd66b6
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq 0xe(%rip), %rcx         # 0xd690e
movq %rcx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push_sr
sr_s bcore_life_s_push_sr( bcore_life_s* o, sr_s object )
{
    if( sr_s_is_strong( &object ) )
    {
        return sr_pocs( object.p, bcore_life_s_push_typed( o, sr_s_type( &object ), object.o ), sr_s_is_const( &object ), false );
    }
    else
    {
        return object;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq 0x10(%rax), %r14
testb $0x2, %r14b
jne 0xd69e5
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
jmp 0xd6a2f
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xd69f4
movq 0x8(%r15), %r13
jmp 0xd69f7
xorl %r13d, %r13d
movq (%rax), %r12
testq %r12, %r12
je 0xd6a20
movq 0x10(%rsi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd66b6
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
leaq -0x22b(%rip), %rcx      # 0xd67f2
movq %rcx, (%rax)
andl $0x1, %r14d
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push_aware
vd_t bcore_life_s_push_aware( bcore_life_s* o, vd_t object )
{
    if( !object ) return NULL;
    assert( bcore_flect_exists( *( aware_t* )object ) );
    bcore_life_item_s* item = bcore_life_s_push_item( o );
    item->down_or_discard = ( bcore_fp_down_or_discard )bcore_inst_a_discard;
    item->object = object;
    return object;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd6a5c
movq 0x10(%rdi), %rsi
callq 0xd66b6
leaq 0xc(%rip), %rcx         # 0xd6a61
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push_level_aware
vd_t bcore_life_s_push_level_aware( bcore_life_s* o, sz_t level, vd_t object )
{
    if( !object ) return NULL;
    assert( bcore_flect_exists( *( aware_t* )object ) );
    bcore_life_item_s* item = bcore_life_s_push_level_item( o, level );
    item->down_or_discard = ( bcore_fp_down_or_discard )bcore_inst_a_discard;
    item->object = object;
    return object;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd6b33
callq 0xd66b6
leaq -0xcb(%rip), %rcx       # 0xd6a61
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_spush_aware
vd_t bcore_life_s_spush_aware( bcore_life_s* o, vd_t object )
{
    if( !object ) return NULL;
    assert( bcore_flect_exists( *( aware_t* )object ) );
    bcore_life_item_s* item = bcore_life_s_push_item( o );
    item->down_or_discard = ( bcore_fp_down_or_discard )bcore_inst_a_down;
    item->object  = object;
    return object;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd6b58
movq 0x10(%rdi), %rsi
callq 0xd66b6
leaq 0xc(%rip), %rcx         # 0xd6b5d
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_push_free
vd_t bcore_life_s_push_free( bcore_life_s* o, vd_t object )
{
    if( !object ) return NULL;
    bcore_life_item_s* item = bcore_life_s_push_item( o );
    item->down_or_discard = ( bcore_fp_down_or_discard )bcore_free;
    item->object  = object;
    return object;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd6c29
movq 0x10(%rdi), %rsi
callq 0xd66b6
leaq -0x1847f(%rip), %rcx    # 0xbe7a3
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_down_all
void bcore_life_s_down_all( bcore_life_s* o )
{
    if( !o ) return;
    bcore_life_s* parent = o->parent;
    bcore_life_s_down( o );
    bcore_life_s_down_all( parent );
}

// Assembly:
testq %rdi, %rdi
je 0xd6d44
pushq %rbx
movq 0x8(%rdi), %rbx
callq 0xd6599
movq %rbx, %rdi
testq %rbx, %rbx
jne 0xd6d32
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_down_level
void bcore_life_s_down_level( bcore_life_s* o, sz_t nesting_level )
{
    if( !o ) return;
    if( o->nesting_level < nesting_level ) return;
    bcore_life_s* parent = o->parent;
    bcore_life_s_down( o );
    bcore_life_s_down_level( parent, nesting_level );
}

// Assembly:
testq %rdi, %rdi
je 0xd6d6f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq %rbx, 0x10(%rdi)
jl 0xd6d68
movq 0x8(%rdi), %r14
callq 0xd6599
movq %r14, %rdi
testq %r14, %r14
jne 0xd6d51
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: bcore_life_s_discard_all
void bcore_life_s_discard_all( bcore_life_s* o )
{
    if( !o ) return;
    bcore_life_s* parent = o->parent;
    bcore_life_s_discard( o );
    bcore_life_s_discard_all( parent );
}

// Assembly:
testq %rdi, %rdi
je 0xd6d9e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rsi
leaq -0x7ea(%rip), %rbx      # 0xd6599
movq 0x8(%rsi), %r14
movq %rbx, %rdi
callq 0xbe7ee
movq %r14, %rsi
testq %r14, %r14
jne 0xd6d83
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_life.c
// Function: life_s_create_self
static bcore_self_s* life_s_create_self( void )
{
    sc_t sc_def =
    "bcore_life_s = bcore_inst"
    "{"
        "aware_t _;"
        "private vd_t parent;"
        "private sz_t nesting_level;"
        "private vd_t data;"
        "private uz_t size;"
        "private uz_t space;"
    "}";

    bcore_self_s* self = bcore_self_s_build_parse_sc( sc_def, sizeof( bcore_life_s ), alignof( bcore_life_s ) );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_life_s_init, "bcore_fp_init",  "init" );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_life_s_down, "bcore_fp_down",  "down" );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x6fdff(%rip), %rdi     # 0x146bdf
movl $0x30, %esi
movl $0x8, %edx
callq 0xc447e
movq %rax, %rbx
leaq -0x87d(%rip), %rsi      # 0xd657c
leaq 0x6bc35(%rip), %rdx     # 0x142a35
leaq 0x6bc37(%rip), %rcx     # 0x142a3e
movq %rax, %rdi
callq 0xc34ab
leaq -0x87d(%rip), %rsi      # 0xd6599
leaq 0x6bc26(%rip), %rdx     # 0x142a43
leaq 0x603a6(%rip), %rcx     # 0x1371ca
movq %rbx, %rdi
callq 0xc34ab
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: cat_name_ns_n
st_s* cat_name_ns_n( tp_t name_space, sc_t name, uz_t n )
{
    st_s* cat_name = st_s_create();
    if( name_space )
    {
        st_s_push_st_d( cat_name, bifnameof_s( name_space ) );
        st_s_push_char( cat_name, ':' );
    }
    st_s_push_sc_n( cat_name, name, n );
    return cat_name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %eax, %eax
callq 0x109c82
movq %rax, %r15
testq %r12, %r12
je 0xd6e80
movq %r12, %rdi
callq 0xd6f4c
testq %rax, %rax
jne 0xd6e68
xorl %eax, %eax
callq 0x109c82
movq %r15, %rdi
movq %rax, %rsi
callq 0x10a641
movq %r15, %rdi
movl $0x3a, %esi
callq 0x10a448
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10a66f
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_try_name
sc_t bcore_name_try_name( tp_t type )
{
    assert( hmap_s_g != NULL );
    bcore_mutex_s_lock( &hmap_s_g->mutex );
    bcore_name_s* name = bcore_name_map_s_get( &hmap_s_g->map, type );
    bcore_mutex_s_unlock( &hmap_s_g->mutex );
    return name ? name->name : NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xc4f09(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142c9
movq 0xc4ef9(%rip), %rdi     # 0x19bdd8
movq %rbx, %rsi
callq 0x12bb6f
movq %rax, %rbx
movq 0xc4ee7(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142fb
testq %rbx, %rbx
je 0xd6f05
movq 0x10(%rbx), %rax
jmp 0xd6f07
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_try_name_s
st_s* bcore_name_try_name_s( tp_t type )
{
    assert( hmap_s_g != NULL );
    bcore_mutex_s_lock( &hmap_s_g->mutex );
    bcore_name_s* name = bcore_name_map_s_get( &hmap_s_g->map, type );
    bcore_mutex_s_unlock( &hmap_s_g->mutex );

    if( name )
    {
        return cat_name_ns( name->name_space, name->name );
    }
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc4e7e(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142c9
movq 0xc4e6e(%rip), %rdi     # 0x19bdd8
movq %rbx, %rsi
callq 0x12bb6f
movq %rax, %rbx
movq 0xc4e5c(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142fb
testq %rbx, %rbx
je 0xd6faf
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rbx
movq %rbx, %rdi
callq 0xbe963
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd6e34
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: btypeof_fv
tp_t btypeof_fv( sc_t format, va_list args )
{
    st_s* s = st_s_create_fv( format, args );
    tp_t tp = btypeof( s->sc );
    st_s_discard( s );
    return tp;
}

// Assembly:
pushq %rbx
callq 0x109d97
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xd74d6
movabsq $-0x340d631b7bdddcdb, %rdi # imm = 0xCBF29CE484222325
movb (%rcx), %sil
testb %sil, %sil
je 0xd74e2
incq %rcx
movabsq $0x100000001b3, %rdx    # imm = 0x100000001B3
movzbl %sil, %ebx
xorq %rdi, %rbx
imulq %rdx, %rbx
movb (%rcx), %sil
incq %rcx
movq %rbx, %rdi
testb %sil, %sil
jne 0xd74bb
jmp 0xd74e5
movabsq $-0x509c42b379fe4821, %rbx # imm = 0xAF63BD4C8601B7DF
jmp 0xd74e5
movq %rdi, %rbx
movq %rax, %rdi
callq 0x10a028
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bentypeof_fv
tp_t bentypeof_fv( sc_t format, va_list args )
{
    st_s* s = st_s_create_fv( format, args );
    tp_t tp = bentypeof( s->sc );
    st_s_discard( s );
    return tp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x109d97
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r14, %rdi
callq 0xbe963
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd7215
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a028
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_push_all
void bcore_name_push_all( bcore_hmap_name_s* name_map )
{
    assert( hmap_s_g != NULL );
    bcore_mutex_s_lock( &hmap_s_g->mutex );
    for( uz_t i = 0; i < hmap_s_g->map.size; i++ )
    {
        const bcore_name_s* name = &hmap_s_g->map.data[ i ];
        if( name->key ) bcore_hmap_name_s_set_sc( name_map, name->name );
    }
    bcore_mutex_s_unlock( &hmap_s_g->mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc4758(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142c9
movq 0xc4748(%rip), %rdi     # 0x19bdd8
cmpq $0x0, 0x18(%rdi)
je 0xd76cc
movl $0x10, %r14d
xorl %r15d, %r15d
movq 0x8(%rdi), %rax
cmpq $0x0, -0x10(%rax,%r14)
je 0xd76bf
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq 0xd3d8e
movq 0xc4719(%rip), %rdi     # 0x19bdd8
incq %r15
addq $0x18, %r14
cmpq 0x18(%rdi), %r15
jb 0xd76a0
addq $0x30, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1142fb
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_size
sz_t  bcore_name_size()
{
    assert( hmap_s_g != NULL );
    bcore_mutex_s_lock( &hmap_s_g->mutex );
    sz_t size = bcore_name_map_s_keys( &hmap_s_g->map );
    bcore_mutex_s_unlock( &hmap_s_g->mutex );
    return size;
}

// Assembly:
pushq %rbx
movq 0xc46f6(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142c9
movq 0xc46e6(%rip), %rdi     # 0x19bdd8
callq 0x12bbca
movq %rax, %rbx
movq 0xc46d7(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142fb
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_show
st_s* bcore_name_show()
{
    assert( hmap_s_g != NULL );
    bcore_mutex_s_lock( &hmap_s_g->mutex );
    st_s* log = st_s_create();
    uz_t size = bcore_name_map_s_size( &hmap_s_g->map );
    for( uz_t i = 0; i < size; i++ )
    {
        bcore_name_s* node = bcore_name_map_s_idx_name( &hmap_s_g->map, i );
        if( node->key )
        {
            bcore_mutex_s_unlock( &hmap_s_g->mutex );
            st_s_push_st_d( log, cat_name_ns( node->name_space, node->name ) );
            bcore_mutex_s_lock( &hmap_s_g->mutex );
            st_s_push_char( log, '\n' );
        }
    }
    bcore_mutex_s_unlock( &hmap_s_g->mutex );
    return log;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0xc46b9(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142c9
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
movq 0xc469f(%rip), %rdi     # 0x19bdd8
callq 0x12bbee
testq %rax, %rax
je 0xd77c1
movq %rax, %r14
xorl %r15d, %r15d
movq 0xc4688(%rip), %rdi     # 0x19bdd8
movq %r15, %rsi
callq 0x12bbf3
cmpq $0x0, (%rax)
je 0xd77b9
movq %rax, %r12
movq 0xc4670(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142fb
movq 0x8(%r12), %r13
movq 0x10(%r12), %r12
movq %r12, %rdi
callq 0xbe963
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xd6e34
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a641
movq 0xc4635(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142c9
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10a448
incq %r15
cmpq %r15, %r14
jne 0xd7749
movq 0xc4610(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142fb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_create_name_map
bcore_name_map_s* bcore_name_create_name_map()
{
    assert( hmap_s_g != NULL );
    bcore_mutex_s_lock( &hmap_s_g->mutex );
    bcore_name_map_s* ret = bcore_name_map_s_clone( &hmap_s_g->map );
    bcore_mutex_s_unlock( &hmap_s_g->mutex );
    return ret;
}

// Assembly:
pushq %rbx
movq 0xc45f2(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142c9
movq 0xc45e2(%rip), %rdi     # 0x19bdd8
callq 0x12b68b
movq %rax, %rbx
movq 0xc45d3(%rip), %rdi     # 0x19bdd8
addq $0x30, %rdi
callq 0x1142fb
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_manager_selftest
st_s* bcore_name_manager_selftest()
{
    tp_t mynamespace_t = bentypeof( "mynamespace" );
    tp_t myname_t = bentypeof_ns( mynamespace_t, "myname" );
    ASSERT( myname_t == btypeof( "mynamespace:myname" ) );
    st_s* cname = bnameof_s( myname_t );
    ASSERT( st_s_cmp_sc( cname, "mynamespace:myname" ) == 0 );
    st_s_discard( cname );
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6f5a9(%rip), %rbx     # 0x146dc7
movq %rbx, %rdi
callq 0xbe963
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xd7215
movq %rax, %rbx
leaq 0x6f5a2(%rip), %r14     # 0x146ddf
movq %r14, %rdi
callq 0xbe963
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd7215
movq %rax, %rbx
movabsq $0x7fc61ea4d6493b7d, %rax # imm = 0x7FC61EA4D6493B7D
cmpq %rax, %rbx
je 0xd788e
leaq 0x55ddb(%rip), %rdi     # 0x12d647
leaq 0x6f573(%rip), %rsi     # 0x146de6
leaq 0x6f598(%rip), %rdx     # 0x146e12
leaq 0x6f3fe(%rip), %rcx     # 0x146c7f
movl $0x186, %r8d            # imm = 0x186
xorl %eax, %eax
callq 0xbe4ef
movq %rbx, %rdi
callq 0xd6f4c
movq %rax, %rbx
testq %rax, %rax
je 0xd78a4
movq 0x8(%rbx), %rdi
jmp 0xd78a6
xorl %edi, %edi
leaq 0x6f526(%rip), %rsi     # 0x146dd3
callq 0xbe959
testl %eax, %eax
je 0xd78df
leaq 0x55d8a(%rip), %rdi     # 0x12d647
leaq 0x6f56a(%rip), %rsi     # 0x146e2e
leaq 0x6f547(%rip), %rdx     # 0x146e12
leaq 0x6f3ad(%rip), %rcx     # 0x146c7f
movl $0x188, %r8d            # imm = 0x188
xorl %eax, %eax
callq 0xbe4ef
movq %rbx, %rdi
callq 0x10a028
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: bcore_name_manager_signal_handler
vd_t bcore_name_manager_signal_handler( const bcore_signal_s* o )
{
    switch( bcore_signal_s_handle_type( o, btypeof( "bcore_name_manager" ) ) )
    {
        case TYPEOF_init0:
        {
            name_manager_open();
        }
        break;

        case TYPEOF_init1:
        {
        }
        break;

        case TYPEOF_down0:
        {
            // bcore_tbman_instance_disgnostics();

            s2_t verbosity = o->object ? *( s2_t* )o->object : 0;
            if( verbosity > 0 )
            {
                uz_t count = bcore_name_size(); // number of registered names
                uz_t space = bcore_tbman_total_granted_space();
                name_manager_close();
                space -= bcore_tbman_total_granted_space();
                bcore_msg( "  name mananger ....... % 7zu (by % 4zu names        )\n", space, count );
            }
            else
            {
                name_manager_close();
            }
        }
        break;

        case TYPEOF_selftest:
        {
            return bcore_name_manager_selftest();
        }
        break;

        default: break;
    }

    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x1d061dcf2f3eb2c, %rsi # imm = 0x1D061DCF2F3EB2C
callq 0xdfce3
movabsq $-0x69a05554ee793861, %rcx # imm = 0x965FAAAB1186C79F
cmpq %rcx, %rax
je 0xd795a
movabsq $0x7ee758bbfced33e3, %rcx # imm = 0x7EE758BBFCED33E3
cmpq %rcx, %rax
je 0xd7950
movabsq $0x6a72cf8f8250f179, %rcx # imm = 0x6A72CF8F8250F179
cmpq %rcx, %rax
jne 0xd79dc
leaq 0xc44a1(%rip), %rdi     # 0x19bde0
leaq 0xa0(%rip), %rsi        # 0xd79e6
callq 0x11465b
jmp 0xd79dc
callq 0xd7813
jmp 0xd79dc
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xd79b9
cmpl $0x0, (%rax)
jle 0xd79b9
callq 0xd76da
movq %rax, %rbx
callq 0x111248
movq %rax, %r14
movq 0xc4459(%rip), %rsi     # 0x19bdd8
testq %rsi, %rsi
je 0xd799b
leaq 0x92(%rip), %rdi        # 0xd7a1d
callq 0xbe7ee
movq $0x0, 0xc443d(%rip) # 0x19bdd8
callq 0x111248
subq %rax, %r14
leaq 0x6f4b4(%rip), %rdi     # 0x146e5e
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xbe2ad
jmp 0xd79dc
movq 0xc4418(%rip), %rsi     # 0x19bdd8
testq %rsi, %rsi
je 0xd79dc
leaq 0x51(%rip), %rdi        # 0xd7a1d
callq 0xbe7ee
movq $0x0, 0xc43fc(%rip) # 0x19bdd8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name_manager.c
// Function: hmap_s_down
static void hmap_s_down( hmap_s* o )
{
    bcore_mutex_s_lock( &o->mutex );
    bcore_name_map_s_down( &o->map );
    bcore_mutex_s_unlock( &o->mutex );
    bcore_mutex_s_down( &o->mutex );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0x1142c9
movq %rbx, %rdi
callq 0x12b5c8
movq %r14, %rdi
callq 0x1142fb
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1141a2
nop
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_quicktypes.c
// Function: get_def_quicktype
static st_s* get_def_quicktype( hf hash, sr_s string, uz_t align )
{
    sc_t name = ( ( st_s* )string.o )->sc;
    st_s* s = st_s_createf( "#define TYPEOF_%s", name );
    uz_t pad = s->size < align ? align - s->size : 1;
    st_s_push_char_n( s, ' ', pad );
    st_s_pushf( s, "0x%016"PRIXtp_t"ull", hash( name ) );
    st_s_push_char( s, '\n' );
    sr_down( string );
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rsp), %rax
movq 0x8(%rax), %r12
leaq 0x6cd53(%rip), %rdi     # 0x146ecc
movq %r12, %rsi
xorl %eax, %eax
callq 0x109ce5
movq %rax, %rbx
subq 0x10(%rax), %r14
movl $0x1, %edx
cmovaq %r14, %rdx
movq %rax, %rdi
movl $0x20, %esi
callq 0x10a4d1
movq %r12, %rdi
callq *%r15
leaq 0x6cd31(%rip), %rsi     # 0x146ede
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a7d0
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10a448
testb $0x2, 0x50(%rsp)
je 0xda1e8
leaq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_quicktypes.c
// Function: max_len
static uz_t max_len( const sr_s* list )
{
    uz_t len = 0;
    for( uz_t i = 0; i < bcore_array_r_get_size( list ); i++ )
    {
        uz_t size = ( ( st_s* )bcore_array_r_get( list, i ).o )->size;
        len = size > len ? size : len;
    }
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xc1c0e(%rip), %r13     # 0x19be20
xorl %ebp, %ebp
movq 0x8(%rbx), %r14
movq 0x8(%r14), %r12
movabsq $-0x5073d588c3beb52e, %rax # imm = 0xAF8C2A773C414AD2
cmpq %rax, %r12
je 0xda2b2
movl (%r13), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%r13,%rax,8), %rcx
movq 0x18(%r13,%rax,8), %rdx
andq %r12, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xda286
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xda286
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xda286
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xda28f
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0xda2b2
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq (%rbx), %rsi
movq %r14, %rdi
callq 0xede4d
cmpq %rax, %r15
jae 0xda38c
movq 0x8(%rbx), %r14
movq 0x8(%r14), %r12
movabsq $-0x5073d588c3beb52e, %rax # imm = 0xAF8C2A773C414AD2
cmpq %rax, %r12
je 0xda364
movl (%r13), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%r13,%rax,8), %rcx
movq 0x18(%r13,%rax,8), %rdx
andq %r12, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xda338
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xda338
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xda338
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xda341
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0xda364
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq (%rbx), %rdx
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xede75
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq %rbp, %rax
cmovaq %rax, %rbp
incq %r15
jmp 0xda214
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_quicktypes.c
// Function: bcore_type_is_leaf
bl_t bcore_type_is_leaf( tp_t type )
{
    switch( type )
    {
        case TYPEOF_s3_t:
        case TYPEOF_s2_t:
        case TYPEOF_s1_t:
        case TYPEOF_s0_t:
        case TYPEOF_u3_t:
        case TYPEOF_u2_t:
        case TYPEOF_u1_t:
        case TYPEOF_u0_t:
        case TYPEOF_f3_t:
        case TYPEOF_f2_t:
        case TYPEOF_sz_t:
        case TYPEOF_uz_t:
        case TYPEOF_sd_t:
        case TYPEOF_sc_t:
        case TYPEOF_vd_t:
        case TYPEOF_vc_t:
        case TYPEOF_fp_t:
        case TYPEOF_tp_t:
        case TYPEOF_bl_t:
        case TYPEOF_aware_t:
            return true;
        default:
            return false;
    }
}

// Assembly:
movb $0x1, %al
movabsq $-0x84b14e74a9e1ff1, %rcx # imm = 0xF7B4EB18B561E00F
cmpq %rcx, %rdi
jg 0xda40a
movabsq $-0x58737885f0577327, %rcx # imm = 0xA78C877A0FA88CD9
cmpq %rcx, %rdi
jg 0xda465
movabsq $-0x6119581ac7eacd64, %rcx # imm = 0x9EE6A7E53815329C
cmpq %rcx, %rdi
jle 0xda4ea
movabsq $-0x6119581ac7eacd63, %rcx # imm = 0x9EE6A7E53815329D
cmpq %rcx, %rdi
je 0xda559
movabsq $-0x5fc2af85f419929b, %rcx # imm = 0xA03D507A0BE66D65
cmpq %rcx, %rdi
je 0xda559
movabsq $-0x5aa4411ac4e2880e, %rcx # imm = 0xA55BBEE53B1D77F2
jmp 0xda554
movabsq $0x62367a17d02b474c, %rcx # imm = 0x62367A17D02B474C
cmpq %rcx, %rdi
jg 0xda4ad
movabsq $0x510c2417c67dabea, %rcx # imm = 0x510C2417C67DABEA
cmpq %rcx, %rdi
jle 0xda505
movabsq $0x510c2417c67dabeb, %rcx # imm = 0x510C2417C67DABEB
cmpq %rcx, %rdi
je 0xda559
movabsq $0x54de8100f7c1cbe5, %rcx # imm = 0x54DE8100F7C1CBE5
cmpq %rcx, %rdi
je 0xda559
movabsq $0x585a3b17ca3de200, %rcx # imm = 0x585A3B17CA3DE200
jmp 0xda554
movabsq $-0x3f1363e6d8155aee, %rcx # imm = 0xC0EC9C1927EAA512
cmpq %rcx, %rdi
jle 0xda520
movabsq $-0x3f1363e6d8155aed, %rcx # imm = 0xC0EC9C1927EAA513
cmpq %rcx, %rdi
je 0xda559
movabsq $-0x3ac242643d9c35a8, %rcx # imm = 0xC53DBD9BC263CA58
cmpq %rcx, %rdi
je 0xda559
movabsq $-0x388c46b188de83fe, %rcx # imm = 0xC773B94E77217C02
jmp 0xda554
movabsq $0x6d07f9ef5b68e8a1, %rcx # imm = 0x6D07F9EF5B68E8A1
cmpq %rcx, %rdi
jle 0xda53b
movabsq $0x6d07f9ef5b68e8a2, %rcx # imm = 0x6D07F9EF5B68E8A2
cmpq %rcx, %rdi
je 0xda559
movabsq $0x6db6f178cd6db4b8, %rcx # imm = 0x6DB6F178CD6DB4B8
cmpq %rcx, %rdi
je 0xda559
movabsq $0x6f0b060106a30da4, %rcx # imm = 0x6F0B060106A30DA4
jmp 0xda554
movabsq $-0x73f6ae1ad309fd45, %rcx # imm = 0x8C0951E52CF602BB
cmpq %rcx, %rdi
je 0xda559
movabsq $-0x6bce971ace902370, %rcx # imm = 0x943168E5316FDC90
jmp 0xda554
movabsq $-0x84b14e74a9e1ff0, %rcx # imm = 0xF7B4EB18B561E010
cmpq %rcx, %rdi
je 0xda559
movabsq $0x230abe18cdeefc99, %rcx # imm = 0x230ABE18CDEEFC99
jmp 0xda554
movabsq $-0x58737885f0577326, %rcx # imm = 0xA78C877A0FA88CDA
cmpq %rcx, %rdi
je 0xda559
movabsq $-0x4882601bdca6aefb, %rcx # imm = 0xB77D9FE423595105
jmp 0xda554
movabsq $0x62367a17d02b474d, %rcx # imm = 0x62367A17D02B474D
cmpq %rcx, %rdi
je 0xda559
movabsq $0x69849117d3eb7d62, %rcx # imm = 0x69849117D3EB7D62
cmpq %rcx, %rdi
jne 0xda55a
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_scan_type
s2_t sc_t_scan_type( sc_t format, tp_t* p_type, bl_t* p_is_ptr )
{
    sc_t fp = format;
    if( fp[ 0 ] == 0 ) return -1;
    tp_t type = 0;
    if( fp[ 0 ] == '<' )
    {
        fp++;
        sc_t fp0 = fp;
        while( *fp != 0 && *fp != '>' ) fp++;
        if( *fp != '>' ) return -1;
        sc_t fp1 = fp++;
        if( fp1[ -1 ] == '*' )
        {
            fp1--;
            if( p_is_ptr ) *p_is_ptr = true;
        }
        else
        {
            if( p_is_ptr ) *p_is_ptr = false;
        }
        type = btypeof_n( fp0, fp1 - fp0 );
    }
    else if( fp[ 1 ] != 0 && fp[ 2 ] == '_' && fp[ 3 ] == 't' ) // all types of format xy_t
    {
        type = btypeof_n( fp, 4 );
        fp += 4;
    }
    else
    {
        return -1;
    }
    if( p_type ) *p_type = type;
    return fp - format;
}

// Assembly:
movzbl (%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0xddfbb
cmpl $0x3c, %ecx
jne 0xddf10
leaq 0x1(%rdi), %r9
movq %r9, %rcx
movzbl (%rcx), %r8d
testl %r8d, %r8d
je 0xddfbb
cmpl $0x3e, %r8d
je 0xddf5f
incq %rcx
jmp 0xddef8
cmpb $0x0, 0x1(%rdi)
je 0xddfbb
cmpb $0x5f, 0x2(%rdi)
jne 0xddfbb
cmpb $0x74, 0x3(%rdi)
jne 0xddfbb
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
xorl %edx, %edx
movzbl (%rdi,%rdx), %r8d
xorq %r8, %rax
imulq %rcx, %rax
incq %rdx
cmpq $0x4, %rdx
jne 0xddf44
leaq 0x4(%rdi), %rcx
jmp 0xddfaf
leaq -0x1(%rcx), %r8
movb -0x1(%rcx), %al
cmpb $0x2a, %al
cmovneq %rcx, %r8
testq %rdx, %rdx
je 0xddf76
cmpb $0x2a, %al
sete (%rdx)
incq %rcx
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
cmpq %r9, %r8
je 0xddfaf
movabsq $0x100000001b3, %rdx    # imm = 0x100000001B3
subq %rdi, %r8
movl $0x1, %r9d
movzbl (%rdi,%r9), %r10d
xorq %r10, %rax
imulq %rdx, %rax
incq %r9
cmpq %r9, %r8
jne 0xddf9b
testq %rsi, %rsi
je 0xddfb7
movq %rax, (%rsi)
subl %edi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_cpy
sd_t sc_t_cpy( sd_t dst, sc_t src )
{
    if( !dst && !src ) return NULL;
    uz_t len = src ? strlen( src ) : 0;
    dst = bcore_alloc( dst, len + 1 );
    bcore_memcpy( dst, src, len );
    dst[ len ] = 0;
    return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0xdfa01
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xdfa06
movq %rbx, %rdi
callq 0xd230
movq %rax, %r15
jmp 0xdfa09
xorl %r14d, %r14d
jmp 0xdfa2b
xorl %r15d, %r15d
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xbe7b1
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xbe87d
movb $0x0, (%r14,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_cmp
s2_t sc_t_cmp( sc_t str1, sc_t str2 )
{
    if( str1 == NULL ) return ( str2 == NULL ) ? 0 :  1;
    if( str2 == NULL ) return -1;
    while( ( *str1 != 0 ) && ( *str2 != 0 ) )
    {
        if( *str1 != *str2 ) return ( *str1 < *str2 ) ? 2 : -2;
        str1++;
        str2++;
    }
    return ( *str1 == 0 ) ? ( ( *str2 == 0 ) ? 0 : +1 ) : -1;
}

// Assembly:
testq %rdi, %rdi
je 0xdfa69
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0xdfa71
movb (%rdi), %cl
testb %cl, %cl
je 0xdfa62
incq %rdi
movb (%rsi), %dl
testb %dl, %dl
je 0xdfa71
cmpb %dl, %cl
jne 0xdfa72
incq %rsi
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xdfa4c
xorl %eax, %eax
cmpb $0x0, (%rsi)
jmp 0xdfa6e
xorl %eax, %eax
testq %rsi, %rsi
setne %al
retq
setl %al
movzbl %al, %eax
leal -0x2(,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_cmp_n
s2_t sc_t_cmp_n( sc_t str1, uz_t n1, sc_t str2, uz_t n2 )
{
    if( str1 == NULL ) return ( str2 == NULL ) ? 0 :  1;
    if( str2 == NULL ) return -1;
    if( n1 == 0 ) return ( n2 == 0 ) ? 0 :  1;
    if( n2 == 0 ) return -1;
    uz_t i1 = 0;
    uz_t i2 = 0;
    while( ( i1 < n1 ) && ( i2 < n2 ) )
    {
        if( str1[ i1 ] != str2[ i2 ] ) return ( str1[ i1 ] < str2[ i2 ] ) ? 2 : -2;
        i1++;
        i2++;
    }
    return ( i1 == n1 ) ? ( ( i2 == n2 ) ? 0 : +1 ) : -1;
}

// Assembly:
testq %rdi, %rdi
je 0xdfad4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0xdfad3
testq %rsi, %rsi
je 0xdfadb
testq %rcx, %rcx
je 0xdfad3
leaq -0x1(%rcx), %r8
leaq -0x1(%rsi), %rax
cmpq %rax, %r8
cmovbq %r8, %rax
incq %rax
xorl %r8d, %r8d
movb (%rdx,%r8), %r9b
cmpb %r9b, (%rdi,%r8)
jne 0xdfae4
incq %r8
cmpq %r8, %rax
jne 0xdfaae
xorl %edx, %edx
cmpq %rcx, %rax
setne %dl
cmpq %rsi, %rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %edx, %eax
retq
xorl %eax, %eax
testq %rdx, %rdx
jmp 0xdfae0
xorl %eax, %eax
testq %rcx, %rcx
setne %al
retq
setl %al
movzbl %al, %eax
leal -0x2(,%rax,4), %eax
retq