LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x114bbb
movq %rax, %rbx
movq 0x18(%r15), %rax
testq %rax, %rax
je 0xdf763
movq 0x8(%r15), %rcx
xorl %r14d, %r14d
cmpq $0x1, (%rcx)
sbbq $-0x1, %r14
addq $0x20, %rcx
decq %rax
jne 0xdf752
leaq 0x70f24(%rip), %rsi     # 0x15068e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1156f6
movq 0x18(%r15), %rdx
leaq 0x70f22(%rip), %rsi     # 0x1506a4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
movq 0x18(%r15), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0xdf7df
movq %r14, %xmm1
movq 0x62aea(%rip), %xmm2    # 0x142290
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x62aee(%rip), %xmm3    # 0x1422a0
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 0x70ed4(%rip), %rsi     # 0x1506ba
movq %rbx, %rdi
movb $0x1, %al
callq 0x1156f6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x114bbb
movq %rax, %rbx
leaq 0x8(%r14), %rdi
callq 0xd69cb
movq %rax, %r15
leaq 0x704a7(%rip), %rsi     # 0x15068e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1156f6
movq 0x20(%r14), %rdx
leaq 0x704a5(%rip), %rsi     # 0x1506a4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1156f6
movq 0x20(%r14), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0xe025c
movq %r15, %xmm1
movq 0x6206d(%rip), %xmm2    # 0x142290
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x62071(%rip), %xmm3    # 0x1422a0
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 0x70457(%rip), %rsi     # 0x1506ba
movq %rbx, %rdi
movb $0x1, %al
callq 0x1156f6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xe03b2
leaq (%r15,%r15,2), %rax
leaq -0x8(,%rax,8), %r12
movq 0x18(%rbx), %rcx
movq (%rcx,%r12), %rsi
testq %rsi, %rsi
je 0xe03a6
movq -0x10(%rcx,%r12), %rax
movq -0x8(%rcx,%r12), %rdi
testq %rdi, %rdi
je 0xe039c
callq *%rax
jmp 0xe03a6
testq %rax, %rax
je 0xe03a6
movq %rsi, %rdi
callq *%rax
decq %r15
addq $-0x18, %r12
testq %r15, %r15
jg 0xe037c
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xc8315
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_O1/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 0xe04b1
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xe047c
leaq 0x716d3(%rip), %rdi     # 0x151b65
leaq 0x716e9(%rip), %rsi     # 0x151b82
leaq 0x716ef(%rip), %rcx     # 0x151b8f
xorl %r14d, %r14d
movl $0x84, %edx
xorl %eax, %eax
callq 0xc825d
jmp 0xe0512
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xe04d6
movq 0x28(%rbx), %rax
cmpq %rax, 0x20(%rbx)
jne 0xe04ee
leaq (%rax,%rax), %rcx
movq %rcx, 0x28(%rbx)
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
jmp 0xe04e5
movq $0x4, 0x28(%rbx)
movl $0x60, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, 0x18(%rbx)
movq 0x20(%rbx), %rax
leaq (%rax,%rax,2), %r14
shlq $0x3, %r14
addq 0x18(%rbx), %r14
incq %rax
movq %rax, 0x20(%rbx)
movl $0x18, %esi
movq %r14, %rdi
callq 0xc8366
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdx, %rdx
je 0xe0547
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xe0472
movq %r14, (%rax)
movq %rbx, 0x10(%rax)
jmp 0xe0549
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdx, %rdx
je 0xe0575
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xe0472
movq %r14, (%rax)
movq %rbx, 0x10(%rax)
jmp 0xe0577
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdx, %rdx
je 0xe05ae
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xe0472
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq 0x12(%rip), %rcx        # 0xe05bb
movq %rcx, (%rax)
jmp 0xe05b0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rcx, %rcx
je 0xe069e
movq %rcx, %rbx
movq %rdx, %r14
callq 0xe0472
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq -0xde(%rip), %rcx       # 0xe05bb
movq %rcx, (%rax)
jmp 0xe06a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdx, %rdx
je 0xe06d7
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rsi
callq 0xe0472
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq 0x12(%rip), %rcx        # 0xe06e4
movq %rcx, (%rax)
jmp 0xe06d9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe07c0
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
jmp 0xe080f
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xe07cf
movq 0x8(%r15), %r13
jmp 0xe07d2
xorl %r13d, %r13d
movq (%rax), %r12
testq %r12, %r12
je 0xe07fd
movq 0x10(%rsi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xe0472
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
leaq -0x23d(%rip), %rcx      # 0xe05bb
movq %rcx, (%rax)
jmp 0xe0800
xorl %r12d, %r12d
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_O1/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
testq %rsi, %rsi
je 0xe083e
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
callq 0xe0472
leaq 0x10(%rip), %rcx        # 0xe0845
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
jmp 0xe0840
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdx, %rdx
je 0xe091e
movq %rdx, %rbx
callq 0xe0472
leaq -0xd0(%rip), %rcx       # 0xe0845
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
jmp 0xe0920
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rsi, %rsi
je 0xe0947
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
callq 0xe0472
leaq 0x10(%rip), %rcx        # 0xe094e
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
jmp 0xe0949
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rsi, %rsi
je 0xe0a21
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
callq 0xe0472
leaq -0x18711(%rip), %rcx    # 0xc8307
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
jmp 0xe0a23
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
testq %rdi, %rdi
je 0xe0b44
movq 0x8(%rdi), %rbx
callq 0xe0355
movq %rbx, %rdi
jmp 0xe0b31
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0xe0b66
cmpq %rbx, 0x10(%rdi)
jl 0xe0b66
movq 0x8(%rdi), %r14
callq 0xe0355
movq %r14, %rdi
jmp 0xe0b4d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rsi
leaq -0x827(%rip), %rbx      # 0xe0355
testq %rsi, %rsi
je 0xe0b92
movq 0x8(%rsi), %r14
movq %rbx, %rdi
callq 0xc8352
movq %r14, %rsi
jmp 0xe0b7c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x70fde(%rip), %rdi     # 0x151bb9
movl $0x30, %esi
movl $0x8, %edx
callq 0xce5c6
movq %rax, %rbx
leaq -0x8bc(%rip), %rsi      # 0xe0338
leaq 0x6cdfa(%rip), %rdx     # 0x14d9f5
leaq 0x6cdfc(%rip), %rcx     # 0x14d9fe
movq %rax, %rdi
callq 0xcd5ad
leaq -0x8bc(%rip), %rsi      # 0xe0355
leaq 0x6cdeb(%rip), %rdx     # 0x14da03
leaq 0x615ab(%rip), %rcx     # 0x1421ca
movq %rbx, %rdi
callq 0xcd5ad
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x114bbb
movq %rax, %r15
testq %r12, %r12
je 0xe0c78
movq %r12, %rdi
callq 0xe0d44
testq %rax, %rax
jne 0xe0c60
xorl %eax, %eax
callq 0x114bbb
movq %r15, %rdi
movq %rax, %rsi
callq 0x11556c
movq %r15, %rdi
movl $0x3a, %esi
callq 0x115381
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11559a
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0xc8111(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f515
movq 0xc8101(%rip), %rdi     # 0x1a8dd8
movq %rbx, %rsi
callq 0x1370e2
movq %rax, %rbx
movq 0xc80ef(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f547
testq %rbx, %rbx
je 0xe0cfd
movq 0x10(%rbx), %rax
jmp 0xe0cff
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc8086(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f515
movq 0xc8076(%rip), %rdi     # 0x1a8dd8
movq %rbx, %rsi
callq 0x1370e2
movq %rax, %rbx
movq 0xc8064(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f547
testq %rbx, %rbx
je 0xe0da7
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rbx
movq %rbx, %rdi
callq 0xc84d7
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe0c2c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x114cd0
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xe12d0
movabsq $-0x340d631b7bdddcdb, %rdi # imm = 0xCBF29CE484222325
movb (%rcx), %sil
testb %sil, %sil
je 0xe12dc
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 0xe12b5
jmp 0xe12df
movabsq $-0x509c42b379fe4821, %rbx # imm = 0xAF63BD4C8601B7DF
jmp 0xe12df
movq %rdi, %rbx
movq %rax, %rdi
callq 0x114f61
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x114cd0
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r14, %rdi
callq 0xc84d7
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe100f
movq %rax, %r14
movq %rbx, %rdi
callq 0x114f61
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0xc795e(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f515
movq 0xc794e(%rip), %rdi     # 0x1a8dd8
cmpq $0x0, 0x18(%rdi)
je 0xe14c6
movl $0x10, %r14d
xorl %r15d, %r15d
movq 0x8(%rdi), %rax
cmpq $0x0, -0x10(%rax,%r14)
je 0xe14b2
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq 0xddb52
incq %r15
movq 0xc791c(%rip), %rdi     # 0x1a8dd8
addq $0x18, %r14
cmpq 0x18(%rdi), %r15
jb 0xe149a
addq $0x30, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11f547
// File: /workspace/github_c_makefile_star2_O1/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 0xc78fc(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f515
movq 0xc78ec(%rip), %rdi     # 0x1a8dd8
callq 0x13713d
movq %rax, %rbx
movq 0xc78dd(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f547
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc78bf(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f515
xorl %eax, %eax
callq 0x114bbb
movq %rax, %rbx
movq 0xc78a5(%rip), %rdi     # 0x1a8dd8
callq 0x137161
testq %rax, %rax
je 0xe15bb
movq %rax, %r14
xorl %r15d, %r15d
movq 0xc788e(%rip), %rdi     # 0x1a8dd8
movq %r15, %rsi
callq 0x137166
cmpq $0x0, (%rax)
je 0xe15b3
movq %rax, %r12
movq 0xc7876(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f547
movq 0x8(%r12), %r13
movq 0x10(%r12), %r12
movq %r12, %rdi
callq 0xc84d7
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xe0c2c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11556c
movq 0xc783b(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f515
movq %rbx, %rdi
movl $0xa, %esi
callq 0x115381
incq %r15
cmpq %r15, %r14
jne 0xe1543
movq 0xc7816(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f547
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0xc77f8(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f515
movq 0xc77e8(%rip), %rdi     # 0x1a8dd8
callq 0x136be0
movq %rax, %rbx
movq 0xc77d9(%rip), %rdi     # 0x1a8dd8
addq $0x30, %rdi
callq 0x11f547
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x70789(%rip), %rbx     # 0x151da1
movq %rbx, %rdi
callq 0xc84d7
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xe100f
movq %rax, %rbx
leaq 0x70782(%rip), %r14     # 0x151db9
movq %r14, %rdi
callq 0xc84d7
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe100f
movq %rax, %rbx
movabsq $0x7fc61ea4d6493b7d, %rax # imm = 0x7FC61EA4D6493B7D
cmpq %rax, %rbx
je 0xe1688
leaq 0x56fe1(%rip), %rdi     # 0x138647
leaq 0x70753(%rip), %rsi     # 0x151dc0
leaq 0x70778(%rip), %rdx     # 0x151dec
leaq 0x705de(%rip), %rcx     # 0x151c59
movl $0x186, %r8d            # imm = 0x186
xorl %eax, %eax
callq 0xc8053
movq %rbx, %rdi
callq 0xe0d44
movq %rax, %rbx
testq %rax, %rax
je 0xe169e
movq 0x8(%rbx), %rdi
jmp 0xe16a0
xorl %edi, %edi
leaq 0x70706(%rip), %rsi     # 0x151dad
callq 0xc84cd
testl %eax, %eax
je 0xe16d9
leaq 0x56f90(%rip), %rdi     # 0x138647
leaq 0x7074a(%rip), %rsi     # 0x151e08
leaq 0x70727(%rip), %rdx     # 0x151dec
leaq 0x7058d(%rip), %rcx     # 0x151c59
movl $0x188, %r8d            # imm = 0x188
xorl %eax, %eax
callq 0xc8053
movq %rbx, %rdi
callq 0x114f61
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe9c93
movabsq $-0x69a05554ee793861, %rcx # imm = 0x965FAAAB1186C79F
cmpq %rcx, %rax
je 0xe1754
movabsq $0x7ee758bbfced33e3, %rcx # imm = 0x7EE758BBFCED33E3
cmpq %rcx, %rax
je 0xe174a
movabsq $0x6a72cf8f8250f179, %rcx # imm = 0x6A72CF8F8250F179
cmpq %rcx, %rax
jne 0xe17d6
leaq 0xc76a7(%rip), %rdi     # 0x1a8de0
leaq 0xa0(%rip), %rsi        # 0xe17e0
callq 0x11f8a7
jmp 0xe17d6
callq 0xe160d
jmp 0xe17d6
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xe17b3
cmpl $0x0, (%rax)
jle 0xe17b3
callq 0xe14d4
movq %rax, %rbx
callq 0x11c4a0
movq %rax, %r14
movq 0xc765f(%rip), %rsi     # 0x1a8dd8
testq %rsi, %rsi
je 0xe1795
leaq 0x92(%rip), %rdi        # 0xe1817
callq 0xc8352
movq $0x0, 0xc7643(%rip) # 0x1a8dd8
callq 0x11c4a0
subq %rax, %r14
leaq 0x70694(%rip), %rdi     # 0x151e38
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xc7e11
jmp 0xe17d6
movq 0xc761e(%rip), %rsi     # 0x1a8dd8
testq %rsi, %rsi
je 0xe17d6
leaq 0x51(%rip), %rdi        # 0xe1817
callq 0xc8352
movq $0x0, 0xc7602(%rip) # 0x1a8dd8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11f515
movq %rbx, %rdi
callq 0x136b16
movq %r14, %rdi
callq 0x11f547
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f3ee
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x6e067(%rip), %rdi     # 0x151ea6
movq %r12, %rsi
xorl %eax, %eax
callq 0x114c1e
movq %rax, %rbx
subq 0x10(%rax), %r14
movl $0x1, %edx
cmovaq %r14, %rdx
movq %rax, %rdi
movl $0x20, %esi
callq 0x115408
movq %r12, %rdi
callq *%r15
leaq 0x6e045(%rip), %rsi     # 0x151eb8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1156f6
movq %rbx, %rdi
movl $0xa, %esi
callq 0x115381
testb $0x2, 0x50(%rsp)
je 0xe3eae
leaq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x112485
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc4f48(%rip), %r13     # 0x1a8e20
xorl %ebp, %ebp
movq 0x8(%rbx), %r14
movq 0x8(%r14), %r12
movabsq $-0x5073d588c3beb52e, %rax # imm = 0xAF8C2A773C414AD2
cmpq %rax, %r12
je 0xe3f7c
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 0xe3f50
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xe3f50
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xe3f50
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xe4056
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0xe3f7c
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq (%rbx), %rsi
movq %r14, %rdi
callq 0xf837b
cmpq %rax, %r15
jae 0xe4063
movq 0x8(%rbx), %r14
movq 0x8(%r14), %r12
movabsq $-0x5073d588c3beb52e, %rax # imm = 0xAF8C2A773C414AD2
cmpq %rax, %r12
je 0xe402e
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 0xe4002
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xe4002
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xe4002
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xe405e
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0xe402e
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq (%rbx), %rdx
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xf83a3
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq %rbp, %rax
cmovaq %rax, %rbp
incq %r15
jmp 0xe3eda
xorl %r14d, %r14d
jmp 0xe3f54
xorl %r14d, %r14d
jmp 0xe4006
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_O1/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 0xe40e1
movabsq $-0x58737885f0577327, %rcx # imm = 0xA78C877A0FA88CD9
cmpq %rcx, %rdi
jg 0xe413c
movabsq $-0x6119581ac7eacd64, %rcx # imm = 0x9EE6A7E53815329C
cmpq %rcx, %rdi
jle 0xe41c1
movabsq $-0x6119581ac7eacd63, %rcx # imm = 0x9EE6A7E53815329D
cmpq %rcx, %rdi
je 0xe4230
movabsq $-0x5fc2af85f419929b, %rcx # imm = 0xA03D507A0BE66D65
cmpq %rcx, %rdi
je 0xe4230
movabsq $-0x5aa4411ac4e2880e, %rcx # imm = 0xA55BBEE53B1D77F2
jmp 0xe422b
movabsq $0x62367a17d02b474c, %rcx # imm = 0x62367A17D02B474C
cmpq %rcx, %rdi
jg 0xe4184
movabsq $0x510c2417c67dabea, %rcx # imm = 0x510C2417C67DABEA
cmpq %rcx, %rdi
jle 0xe41dc
movabsq $0x510c2417c67dabeb, %rcx # imm = 0x510C2417C67DABEB
cmpq %rcx, %rdi
je 0xe4230
movabsq $0x54de8100f7c1cbe5, %rcx # imm = 0x54DE8100F7C1CBE5
cmpq %rcx, %rdi
je 0xe4230
movabsq $0x585a3b17ca3de200, %rcx # imm = 0x585A3B17CA3DE200
jmp 0xe422b
movabsq $-0x3f1363e6d8155aee, %rcx # imm = 0xC0EC9C1927EAA512
cmpq %rcx, %rdi
jle 0xe41f7
movabsq $-0x3f1363e6d8155aed, %rcx # imm = 0xC0EC9C1927EAA513
cmpq %rcx, %rdi
je 0xe4230
movabsq $-0x3ac242643d9c35a8, %rcx # imm = 0xC53DBD9BC263CA58
cmpq %rcx, %rdi
je 0xe4230
movabsq $-0x388c46b188de83fe, %rcx # imm = 0xC773B94E77217C02
jmp 0xe422b
movabsq $0x6d07f9ef5b68e8a1, %rcx # imm = 0x6D07F9EF5B68E8A1
cmpq %rcx, %rdi
jle 0xe4212
movabsq $0x6d07f9ef5b68e8a2, %rcx # imm = 0x6D07F9EF5B68E8A2
cmpq %rcx, %rdi
je 0xe4230
movabsq $0x6db6f178cd6db4b8, %rcx # imm = 0x6DB6F178CD6DB4B8
cmpq %rcx, %rdi
je 0xe4230
movabsq $0x6f0b060106a30da4, %rcx # imm = 0x6F0B060106A30DA4
jmp 0xe422b
movabsq $-0x73f6ae1ad309fd45, %rcx # imm = 0x8C0951E52CF602BB
cmpq %rcx, %rdi
je 0xe4230
movabsq $-0x6bce971ace902370, %rcx # imm = 0x943168E5316FDC90
jmp 0xe422b
movabsq $-0x84b14e74a9e1ff0, %rcx # imm = 0xF7B4EB18B561E010
cmpq %rcx, %rdi
je 0xe4230
movabsq $0x230abe18cdeefc99, %rcx # imm = 0x230ABE18CDEEFC99
jmp 0xe422b
movabsq $-0x58737885f0577326, %rcx # imm = 0xA78C877A0FA88CDA
cmpq %rcx, %rdi
je 0xe4230
movabsq $-0x4882601bdca6aefb, %rcx # imm = 0xB77D9FE423595105
jmp 0xe422b
movabsq $0x62367a17d02b474d, %rcx # imm = 0x62367A17D02B474D
cmpq %rcx, %rdi
je 0xe4230
movabsq $0x69849117d3eb7d62, %rcx # imm = 0x69849117D3EB7D62
cmpq %rcx, %rdi
jne 0xe4231
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movzbl (%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0xe80a5
cmpl $0x3c, %ecx
jne 0xe804e
leaq 0x1(%rdi), %r10
movq %r10, %rcx
movzbl (%rcx), %r8d
testl %r8d, %r8d
je 0xe7fed
cmpl $0x3e, %r8d
je 0xe7fed
incq %rcx
jmp 0xe7fd9
cmpb $0x3e, %r8b
jne 0xe8091
leaq -0x1(%rcx), %r9
movb -0x1(%rcx), %r11b
cmpb $0x2a, %r11b
cmovneq %rcx, %r9
testq %rdx, %rdx
je 0xe8013
cmpb $0x2a, %r11b
sete (%rdx)
incq %rcx
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
cmpq %r10, %r9
je 0xe8093
movabsq $0x100000001b3, %r10    # imm = 0x100000001B3
subq %rdi, %r9
movl $0x1, %r11d
movzbl (%rdi,%r11), %ebx
xorq %rbx, %rdx
imulq %r10, %rdx
incq %r11
cmpq %r11, %r9
jne 0xe8038
jmp 0xe8093
cmpb $0x0, 0x1(%rdi)
je 0xe80a5
cmpb $0x5f, 0x2(%rdi)
jne 0xe80a5
cmpb $0x74, 0x3(%rdi)
jne 0xe80a5
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %r8d
xorq %r8, %rdx
imulq %rax, %rdx
incq %rcx
cmpq $0x4, %rcx
jne 0xe8076
leaq 0x4(%rdi), %rcx
jmp 0xe8099
xorl %edx, %edx
cmpb $0x3e, %r8b
jne 0xe80a5
testq %rsi, %rsi
je 0xe80a1
movq %rdx, (%rsi)
subl %edi, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe9996
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xe999b
movq %rbx, %rdi
callq 0xd230
movq %rax, %r15
jmp 0xe999e
xorl %r14d, %r14d
jmp 0xe99c0
xorl %r15d, %r15d
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xc8315
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xc83f1
movb $0x0, (%r14,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe9a19
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0xe9a21
movb (%rdi), %cl
testb %cl, %cl
sete %dl
je 0xe9a12
movb (%rsi), %r8b
testb %r8b, %r8b
je 0xe9a0e
incq %rdi
incq %rsi
cmpb %r8b, %cl
jne 0xe9a22
movb (%rdi), %cl
testb %cl, %cl
sete %dl
je 0xe9a12
movb (%rsi), %r8b
incq %rdi
incq %rsi
testb %r8b, %r8b
jne 0xe99ef
decq %rsi
testb %dl, %dl
je 0xe9a21
xorl %eax, %eax
cmpb $0x0, (%rsi)
jmp 0xe9a1e
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_O1/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 0xe9a84
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0xe9a83
testq %rsi, %rsi
je 0xe9a8b
testq %rcx, %rcx
je 0xe9a83
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 0xe9a94
incq %r8
cmpq %r8, %rax
jne 0xe9a5e
xorl %edx, %edx
cmpq %r8, %rcx
setne %dl
cmpq %r8, %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %edx, %eax
retq
xorl %eax, %eax
testq %rdx, %rdx
jmp 0xe9a90
xorl %eax, %eax
testq %rcx, %rcx
setne %al
retq
setl %al
movzbl %al, %eax
leal -0x2(,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_parse_em_fa
er_t sc_t_parse_em_fa( sc_t o, uz_t start, uz_t end, uz_t* out_idx, sc_t format, ... )
{
    va_list args;
    va_start( args, format );
    er_t err = sc_t_parse_em_fv( o, start, end, out_idx, format, args );
    va_end( args );
    return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
leaq 0x40(%rsp), %rcx
movq %r9, 0x28(%rcx)
testb %al, %al
je 0xe9b87
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r13
movq %rcx, 0x10(%r13)
leaq 0x130(%rsp), %rax
movq %rax, 0x8(%r13)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%r13)
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
callq 0x11436d
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x118901
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_signal.c
// Function: bcore_signal_s_broadcast
vd_t bcore_signal_s_broadcast( const bcore_signal_s* o, bcore_fp_signal_handler* arr, uz_t size )
{
    vd_t ret = NULL;

    if( o->type == TYPEOF_down0 || o->type == TYPEOF_down1 )
    {
        for( uz_t i = size; i > 0; i-- ) if( ( ret = arr[ i - 1 ]( o ) ) ) return ret;
    }
    else
    {
        for( uz_t i = 0; i < size; i++ ) if( ( ret = arr[ i     ]( o ) ) ) return ret;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movabsq $-0x69a05654ee793a14, %rcx # imm = 0x965FA9AB1186C5EC
cmpq %rcx, %rax
je 0xe9cfc
movabsq $-0x69a05554ee793861, %rcx # imm = 0x965FAAAB1186C79F
cmpq %rcx, %rax
jne 0xe9d38
testq %rbx, %rbx
sete %bpl
je 0xe9d51
movq %r15, %rdi
callq *-0x8(%r14,%rbx,8)
testq %rax, %rax
je 0xe9d2a
movq %rax, %rcx
jmp 0xe9d53
movq %r15, %rdi
callq *-0x10(%r14,%rbx,8)
decq %rbx
movq %rax, %rcx
testq %rax, %rax
jne 0xe9d53
cmpq $0x1, %rbx
sete %bpl
jne 0xe9d17
xorl %ecx, %ecx
jmp 0xe9d53
testq %rbx, %rbx
setne %bpl
je 0xe9d64
movq %r15, %rdi
callq *(%r14)
testq %rax, %rax
je 0xe9d68
movq %rax, %rcx
jmp 0xe9d94
xorl %ecx, %ecx
testb %bpl, %bpl
je 0xe9d5b
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
jmp 0xe9d94
movl $0x1, %edx
movq %rdx, %r12
cmpq %rdx, %rbx
je 0xe9d8b
movq %r15, %rdi
callq *(%r14,%r12,8)
leaq 0x1(%r12), %rdx
movq %rax, %rcx
testq %rax, %rax
je 0xe9d6d
jmp 0xe9d8d
xorl %ecx, %ecx
cmpq %rbx, %r12
setb %bpl
testb %bpl, %bpl
je 0xe9d58
jmp 0xe9d5b
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_buffer_s_flush
bcore_sink_buffer_s* bcore_sink_buffer_s_flush( bcore_sink_buffer_s* o )
{
    if( o->consumer && o->size > 0 )
    {
        uz_t pushed_size = bcore_sink_a_push_data( o->consumer, o->data, o->size );
        if( pushed_size != o->size ) ERR( "Consumer accepted %zu of %zu bytes.", pushed_size, o->size );
        o->size = 0;
    }
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0xeabbd
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xeabbd
movq 0x8(%rbx), %r12
movq (%r14), %r13
leaq 0xbefd4(%rip), %rax     # 0x1a9ab0
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r13, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r13, %rdx
je 0xeab36
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0xeab36
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0xeab36
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0xeabcf
movq (%rax,%rcx), %rbp
testq %rbp, %rbp
jne 0xeab66
movabsq $0x5ea8cabb93ff3b7e, %rdi # imm = 0x5EA8CABB93FF3B7E
movq %r13, %rsi
callq 0xf3f85
movq %rax, %rbp
leaq 0xbef55(%rip), %rdi     # 0x1a9ab0
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
cmpq $0x0, 0x10(%rbp)
jne 0xeab7c
leaq 0x5a74a(%rip), %rsi     # 0x1452be
movq %rbp, %rdi
callq 0xf592c
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x10(%rbp)
movq 0x10(%rbx), %r9
cmpq %r9, %rax
je 0xeabb5
leaq 0x679f1(%rip), %rdi     # 0x152589
leaq 0x67a04(%rip), %rsi     # 0x1525a3
leaq 0x67a0b(%rip), %rcx     # 0x1525b1
movl $0xe5, %edx
movq %rax, %r8
xorl %eax, %eax
callq 0xc80f6
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xeab3a
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: buffer_flow_snk
static uz_t buffer_flow_snk( bcore_sink_buffer_s* o, vc_t data, uz_t size )
{
    uz_t new_size = o->size + size;
    if( new_size > o->space )
    {
        uz_t new_space = ( o->space * 2 > new_size ) ? o->space * 2 : new_size;
        o->data = bcore_bn_alloc( o->data, o->space, new_space, &o->space );
    }
    bcore_memcpy( o->data + o->size, data, size );
    o->size += size;
    if( o->consumer && o->size >= o->entrepot_size ) bcore_sink_buffer_s_flush( o );
    return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rdx
addq %rbx, %rdx
movq 0x18(%rdi), %rsi
cmpq %rsi, %rdx
jbe 0xeac12
leaq 0x18(%r14), %rcx
leaq (%rsi,%rsi), %rax
cmpq %rdx, %rax
cmovaq %rax, %rdx
movq 0x8(%r14), %rdi
callq 0xc8334
movq %rax, 0x8(%r14)
movq 0x8(%r14), %rdi
addq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc83f1
movq 0x10(%r14), %rax
addq %rbx, %rax
movq %rax, 0x10(%r14)
cmpq $0x0, 0x20(%r14)
je 0xeac45
cmpq 0x28(%r14), %rax
jb 0xeac45
movq %r14, %rdi
callq 0xeaaa6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_file_s_open
void bcore_sink_file_s_open( bcore_sink_file_s* o )
{
    if( !o->name ) ERR( "No file name specified." );
    if( o->handle ) bcore_sink_file_s_close( o );
    o->handle = fopen( o->name->sc, "wb" );
    if( !o->handle )
    {
        st_s* msg = st_s_createf( "Error opening file %s:\n", o->name->sc );
        perror( msg->sc );
        st_s_discard( msg );
        bcore_abort();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0xeb233
leaq 0x673eb(%rip), %rdi     # 0x152604
leaq 0x67383(%rip), %rsi     # 0x1525a3
leaq 0x673f4(%rip), %rcx     # 0x15261b
movl $0x19b, %edx            # imm = 0x19B
xorl %eax, %eax
callq 0xc80f6
cmpq $0x0, 0x10(%rbx)
je 0xeb242
movq %rbx, %rdi
callq 0xeb26f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x6324c(%rip), %rsi     # 0x14e49d
callq 0xd170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xeb261
popq %rbx
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xd771
jmp 0xeb25f