LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_node_vd_s_count
uz_t bcore_btree_node_vd_s_count( const bcore_btree_node_vd_s* root, bl_t (*func)( vd_t arg, bcore_btree_vd_key_t key ), vd_t arg )
{
    uz_t count = 0;
    if( !root ) return count;
    if( root->child0 )
    {
        if( root->child0 != BNUL_VP ) count += bcore_btree_node_vd_s_count( root->child0, func, arg );
    }
    if( root->child1 )
    {
        count += ( func ) ? func( arg, root->kv1.key ) : 1;
        if( root->child1 != BNUL_VP ) count += bcore_btree_node_vd_s_count( root->child1, func, arg );
    }
    if( root->child2 )
    {
        count += ( func ) ? func( arg, root->kv2.key ) : 1;
        if( root->child2 != BNUL_VP ) count += bcore_btree_node_vd_s_count( root->child2, func, arg );
    }
    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x759ad(%rip), %rbp     # 0x1193f0
testq %r15, %r15
je 0xa3adf
movq 0x18(%r15), %rdi
testq %rdi, %rdi
sete %al
cmpq %rbp, %rdi
sete %cl
orb %al, %cl
je 0xa3a65
xorl %r12d, %r12d
jmp 0xa3a73
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa3a25
movq %rax, %r12
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0xa3aaa
pushq $0x1
popq %rax
testq %r14, %r14
je 0xa3a94
movq (%r15), %rsi
movq %rbx, %rdi
callq *%r14
movzbl %al, %eax
movq 0x20(%r15), %rdi
addq %rax, %r12
cmpq %rbp, %rdi
je 0xa3aaa
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa3a25
addq %rax, %r12
movq 0x28(%r15), %rax
testq %rax, %rax
je 0xa3ae2
pushq $0x1
popq %rcx
testq %r14, %r14
je 0xa3acc
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *%r14
movzbl %al, %ecx
movq 0x28(%r15), %rax
addq %rcx, %r12
cmpq %rbp, %rax
je 0xa3ae2
addq %r12, %r13
movq %rax, %r15
jmp 0xa3a43
xorl %r12d, %r12d
addq %r13, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_node_vd_s_keys
uz_t bcore_btree_node_vd_s_keys( bcore_btree_node_vd_s* root )
{
    if( !root || root == BNUL_VP ) return 0;
    uz_t keys = root->child2 ? 2 : 1;
    keys += bcore_btree_node_vd_s_keys( root->child0 );
    keys += bcore_btree_node_vd_s_keys( root->child1 );
    if( root->child2 ) keys += bcore_btree_node_vd_s_keys( root->child2 );
    return keys;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq $0x0, (%rsp)
leaq 0x758dc(%rip), %r13     # 0x1193f0
xorl %r12d, %r12d
testq %r14, %r14
je 0xa3b5d
cmpq %r13, %r14
je 0xa3b5d
movq 0x18(%r14), %rdi
movq 0x28(%r14), %rbp
xorl %ebx, %ebx
testq %rbp, %rbp
sete %bl
callq 0xa3af7
movq %rax, %r15
subq %rbx, %r15
movq 0x20(%r14), %rdi
callq 0xa3af7
addq %r15, %rax
addq $0x2, %rax
testq %rbp, %rbp
je 0xa3b59
addq %rax, %r12
movq %rbp, %r14
jmp 0xa3b17
movq %rax, (%rsp)
movq (%rsp), %rax
addq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_node_vd_s_show
st_s* bcore_btree_node_vd_s_show( bcore_btree_node_vd_s* o, uz_t depth )
{
    st_s* string = st_s_create();
    if( !o )
    {
        st_s_pushf( string, "()\n" );
        return string;
    }
    if( o->child1 )
    {
        if( o->child0 && o->child0 != BNUL_VP ) st_s_push_st_d( string, bcore_btree_node_vd_s_show( o->child0, depth + 1 ) );
        for( uz_t i = 0; i < depth; i++ ) st_s_pushf( string, "    " );
        st_s_pushf( string, "(%lu)\n", ( int64_t )(intptr_t)o->kv1.key );
        if( o->child1 && o->child1 != BNUL_VP ) st_s_pushf( string, "    " );
    }
    if( o->child2 )
    {
        for( uz_t i = 0; i < depth; i++ ) st_s_pushf( string, "    " );
        st_s_pushf( string, "(%lu)\n", ( int64_t )(intptr_t)o->kv2.key );
        if( o->child2 && o->child2 != BNUL_VP ) st_s_push_st_d( string, bcore_btree_node_vd_s_show( o->child2, depth + 1 ) );
    }
    return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
callq 0x8eb65
movq %rax, %rbx
testq %r15, %r15
je 0xa4150
cmpq $0x0, 0x20(%r15)
je 0xa40e2
movq 0x18(%r15), %rdi
testq %rdi, %rdi
sete %al
leaq 0x75384(%rip), %r13     # 0x1193f0
cmpq %r13, %rdi
sete %cl
orb %al, %cl
jne 0xa408a
leaq 0x1(%r14), %rsi
callq 0xa402c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8f2e5
leaq 0x1d6e9(%rip), %r12     # 0xc177a
movq %r14, %rbp
subq $0x1, %rbp
jb 0xa40a9
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x8f42b
jmp 0xa4094
movq (%r15), %rdx
leaq 0x28a9d(%rip), %rsi     # 0xccb50
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
movq 0x20(%r15), %rax
testq %rax, %rax
sete %cl
cmpq %r13, %rax
sete %al
orb %cl, %al
jne 0xa40e2
leaq 0x1d6a2(%rip), %rsi     # 0xc177a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
cmpq $0x0, 0x28(%r15)
je 0xa4161
leaq 0x1d68a(%rip), %r12     # 0xc177a
movq %r14, %r13
subq $0x1, %r13
jb 0xa4108
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x8f42b
jmp 0xa40f3
movq 0x8(%r15), %rdx
leaq 0x28a3d(%rip), %rsi     # 0xccb50
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
movq 0x28(%r15), %rdi
testq %rdi, %rdi
sete %al
leaq 0x752c2(%rip), %rcx     # 0x1193f0
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0xa4161
incq %r14
movq %r14, %rsi
callq 0xa402c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8f2e5
jmp 0xa4161
leaq 0x287dd(%rip), %rsi     # 0xcc934
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8f42b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_vd_s_create
bcore_btree_vd_s* bcore_btree_vd_s_create( vd_t (*alloc)( vd_t, uz_t size ) )
{
    bcore_btree_vd_s* o = NULL;
    if( alloc )
    {
        o = alloc( NULL, sizeof( bcore_btree_vd_s ) );
        o->alloc = alloc;
    }
    else
    {
        o = bcore_alloc( NULL, sizeof( bcore_btree_vd_s ) );
        o->alloc = bcore_alloc;
    }
    o->root      = NULL;
    o->chain_beg = NULL;
    o->chain_end = NULL;
    o->chain_ins = NULL;
    o->del_chain = NULL;
    o->block_size = 1024;
    return o;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa4185
movq %rdi, %rbx
pushq $0x38
popq %rsi
xorl %edi, %edi
callq *%rbx
jmp 0xa4196
pushq $0x38
popq %rsi
xorl %edi, %edi
callq 0x6023e
leaq -0x43f58(%rip), %rbx    # 0x6023e
movq %rbx, 0x28(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x400, 0x30(%rax)      # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_vd_s_discard
void bcore_btree_vd_s_discard( bcore_btree_vd_s* o )
{
    o->root = NULL;

    bcore_btree_node_vd_s* chain_beg = o->chain_beg;
    while( chain_beg )
    {
        bcore_btree_node_vd_s* new_beg = *( bcore_btree_node_vd_s** )( chain_beg + o->block_size );
        o->alloc( chain_beg, 0 );
        chain_beg = new_beg;
    }

    o->alloc( o, 0 );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xa41da
imulq $0x30, 0x30(%rbx), %rax
movq (%rdi,%rax), %r14
xorl %esi, %esi
callq *0x28(%rbx)
movq %r14, %rdi
jmp 0xa41c2
movq 0x28(%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_vd_s_new_node
bcore_btree_node_vd_s* bcore_btree_vd_s_new_node( bcore_btree_vd_s* o )
{
    if( o->del_chain )
    {
        bcore_btree_node_vd_s* new_node = o->del_chain;
        o->del_chain = new_node->parent;
        bcore_btree_node_vd_s_init( new_node );
        return new_node;
    }
    else
    {
        if( o->chain_ins == o->chain_end )
        {
            bcore_btree_node_vd_s* new_ptr = o->alloc( NULL, o->block_size * sizeof( bcore_btree_node_vd_s ) + sizeof( bcore_btree_node_vd_s* ) );
            if( !o->chain_beg )
            {
                o->chain_beg = new_ptr;
            }
            else
            {
                ( ( bcore_btree_node_vd_s** )( o->chain_end ) )[ 0 ] = new_ptr;
            }
            o->chain_ins = new_ptr;
            o->chain_end = new_ptr + o->block_size;
            *( bcore_btree_node_vd_s** )( o->chain_end ) = NULL;
        }
        bcore_btree_node_vd_s* new_node = o->chain_ins;
        bcore_btree_node_vd_s_init( new_node );
        o->chain_ins++;
        return new_node;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xa4211
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0xa426c
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0xa4259
imulq $0x30, 0x30(%rbx), %rsi
orq $0x8, %rsi
xorl %edi, %edi
callq *0x28(%rbx)
cmpq $0x0, 0x8(%rbx)
je 0xa4236
movq 0x10(%rbx), %rcx
jmp 0xa423a
leaq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rax, 0x18(%rbx)
imulq $0x30, 0x30(%rbx), %rcx
movq %rax, %rdx
addq %rcx, %rdx
movq %rdx, 0x10(%rbx)
andq $0x0, (%rax,%rcx)
movq 0x18(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x30, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_vd_s_exists
bl_t bcore_btree_vd_s_exists( const bcore_btree_vd_s* o, bcore_btree_vd_key_t key )
{
    if( !o )    return false;
    bcore_btree_node_vd_s* node = bcore_btree_node_vd_s_find( o->root, key );
    if( !node ) return false;
    if( node->kv1.key == key ) return true;
    if( node->child2 && node->kv2.key == key ) return true;
    return false;
}

// Assembly:
testq %rdi, %rdi
je 0xa4864
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rdi
callq 0xa38bf
testq %rax, %rax
je 0xa4860
movq %rax, %rcx
movb $0x1, %al
cmpq %rbx, (%rcx)
je 0xa4862
cmpq $0x0, 0x28(%rcx)
je 0xa4860
cmpq %rbx, 0x8(%rcx)
je 0xa4862
xorl %eax, %eax
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_vd_s_set
int bcore_btree_vd_s_set( bcore_btree_vd_s* o, bcore_btree_vd_key_t key )
{
    if( !o ) return -2;
    if( !o->root )
    {
        o->root = bcore_btree_vd_s_new_node( o );
        o->root->child0 = o->root->child1 = BNUL_VP;
        o->root->child2 = NULL;
        o->root->kv1.key = key;
        return 1;
    }

    bcore_btree_node_vd_s* node = bcore_btree_node_vd_s_find( o->root, key );
    if( !node ) return -2;

    if( node->kv1.key == key )
    {
        return 0;
    }
    else if( node->child2 && node->kv2.key == key )
    {
        return 0;
    }
    else
    {
        bcore_btree_vd_kv_s kv = { key };
        bcore_btree_vd_s_push( o, node, &kv, BNUL_VP, BNUL_VP );
        return 1;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $-0x2
popq %rbp
testq %rdi, %rdi
je 0xa48f2
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa48cd
movq %rbx, %rsi
callq 0xa38bf
testq %rax, %rax
je 0xa48f2
xorl %ebp, %ebp
cmpq %rbx, (%rax)
je 0xa48f2
cmpq $0x0, 0x28(%rax)
je 0xa48ae
cmpq %rbx, 0x8(%rax)
je 0xa48f2
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x74b33(%rip), %rcx     # 0x1193f0
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %r8
callq 0xa4287
jmp 0xa48ef
movq %r14, %rdi
callq 0xa41ec
movq %rax, (%r14)
leaq 0x74b11(%rip), %rcx     # 0x1193f0
movq %rcx, 0x20(%rax)
movq %rcx, 0x18(%rax)
andq $0x0, 0x28(%rax)
movq %rbx, (%rax)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_btree.c
// Function: bcore_btree_vd_s_show
st_s* bcore_btree_vd_s_show( bcore_btree_vd_s* o )
{
    bcore_btree_node_vd_s_check_consistency( o->root );
    st_s* s = bcore_btree_node_vd_s_show( o->root, 0 );
    st_s_pushf( s, "\n" );
    return s;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xa3c17
movq (%rbx), %rdi
xorl %esi, %esi
callq 0xa402c
movq %rax, %rbx
leaq 0x21b4c(%rip), %rsi     # 0xc65cb
movq %rax, %rdi
xorl %eax, %eax
callq 0x8f42b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_const_manager.c
// Function: bcore_const_vget_r
const sr_s* bcore_const_vget_r( tp_t key, tp_t type )
{
    const sr_s* sr = bcore_const_get_r( key );
    if( !sr ) ERR_fa( "Key '#<sc_t>' (#<tp_t>) not registered.", ifnameof( key ), key );
    if( type != 0 )
    {
        if( sr_s_type( sr ) != type )
        {
            ERR_fa( "Key '#<sc_t>': Type mismatch: '#<sc_t>' requested but '#<sc_t>' registered.",
                    ifnameof( key ), ifnameof( type ), ifnameof( sr_s_type( sr ) ) );
        }
    }
    return sr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xa6500
movq %rax, %rbx
testq %rax, %rax
je 0xa654d
testq %r14, %r14
je 0xa65e8
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa6584
movq 0x8(%rax), %r12
jmp 0xa6587
movq %r15, %rdi
callq 0xa62ac
leaq 0x267ea(%rip), %rdi     # 0xccd46
leaq 0x26791(%rip), %rsi     # 0xcccf4
leaq 0x267ef(%rip), %rcx     # 0xccd59
xorl %r12d, %r12d
pushq $0x7a
popq %rdx
movq %rax, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x60186
testq %r14, %r14
jne 0xa6587
jmp 0xa65e8
xorl %r12d, %r12d
cmpq %r14, %r12
je 0xa65e8
movq %r15, %rdi
callq 0xa62ac
movq %rax, %r15
movq %r14, %rdi
callq 0xa62ac
movq %rax, %r14
testq %rbx, %rbx
je 0xa65b6
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa65b6
movq 0x8(%rax), %rdi
jmp 0xa65b8
xorl %edi, %edi
callq 0xa62ac
movq %rax, (%rsp)
leaq 0x2677e(%rip), %rdi     # 0xccd46
leaq 0x26725(%rip), %rsi     # 0xcccf4
leaq 0x267ab(%rip), %rcx     # 0xccd81
movl $0x80, %edx
movq %r15, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x60186
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_const_manager.c
// Function: bcore_const_string_set_st_d
tp_t bcore_const_string_set_st_d( st_s* string )
{
    tp_t key = typeof( string->sc );
    bcore_mutex_s_lock( mutex_st_g );
    if( bcore_hmap_tp_sr_s_exists( hmap_st_g, key ) )
    {
        st_s* st = bcore_hmap_tp_sr_s_get( hmap_st_g, key )->o;
        if( !st_s_equal_st( st, string ) )
        {
            bcore_mutex_s_unlock( mutex_st_g );
            ERR_fa( "Collision: Strings '#<sc_t>' and '#<sc_t>' produce the same key '#<tp_t>'.", string, st->sc, key );
        }
        st_s_discard( string );
    }
    else
    {
        bcore_hmap_tp_sr_s_set( hmap_st_g, key, sr_asm( string ) );
    }
    bcore_mutex_s_unlock( mutex_st_g );
    return key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xa670d
movq %rax, %rbx
movq 0x72df0(%rip), %rdi     # 0x119428
callq 0x97ae2
movq 0x72dec(%rip), %rdi     # 0x119430
movq %rbx, %rsi
callq 0x6fbb4
movq 0x72ddd(%rip), %r15     # 0x119430
testb %al, %al
je 0xa6670
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6f7c7
movq (%rax), %r15
testq %r15, %r15
je 0xa66a5
movq 0x8(%r15), %rdi
jmp 0xa66a7
movq %r14, 0x18(%rsp)
movq (%r14), %rdi
callq 0x8cd25
movq %rax, 0x20(%rsp)
pushq $0x2
popq %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6f857
jmp 0xa66f4
xorl %edi, %edi
movq 0x8(%r14), %rsi
callq 0x6036f
testl %eax, %eax
je 0xa66ec
movq 0x72d6d(%rip), %rdi     # 0x119428
callq 0x97b12
movq 0x8(%r15), %r9
movq %rbx, (%rsp)
leaq 0x266fe(%rip), %rdi     # 0xccdcd
leaq 0x2661e(%rip), %rsi     # 0xcccf4
leaq 0x2670c(%rip), %rcx     # 0xccde9
movl $0x9e, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x60186
movq %r14, %rdi
callq 0x8edd4
movq 0x72d2d(%rip), %rdi     # 0x119428
callq 0x97b12
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_const_manager.c
// Function: bcore_const_string_get_sc
sc_t bcore_const_string_get_sc( tp_t key )
{
    bcore_mutex_s_lock( mutex_st_g );
    sr_s* sr = bcore_hmap_tp_sr_s_get( hmap_st_g, key );
    sc_t  sc = ( sr ) ? ( ( st_s* )sr->o )->sc : NULL;
    bcore_mutex_s_unlock( mutex_st_g );
    return sc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x72cba(%rip), %rdi     # 0x119428
callq 0x97ae2
movq 0x72cb6(%rip), %rdi     # 0x119430
movq %rbx, %rsi
callq 0x6f7c7
testq %rax, %rax
je 0xa6790
movq (%rax), %rax
movq 0x8(%rax), %rbx
jmp 0xa6792
xorl %ebx, %ebx
movq 0x72c8f(%rip), %rdi     # 0x119428
callq 0x97b12
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_const_manager.c
// Function: bcore_const_string_get_st
const st_s* bcore_const_string_get_st( tp_t key )
{
    bcore_mutex_s_lock( mutex_st_g );
    sr_s* sr = bcore_hmap_tp_sr_s_get( hmap_st_g, key );
    st_s* st = ( sr ) ? sr->o : NULL;
    bcore_mutex_s_unlock( mutex_st_g );
    return st;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x72c7a(%rip), %rdi     # 0x119428
callq 0x97ae2
movq 0x72c76(%rip), %rdi     # 0x119430
movq %rbx, %rsi
callq 0x6f7c7
testq %rax, %rax
je 0xa67cc
movq (%rax), %rbx
jmp 0xa67ce
xorl %ebx, %ebx
movq 0x72c53(%rip), %rdi     # 0x119428
callq 0x97b12
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_const_manager.c
// Function: bcore_const_string_exists
bl_t bcore_const_string_exists( tp_t key )
{
    bcore_mutex_s_lock( mutex_st_g );
    bl_t bl = bcore_hmap_tp_sr_s_exists( hmap_st_g, key );
    bcore_mutex_s_unlock( mutex_st_g );
    return bl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x72c3e(%rip), %rdi     # 0x119428
callq 0x97ae2
movq 0x72c3a(%rip), %rdi     # 0x119430
movq %rbx, %rsi
callq 0x6fbb4
movl %eax, %ebx
movq 0x72c21(%rip), %rdi     # 0x119428
callq 0x97b12
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_t_set_d
void bcore_global_t_set_d( tp_t key, tp_t t, vd_t v )
{
    assert( hmap_g );
    bcore_mutex_s_lock( mutex_g );
    bcore_hmap_tp_sr_s_set( hmap_g, key, sr_tsm( t, v ) );
    bcore_mutex_s_unlock( mutex_g );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x72875(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x72871(%rip), %r14     # 0x119440
movq %r12, 0x20(%rsp)
testq %r15, %r15
je 0xa6be3
movq %r15, %rdi
callq 0x8cd25
jmp 0xa6be5
xorl %eax, %eax
movq %rax, 0x28(%rsp)
pushq $0x2
popq %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f857
movq 0x72826(%rip), %rdi     # 0x119438
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x97b12
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_get_ifnexists_set
vd_t bcore_global_get_ifnexists_set( tp_t key, tp_t type )
{
    assert( hmap_g );
    bcore_mutex_s_lock( mutex_g );
    if( !bcore_hmap_tp_sr_s_exists( hmap_g, key ) )
    {
        bcore_hmap_tp_sr_s_set( hmap_g, key, sr_create( type ) );
    }
    const sr_s* sr = bcore_hmap_tp_sr_s_get( hmap_g, key );
    bcore_mutex_s_unlock( mutex_g );
    return ( sr ) ? sr->o : NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x726ea(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x726e6(%rip), %rdi     # 0x119440
movq %rbx, %rsi
callq 0x6fbb4
testb %al, %al
jne 0xa6db1
movq 0x726d3(%rip), %r14     # 0x119440
movq %r15, %rdi
callq 0x8cd0a
movq %rax, 0x18(%rsp)
testq %r15, %r15
je 0xa6d89
movq %r15, %rdi
callq 0x8cd25
jmp 0xa6d8b
xorl %eax, %eax
movq %rax, 0x20(%rsp)
pushq $0x2
popq %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f857
movq 0x72688(%rip), %rdi     # 0x119440
movq %rbx, %rsi
callq 0x6f7c7
movq %rax, %rbx
movq 0x7266e(%rip), %rdi     # 0x119438
callq 0x97b12
testq %rbx, %rbx
je 0xa6dd9
movq (%rbx), %rax
jmp 0xa6ddb
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_get_ifnexists_set_d
vd_t bcore_global_get_ifnexists_set_d( tp_t key, tp_t type, vd_t obj )
{
    assert( hmap_g );
    bcore_mutex_s_lock( mutex_g );
    if( !bcore_hmap_tp_sr_s_exists( hmap_g, key ) )
    {
        bcore_hmap_tp_sr_s_set( hmap_g, key, sr_tsm( type, obj ) );
    }
    else
    {
        bcore_inst_t_discard( type, obj );
    }
    const sr_s* sr = bcore_hmap_tp_sr_s_get( hmap_g, key );
    bcore_mutex_s_unlock( mutex_g );
    return ( sr ) ? sr->o : NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x72638(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x72634(%rip), %rdi     # 0x119440
movq %rbx, %rsi
callq 0x6fbb4
testb %al, %al
je 0xa6e33
testq %r14, %r14
je 0xa6e76
movq %r15, %rdi
callq 0xa7231
movq %rax, %rdi
movq %r14, %rsi
callq *0xb8(%rax)
jmp 0xa6e76
movq 0x72606(%rip), %r12     # 0x119440
movq %r14, 0x20(%rsp)
testq %r15, %r15
je 0xa6e4e
movq %r15, %rdi
callq 0x8cd25
jmp 0xa6e50
xorl %eax, %eax
movq %rax, 0x28(%rsp)
pushq $0x2
popq %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6f857
movq 0x725c3(%rip), %rdi     # 0x119440
movq %rbx, %rsi
callq 0x6f7c7
movq %rax, %rbx
movq 0x725a9(%rip), %rdi     # 0x119438
callq 0x97b12
testq %rbx, %rbx
je 0xa6e9e
movq (%rbx), %rax
jmp 0xa6ea0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_get_o
vd_t bcore_global_get_o( tp_t key )
{
    bcore_mutex_s_lock( mutex_g );
    const sr_s* sr = bcore_hmap_tp_sr_s_get( hmap_g, key );
    bcore_mutex_s_unlock( mutex_g );
    return ( sr ) ? sr->o : NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x72521(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x7251d(%rip), %rdi     # 0x119440
movq %rbx, %rsi
callq 0x6f7c7
movq %rax, %rbx
movq 0x72503(%rip), %rdi     # 0x119438
callq 0x97b12
testq %rbx, %rbx
je 0xa6f44
movq (%rbx), %rax
jmp 0xa6f46
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_get_x
sr_s bcore_global_get_x( tp_t key )
{
    bcore_mutex_s_lock( mutex_g );
    const sr_s* sr = bcore_hmap_tp_sr_s_get( hmap_g, key );
    bcore_mutex_s_unlock( mutex_g );
    return ( sr ) ? sr_pwc( sr->p, sr->o ) : sr_null();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x724df(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x724db(%rip), %rdi     # 0x119440
movq %r14, %rsi
callq 0x6f7c7
movq %rax, %r14
movq 0x724c1(%rip), %rdi     # 0x119438
callq 0x97b12
testq %r14, %r14
je 0xa6f92
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x1, 0x10(%rbx)
jmp 0xa6f9d
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_get_r
sr_s* bcore_global_get_r( tp_t key )
{
    bcore_mutex_s_lock( mutex_g );
    sr_s* sr = bcore_hmap_tp_sr_s_get( hmap_g, key );
    bcore_mutex_s_unlock( mutex_g );
    return sr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x72485(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x72481(%rip), %rdi     # 0x119440
movq %rbx, %rsi
callq 0x6f7c7
movq %rax, %rbx
movq 0x72467(%rip), %rdi     # 0x119438
callq 0x97b12
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_vget_r
sr_s* bcore_global_vget_r( tp_t key, tp_t type )
{
    sr_s* sr = bcore_global_get_r( key );
    if( !sr ) ERR_fa( "Key '#<sc_t>' (#<tp_t>) not registered.", ifnameof( key ), key );
    if( type != 0 )
    {
        if( sr_s_type( sr ) != type )
        {
            ERR_fa( "Key '#<sc_t>': Type mismatch: '#<sc_t>' requested but '#<sc_t>' registered.",
                    ifnameof( key ), ifnameof( type ), ifnameof( sr_s_type( sr ) ) );
        }
    }
    return sr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xa6fa8
movq %rax, %rbx
testq %rax, %rax
je 0xa7019
testq %r14, %r14
je 0xa70b6
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa7052
movq 0x8(%rax), %r12
jmp 0xa7055
movq %r15, %rdi
callq 0xa70e7
leaq 0x25f22(%rip), %rdi     # 0xccf4a
leaq 0x25f2f(%rip), %rsi     # 0xccf5e
leaq 0x25d23(%rip), %rcx     # 0xccd59
xorl %r12d, %r12d
movl $0xa5, %edx
movq %rax, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x60186
testq %r14, %r14
jne 0xa7055
jmp 0xa70b6
xorl %r12d, %r12d
cmpq %r14, %r12
je 0xa70b6
movq %r15, %rdi
callq 0xa70e7
movq %rax, %r15
movq %r14, %rdi
callq 0xa70e7
movq %rax, %r14
testq %rbx, %rbx
je 0xa7084
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa7084
movq 0x8(%rax), %rdi
jmp 0xa7086
xorl %edi, %edi
callq 0xa70e7
movq %rax, (%rsp)
leaq 0x25eb4(%rip), %rdi     # 0xccf4a
leaq 0x25ec1(%rip), %rsi     # 0xccf5e
leaq 0x25cdd(%rip), %rcx     # 0xccd81
movl $0xab, %edx
movq %r15, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x60186
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_exists
bl_t bcore_global_exists( tp_t key )
{
    bcore_mutex_s_lock( mutex_g );
    bl_t bl = bcore_hmap_tp_sr_s_exists( hmap_g, key );
    bcore_mutex_s_unlock( mutex_g );
    return bl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x72330(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x7232c(%rip), %rdi     # 0x119440
movq %rbx, %rsi
callq 0x6fbb4
movl %eax, %ebx
movq 0x72313(%rip), %rdi     # 0x119438
callq 0x97b12
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_global_manager.c
// Function: bcore_global_size
sz_t bcore_global_size()
{
    bcore_mutex_s_lock( mutex_g );
    sz_t sz = bcore_hmap_tp_sr_s_keys( hmap_g );
    bcore_mutex_s_unlock( mutex_g );
    return sz;
}

// Assembly:
pushq %rbx
movq 0x72302(%rip), %rdi     # 0x119438
callq 0x97ae2
movq 0x722fe(%rip), %rdi     # 0x119440
callq 0x6fc1d
movq %rax, %rbx
movq 0x722e7(%rip), %rdi     # 0x119438
callq 0x97b12
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_img.c
// Function: bcore_img_u2_s_set_size
void bcore_img_u2_s_set_size( bcore_img_u2_s* o, uz_t rows, uz_t cols )
{
    bcore_array_a_set_size( ( bcore_array* )o, rows * cols );
    bcore_u_memzero( sizeof( u2_t ), o->data, o->size );
    o->rows = rows;
    o->cols = cols;
    o->stride = cols;

    if( !o->format ) o->format = TYPEOF_bcore_img_u2_argb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r12
imulq %rsi, %r12
movq (%rdi), %r13
leaq 0x70a43(%rip), %rdi     # 0x117e20
movq %r13, %rsi
callq 0xa7aea
movq %rax, %rbp
testq %rax, %rax
jne 0xa7414
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r13, %rsi
callq 0x79b94
movq %rax, %rbp
leaq 0x70a17(%rip), %rdi     # 0x117e20
movq %r13, %rsi
movq %rax, %rdx
callq 0x98d4b
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7b8b6
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
pushq $0x4
popq %rdi
callq 0x602ac
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %r14, 0x20(%rbx)
cmpq $0x0, 0x8(%rbx)
jne 0xa7453
movabsq $-0x59225ce9298deaed, %rax # imm = 0xA6DDA316D6721513
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_img.c
// Function: bcore_img_u2_s_pnm_to_sink
const bcore_img_u2_s* bcore_img_u2_s_pnm_to_sink( const bcore_img_u2_s* o, bcore_sink* snk )
{
    bcore_sink_a_push_fa( snk, "P6\n#<uz_t> #<uz_t>\n255\n", o->cols, o->rows );
    for( sz_t i = 0; i < o->rows; i++ )
    {
        for( sz_t j = 0; j < o->cols; j++ )
        {
            u0_t rgb[ 3 ];
            bcore_img_u2_s_get_rgb( o, i, j, &rgb[ 0 ], &rgb[ 1 ], &rgb[ 2 ] );
            bcore_sink_a_push_data( snk, rgb, 3 );
        }
    }
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
leaq 0x25b3a(%rip), %rsi     # 0xccfbf
movq %r14, %rdi
xorl %eax, %eax
callq 0x87cf1
leaq 0x7161a(%rip), %r15     # 0x118ab0
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x10(%rbx), %rax
jae 0xa759a
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
cmpq 0x18(%rbx), %r12
jae 0xa7587
movq 0x8(%rbx), %rdi
movabsq $-0x59225ce9298deaed, %rax # imm = 0xA6DDA316D6721513
cmpq %rax, %rdi
jne 0xa74f6
movq 0x20(%rbx), %rax
imulq 0x8(%rsp), %rax
addq 0x28(%rbx), %rax
movl (%rax,%r12,4), %eax
movl %eax, %ecx
rolw $0x8, %cx
movw %cx, 0x6(%rsp)
shrl $0x10, %eax
movb %al, 0x5(%rsp)
jmp 0xa751d
callq 0xa7b42
leaq 0x25af9(%rip), %rdi     # 0xccffb
leaq 0x25b0c(%rip), %rsi     # 0xcd015
pushq $0x4d
popq %rdx
leaq 0x25b10(%rip), %rcx     # 0xcd023
movq %rax, %r8
xorl %eax, %eax
callq 0x60186
movq (%r14), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa7aea
movq %rax, %r13
testq %rax, %rax
jne 0xa7556
movabsq $0x5ea8cabb93ff3b7e, %rdi # imm = 0x5EA8CABB93FF3B7E
movq %rbp, %rsi
callq 0x79b94
movq %rax, %r13
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x98d4b
movq 0x10(%r13), %rax
testq %rax, %rax
jne 0xa7572
movq %r13, %rdi
leaq 0x10013(%rip), %rsi     # 0xb757c
callq 0x7ac00
movq 0x10(%r13), %rax
movq %r14, %rdi
leaq 0x5(%rsp), %rsi
pushq $0x3
popq %rdx
callq *%rax
incq %r12
jmp 0xa74b3
movq 0x10(%rsp), %rax
incq %rax
addq $0x4, 0x8(%rsp)
jmp 0xa74a1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_img.c
// Function: bcore_img_u2_s_pnm_to_file
const bcore_img_u2_s* bcore_img_u2_s_pnm_to_file( const bcore_img_u2_s* o, sc_t file )
{
    bcore_sink* snk = ( bcore_sink* )bcore_sink_open_file( file );
    bcore_img_u2_s_pnm_to_sink( o, snk );
    bcore_inst_a_discard( snk );
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7593e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa7462
movq %r14, %rdi
callq 0xa75dc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_img.c
// Function: bcore_img_u2_s_pnm_from_file
bcore_img_u2_s* bcore_img_u2_s_pnm_from_file( bcore_img_u2_s* o, sc_t file )
{
    bcore_source* src = ( bcore_source* )bcore_source_open_file( file );
    bcore_img_u2_s_pnm_from_source( o, src );
    bcore_inst_a_discard( src );
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x78010
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa75fe
movq %r14, %rdi
callq 0xa75dc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_img.c
// Function: bcore_img_signal_handler
vd_t bcore_img_signal_handler( const bcore_signal_s* o )
{
    switch( bcore_signal_s_handle_type( o, typeof( "bcore_img" ) ) )
    {
        case TYPEOF_init1:
        {
            BCORE_REGISTER_OBJECT( bcore_img_u2_s );
        }
        break;

        case TYPEOF_selftest:
        {
            selftest();
        }
        break;

        default: break;
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x25788(%rip), %rdi     # 0xccff1
callq 0xa7a50
movq %rbx, %rdi
movq %rax, %rsi
callq 0x75141
movabsq $0x7ee758bbfced33e3, %rcx # imm = 0x7EE758BBFCED33E3
cmpq %rcx, %rax
je 0xa78bb
movabsq $0x6a72ce8f8250efc6, %rcx # imm = 0x6A72CE8F8250EFC6
cmpq %rcx, %rax
jne 0xa7a3f
leaq 0x1d89d(%rip), %rdi     # 0xc513f
callq 0xa7a50
leaq 0x1da(%rip), %rsi       # 0xa7a88
movq %rax, %rdi
callq 0x6513b
jmp 0xa7a3f
leaq 0x7050e(%rip), %rax     # 0x117dd0
movq (%rax), %rsi
leaq 0x18(%rsp), %r14
movq %r14, 0x10(%rsp)
movq %r14, %rdi
callq 0x717f5
callq 0xa734a
movabsq $0x7e104f76f874d1b6, %r15 # imm = 0x7E104F76F874D1B6
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x71917
movq %rax, %rbx
callq 0xa734a
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x71917
movq %rax, 0x8(%rsp)
movl $0x80, %esi
movl $0x100, %edx            # imm = 0x100
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0xa73b8
xorl %r14d, %r14d
movl $0xff, %r13d
xorl %r15d, %r15d
cmpq $0x80, %r15
je 0xa79a0
movq %r15, %rax
shlq $0x3a, %rax
sarq $0x3f, %rax
movzbl %al, %ebp
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq $0x100, %r12            # imm = 0x100
je 0xa798e
movq %rbx, %r8
sarq $0x3f, %r8
leaq (%r14,%rbx), %r9
sarq $0x3f, %r9
andl %r13d, %r8d
andl %r13d, %r9d
movq (%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0xa77a2
incq %r12
movabsq $0x400000000000000, %rax # imm = 0x400000000000000
addq %rax, %rbx
jmp 0xa794d
incq %r15
movabsq $0x400000000000000, %rax # imm = 0x400000000000000
addq %rax, %r14
jmp 0xa7931
xorl %eax, %eax
callq 0x75519
leaq 0x18(%rsp), %r15
movabsq $-0x741f65139500cd47, %rsi # imm = 0x8BE09AEC6AFF32B9
movq %r15, %rdi
movq %rax, %rdx
callq 0x71917
movq %rax, %r12
movq (%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa7462
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rsi
callq 0x769d6
movq %r15, %rdi
movq %rax, %rsi
callq 0x71a4d
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xa75fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x81306
testl %eax, %eax
je 0xa7a35
leaq 0x2c34(%rip), %rdi      # 0xaa647
leaq 0x2569f(%rip), %rsi     # 0xcd0b9
leaq 0x221f9(%rip), %rdx     # 0xc9c1a
leaq 0x256b4(%rip), %rcx     # 0xcd0dc
movl $0xa1, %r8d
xorl %eax, %eax
callq 0x5ffac
leaq 0x10(%rsp), %rdi
callq 0x71b48
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_sc
bcore_name_s bcore_name_sc( sc_t name )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_strcpy( NULL, name );
    o.name_space = 0;
    o.key = bcore_name_key( name );
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa8398
xorl %edi, %edi
movq %rbx, %rsi
callq 0x6036a
movq %rax, 0x10(%r14)
andq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0xa849f
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_ns_sc
bcore_name_s bcore_name_ns_sc( tp_t name_space, sc_t name )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_strcpy( NULL, name );
    o.name_space = name_space;
    o.key = bcore_name_key_ns( name_space, name );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa8398
xorl %edi, %edi
movq %r14, %rsi
callq 0x6036a
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
testq %r15, %r15
je 0xa84f7
xorq $0x3a, %r15
movabsq $0x100000001b3, %rdi    # imm = 0x100000001B3
imulq %r15, %rdi
movq %r14, %rsi
callq 0xa8cbe
jmp 0xa84ff
movq %r14, %rdi
callq 0xa849f
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_sc_n
bcore_name_s bcore_name_sc_n( sc_t name, uz_t n )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_alloc( NULL, n + 1 );
    bcore_memcpy( o.name, name, n );
    o.name[ n ] = 0;
    o.name_space = 0;
    o.key = bcore_name_key_n( name, n );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa8398
leaq 0x1(%r14), %rsi
xorl %edi, %edi
callq 0x6023e
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x60300
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
andq $0x0, 0x8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xa8560
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_ns_sc_n
bcore_name_s bcore_name_ns_sc_n( tp_t name_space, sc_t name, uz_t n )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_alloc( NULL, n + 1 );
    bcore_memcpy( o.name, name, n );
    o.name[ n ] = 0;
    o.name_space = name_space;
    o.key = bcore_name_key_ns_n( name_space, name, n );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0xa8398
leaq 0x1(%r14), %rsi
xorl %edi, %edi
callq 0x6023e
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x60300
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
movq %r12, 0x8(%rbx)
testq %r12, %r12
je 0xa85dc
xorq $0x3a, %r12
movabsq $0x100000001b3, %rdi    # imm = 0x100000001B3
imulq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa8ce9
jmp 0xa85e7
movq %r15, %rdi
movq %r14, %rsi
callq 0xa8560
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_map_s_clear
void bcore_name_map_s_clear( bcore_name_map_s* o )
{
    if( o->data ) for( uz_t i = 0; i < o->size; i++ ) bcore_name_s_down( &o->data[ i ] );
    bcore_release( o->data );
    bcore_release( o->flags );
    o->data = 0;
    o->flags = 0;
    o->size = 0;
    o->depth_limit = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpq $0x0, 0x8(%rdi)
je 0xa8654
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
cmpq 0x18(%rbx), %r12
jae 0xa8656
addq %r15, %rdi
callq 0xa83be
incq %r12
addq $0x18, %r15
jmp 0xa8639
xorl %edi, %edi
callq 0x60272
movq 0x10(%rbx), %rdi
callq 0x60272
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_map_s_copy
void bcore_name_map_s_copy( bcore_name_map_s* o, const bcore_name_map_s* src )
{
    bcore_name_map_s_clear( o );
    o->data = bcore_alloc( NULL, sizeof( bcore_name_s ) * src->size );
    for( uz_t i = 0; i < src->size; i++ )
    {
        bcore_name_s_init( &o->data[ i ] );
        bcore_name_s_copy( &o->data[ i ], &src->data[ i ] );
    }
    o->size  = src->size;
    o->depth_limit = src->depth_limit;
    o->size_limit  = src->size_limit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa861d
imulq $0x18, 0x18(%r14), %rsi
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x6023e
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
movq 0x18(%r14), %rax
cmpq %rax, %r12
jae 0xa86db
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0xa8398
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq 0x8(%r14), %rsi
addq %r15, %rsi
callq 0xa83cc
incq %r12
addq $0x18, %r15
jmp 0xa86aa
movq %rax, 0x18(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: set_rehash
uz_t set_rehash( bcore_name_map_s* o, bcore_name_s name )
{
    if( !name.key ) ERR( "key is zero" );

    // set
    {
        uz_t idx = find( o, name.key );
        if( idx < o->size )
        {
            bcore_name_s_down( &name );
            return idx;
        }
        idx = set( o, name, 1 );
        if( idx < o->size ) return idx;
    }

    // rehash
    {
        bcore_name_s* buf_data  = o->data;
        uz_t          buf_size  = o->size;
        o->flags = bcore_u_alloc( sizeof( bl_t ), o->flags, 0, NULL );
        o->depth_limit = ( o->size > 0 ) ? o->depth_limit + 1 : 4;
        o->size        = ( o->size > 0 ) ? o->size * 2        : 8;
        if( o->size > o->size_limit ) ERR( "size limit (%zu) exceeded", o->size_limit );
        o->data = bcore_u_memzero( sizeof( bcore_name_s ), NULL, o->size );
        for( uz_t i = 0; i < buf_size; i++ ) if( buf_data[ i ].key ) set_rehash( o, buf_data[ i ] );
        bcore_u_alloc( sizeof( tp_t ), buf_data, 0, NULL );
    }

    return set_rehash( o, name );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x50(%rsp), %rax
movq (%rax), %r15
pushq $0x1
popq %rbx
testq %r15, %r15
jne 0xa8794
leaq 0x2496e(%rip), %rdi     # 0xcd0e8
leaq 0x24972(%rip), %rsi     # 0xcd0f3
movl $0x106, %edx            # imm = 0x106
leaq 0x1ac33(%rip), %rcx     # 0xc33c0
xorl %eax, %eax
callq 0x60031
movq %r14, %rdi
movq %r15, %rsi
callq 0xa88bb
cmpq 0x18(%r14), %rax
jb 0xa8897
leaq 0x50(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa8919
movq 0x18(%r14), %r12
cmpq %r12, %rax
jb 0xa88a6
movq %rbx, %rdi
movq 0x8(%r14), %rbp
movq 0x10(%r14), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6025e
movq %rax, 0x10(%r14)
movq 0x18(%r14), %rcx
pushq $0x4
popq %rax
testq %rcx, %rcx
je 0xa8801
movq 0x20(%r14), %rax
incq %rax
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
pushq $0x8
popq %rcx
cmoveq %rcx, %rdx
movq %rax, 0x20(%r14)
movq %rdx, 0x18(%r14)
movq 0x28(%r14), %r8
cmpq %r8, %rdx
jbe 0xa8845
leaq 0x248c1(%rip), %rdi     # 0xcd0e8
leaq 0x248c5(%rip), %rsi     # 0xcd0f3
movl $0x11b, %edx            # imm = 0x11B
leaq 0x248c6(%rip), %rcx     # 0xcd100
xorl %eax, %eax
callq 0x60031
movq 0x18(%r14), %rdx
pushq $0x18
popq %rdi
xorl %esi, %esi
callq 0x602ac
movq %rax, 0x8(%r14)
movq %rbp, %r13
subq $0x1, %r12
jb 0xa8883
cmpq $0x0, (%r13)
je 0xa887d
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0xa8752
addq $0x18, %r13
jmp 0xa8856
pushq $0x8
popq %rdi
movq %rbp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6025e
jmp 0xa876e
movq %rax, %r13
leaq 0x50(%rsp), %rdi
callq 0xa83be
jmp 0xa88a9
movq %rax, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: set
static uz_t set( bcore_name_map_s* o, bcore_name_s name, uz_t depth ) // sets new node, returns valid index on success; o->size otherwise
{
    uz_t size = o->size;
    if( size == 0 ) return size;
    uz_t mask = o->size - 1;

    if( depth == o->depth_limit ) return size;

    uz_t idx1 = hash_tpu3_1( name.key ) & mask;
    if( !o->data[ idx1 ].key )
    {
        o->data[ idx1 ] = name;
        return idx1;
    }

    uz_t idx2 = hash_tpu3_2( name.key ) & mask;
    if( !o->data[ idx2 ].key )
    {
        o->data[ idx2 ] = name;
        return idx2;
    }

    if( !o->flags ) o->flags = bcore_u_memzero( sizeof( bl_t ), NULL, size );

    if( !o->flags[ idx1 ] )
    {
        o->flags[ idx1 ] = true;
        if( set( o, o->data[ idx1 ], depth + 1 ) < size )
        {
            o->flags[ idx1 ] = false;
            o->data[  idx1 ] = name;
            return idx1;
        }
        o->flags[ idx1 ] = false;
    }

    if( !o->flags[ idx2 ] )
    {
        o->flags[ idx2 ] = true;
        if( set( o, o->data[ idx2 ], depth + 1 ) < size )
        {
            o->flags[ idx2 ] = false;
            o->data[  idx2 ] = name;
            return idx2;
        }
        o->flags[ idx2 ] = false;
    }

    return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
je 0xa8a48
movq %rdi, %r14
cmpq %rsi, 0x20(%rdi)
je 0xa8a6e
movq %rsi, 0x20(%rsp)
leaq 0x60(%rsp), %rax
leaq -0x1(%rbx), %r15
movq (%rax), %r13
movq %r13, %rdi
callq 0xa8d0f
movq %rax, %r12
andq %r15, %r12
movq 0x8(%r14), %rbp
imulq $0x18, %r12, %rax
cmpq $0x0, (%rbp,%rax)
je 0xa8a4c
movq %rax, 0x18(%rsp)
movq %r13, %rdi
callq 0xa8d72
movq %rax, %r13
andq %r15, %r13
imulq $0x18, %r13, %rax
cmpq $0x0, (%rbp,%rax)
je 0xa8a51
movq %rax, %rbp
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0xa89b4
pushq $0x1
popq %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x602ac
movq %rax, 0x10(%r14)
cmpb $0x0, (%rax,%r12)
movq 0x20(%rsp), %r15
jne 0xa89fd
movb $0x1, (%rax,%r12)
movq 0x8(%r14), %rax
leaq 0x1(%r15), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rax,%rdx), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax,%rdx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0xa8919
movq %rax, %rcx
movq 0x10(%r14), %rax
movb $0x0, (%rax,%r12)
cmpq %rbx, %rcx
jb 0xa8a3e
cmpb $0x0, (%rax,%r13)
jne 0xa8a6e
movb $0x1, (%rax,%r13)
movq 0x8(%r14), %rax
incq %r15
movq 0x10(%rax,%rbp), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax,%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8919
movq 0x10(%r14), %rcx
movb $0x0, (%rcx,%r13)
movq %r13, %r12
cmpq %rbx, %rax
jae 0xa8a6e
imulq $0x18, %r12, %rbp
addq 0x8(%r14), %rbp
jmp 0xa8a57
xorl %ebx, %ebx
jmp 0xa8a6e
addq %rax, %rbp
jmp 0xa8a57
addq %rax, %rbp
movq %r13, %r12
leaq 0x60(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rbp)
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq %r12, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_s_create_self
static bcore_self_s* name_s_create_self( void )
{
    sc_t def = "\
        bcore_name_s = bcore_inst \
        { \
            tp_t key;\
            tp_t name_space;\
            private sd_t name;\
            shell st_s name_st;\
        }";
    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_name_s );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_s_init,    "bcore_fp_init",  "init"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_s_down,    "bcore_fp_down",  "down"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_s_copy,    "bcore_fp_copy",  "copy"     );
    bcore_self_s_push_ns_func( self, ( fp_t )name_s_get_name_st,   "bcore_fp_get",   "get_name_st" );
    bcore_self_s_push_ns_func( self, ( fp_t )name_s_set_name_st,   "bcore_fp_set",   "set_name_st" );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x245b7(%rip), %rdi     # 0xcd125
pushq $0x18
popq %rsi
pushq $0x8
popq %rdx
callq 0x64356
movq %rax, %rbx
leaq -0x7eb(%rip), %rsi      # 0xa8398
leaq 0x17c31(%rip), %rdx     # 0xc07bb
leaq 0x17c33(%rip), %rcx     # 0xc07c4
movq %rax, %rdi
callq 0x63a2b
leaq -0x7e2(%rip), %rsi      # 0xa83be
leaq 0x17c22(%rip), %rdx     # 0xc07c9
leaq 0xba3a(%rip), %rcx      # 0xb45e8
movq %rbx, %rdi
callq 0x63a2b
leaq -0x7f1(%rip), %rsi      # 0xa83cc
leaq 0x17c13(%rip), %rdx     # 0xc07d7
leaq 0x13189(%rip), %rcx     # 0xbbd54
movq %rbx, %rdi
callq 0x63a2b
leaq 0x1fb(%rip), %rsi       # 0xa8dd5
leaq 0x18d46(%rip), %rdx     # 0xc1927
leaq 0x245e1(%rip), %rcx     # 0xcd1c9
movq %rbx, %rdi
callq 0x63a2b
leaq 0x210(%rip), %rsi       # 0xa8e07
leaq 0x18d1c(%rip), %rdx     # 0xc191a
leaq 0x245d0(%rip), %rcx     # 0xcd1d5
movq %rbx, %rdi
callq 0x63a2b
movq %rbx, %rax
popq %rbx
retq