LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: flow_snk
static uz_t flow_snk( vd_t o, vc_t data, uz_t size )
{
    if( *( aware_t*)o != TYPEOF_st_s ) ERR( "object 'o' of type %u ('%s') must be st_s", *( aware_t*)o, ifnameof( *( aware_t*)o ) );
    st_s* s = o;
    if( s->space == 0 ) st_s_make_strong( s );
    if( s->space == 0 )
    {
        s->data = bcore_bn_alloc( NULL, 0, size < 7 ? 8 : size + 1, &s->space );
    }
    else if( s->space < s->size + size + 1 )
    {
        s->data = bcore_bn_alloc( s->data, s->space, ( s->space * 2 < s->size + size + 1 ) ? s->size + size + 1 : s->space * 2, &s->space );
    }
    bcore_memcpy( s->data + s->size, data, size );

    s->size += size;
    s->data[ s->size ] = 0;
    return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
movabsq $-0x503db0e6e1c2e704, %rax # imm = 0xAFC24F191E3D18FC
cmpq %rax, %r12
je 0x931ab
movq %r12, %rdi
callq 0x8eafa
leaq 0x323eb(%rip), %rdi     # 0xc5576
leaq 0x36e26(%rip), %rsi     # 0xc9fb8
leaq 0x37384(%rip), %rcx     # 0xca51d
movl $0x8af, %edx            # imm = 0x8AF
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x60031
leaq 0x18(%r14), %r12
movq 0x18(%r14), %rsi
testq %rsi, %rsi
jne 0x931c9
movq %r14, %rdi
callq 0x8ef5c
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x931ea
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
leaq (%rbx,%rax), %rdx
incq %rdx
cmpq %rdx, %rsi
jae 0x9320c
leaq (%rsi,%rsi), %rax
cmpq %rdx, %rax
cmovaq %rax, %rdx
jmp 0x931fd
leaq 0x1(%rbx), %rax
cmpq $0x7, %rbx
pushq $0x8
popq %rdx
cmovaeq %rax, %rdx
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rcx
callq 0x60259
movq %rax, %rdi
movq %rax, 0x8(%r14)
addq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x60300
movq 0x10(%r14), %rax
addq %rbx, %rax
movq %rax, 0x10(%r14)
movq 0x8(%r14), %rcx
movb $0x0, (%rcx,%rax)
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_st.c
// Function: flow_src
static uz_t flow_src( vd_t o, vd_t data, uz_t size )
{
    if( *( aware_t*)o != TYPEOF_st_s ) ERR( "object 'o' of type %u ('%s') must be st_s", *( aware_t*)o, ifnameof( *( aware_t*)o ) );
    st_s* s = o;
    if( s->space > 0 ) ERR( "String is strong. Only weak strings can be used as flow-source." );
    size = ( size > s->size ) ? s->size : size;
    bcore_memcpy( data, s->data, size );
    s->data += size;
    s->size -= size;
    return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
movabsq $-0x503db0e6e1c2e704, %rax # imm = 0xAFC24F191E3D18FC
cmpq %rax, %r12
je 0x9328f
movq %r12, %rdi
callq 0x8eafa
leaq 0x32945(%rip), %rdi     # 0xc5bb4
leaq 0x36d42(%rip), %rsi     # 0xc9fb8
leaq 0x372a0(%rip), %rcx     # 0xca51d
movl $0x8c5, %edx            # imm = 0x8C5
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x60031
cmpq $0x0, 0x18(%r14)
je 0x932b7
leaq 0x32917(%rip), %rdi     # 0xc5bb4
leaq 0x36d14(%rip), %rsi     # 0xc9fb8
leaq 0x3729c(%rip), %rcx     # 0xca547
movl $0x8c7, %edx            # imm = 0x8C7
xorl %eax, %eax
callq 0x60031
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x60300
addq %rbx, 0x8(%r14)
subq %rbx, 0x10(%r14)
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_st.c
// Function: p_errorvf
static void p_errorvf( const st_s* o, sc_t format, va_list args )
{
    st_s* context = st_s_show_line_context( o, 0 );
    st_s* msg     = st_s_createvf( format, args );
    bcore_err( "st_s source parse error:\n%s%s\n", context->sc, msg->sc );
    st_s_discard( msg );
    st_s_discard( context );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
xorl %esi, %esi
callq 0x9022f
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8eb93
movq %rax, %rbx
movq 0x8(%r15), %rsi
movq 0x8(%rax), %rdx
leaq 0x3726d(%rip), %rdi     # 0xca587
xorl %eax, %eax
callq 0x5ffac
movq %rbx, %rdi
callq 0x8edd4
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8edd4
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: parse_fv
static void parse_fv( st_s* o, sc_t format, va_list args )
{
    if( o->space > 0 ) ERR( "String is strong. Only weak strings can be used as flow-source." );
    uz_t size = st_s_parse_fv( o, 0, o->size, format, args );
    o->data += size;
    o->size -= size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x9336c
leaq 0x2410a(%rip), %rdi     # 0xb745c
leaq 0x36c5f(%rip), %rsi     # 0xc9fb8
leaq 0x371e7(%rip), %rcx     # 0xca547
movl $0x8de, %edx            # imm = 0x8DE
xorl %eax, %eax
callq 0x60031
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
movq %r14, %r8
callq 0x91df8
addq %rax, 0x8(%rbx)
subq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: parse_em_fv
static er_t parse_em_fv( st_s* o, sc_t format, va_list args )
{
    if( o->space > 0 ) ERR( "String is strong. Only weak strings can be used as flow-source." );
    uz_t size = 0;
    er_t er = st_s_parse_em_fv( o, 0, o->size, &size, format, args );
    o->data += size;
    o->size -= size;
    return er;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x933c7
leaq 0x32a66(%rip), %rdi     # 0xc5e13
leaq 0x36c04(%rip), %rsi     # 0xc9fb8
leaq 0x3718c(%rip), %rcx     # 0xca547
movl $0x8e8, %edx            # imm = 0x8E8
xorl %eax, %eax
callq 0x60031
movq %rsp, %r12
andq $0x0, (%r12)
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x91e8d
movq (%r12), %rcx
addq %rcx, 0x8(%rbx)
subq %rcx, 0x10(%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_st.c
// Function: set_index
static void set_index( st_s* o, s3_t index )
{
    if( o->space > 0 ) ERR( "String is strong. Only weak strings can be used as flow-source." );
    if( index > 0    ) ERR( "Index is out of range." );

    vd_t root = NULL;
    uz_t granted_space = 0;
    bcore_tbman_get_instance( o->data, &root, &granted_space );

    vd_t new_data = o->data + o->size + index;

    if( ( uz_t )( ptrdiff_t )( ( u0_t* )new_data - ( u0_t* )root ) >= granted_space )
    {
        ERR( "Index exceeds range of memory instance." );
    }

    o->data = new_data;
    o->size = -index;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
je 0x934a3
leaq 0x23fae(%rip), %rdi     # 0xb7437
leaq 0x36b28(%rip), %rsi     # 0xc9fb8
leaq 0x370b0(%rip), %rcx     # 0xca547
movl $0x904, %edx            # imm = 0x904
xorl %eax, %eax
callq 0x60031
testq %rbx, %rbx
jle 0x934c9
leaq 0x23f88(%rip), %rdi     # 0xb7437
leaq 0x36b02(%rip), %rsi     # 0xc9fb8
leaq 0x32507(%rip), %rcx     # 0xc59c4
movl $0x905, %edx            # imm = 0x905
xorl %eax, %eax
callq 0x60031
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rsp, %r12
andq $0x0, (%r12)
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x95093
movq 0x8(%r14), %r13
addq 0x10(%r14), %r13
addq %rbx, %r13
movq %r13, %rax
subq (%r15), %rax
cmpq (%r12), %rax
jb 0x93521
leaq 0x23f30(%rip), %rdi     # 0xb7437
leaq 0x36aaa(%rip), %rsi     # 0xc9fb8
leaq 0x37091(%rip), %rcx     # 0xca5a6
movl $0x90f, %edx            # imm = 0x90F
xorl %eax, %eax
callq 0x60031
movq %r13, 0x8(%r14)
negq %rbx
movq %rbx, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: check_sanity
static void check_sanity( vc_t o )
{
    bcore_inst_t_check_sizeof( TYPEOF_st_s, sizeof( st_s ) );

    if( TYPEOF_st_s != *(aware_t *)o ) ERR( "incorrect type value (%"PRItp_t") (expected st_s)", *(aware_t *)o );
    const st_s* s = o;

    if( ( s->space > 0 ) && ( s->space < s->size ) ) ERR( "space (%zu) < size (%zu)", s->space, s->size );
    if( s->data[ s->size ] != 0 )  ERR( "data section does not terminate in zero" );

    for( uz_t i = 0; i < s->size; i++ )
    {
        u0_t c = s->data[ i ];
        if( c < 10 || c >= 128 ) ERR( "invalid character '%c' in string", c );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movabsq $-0x503db0e6e1c2e704, %r14 # imm = 0xAFC24F191E3D18FC
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x834e3
movq (%rbx), %r8
cmpq %r14, %r8
je 0x93584
leaq 0x36f9f(%rip), %rdi     # 0xca509
leaq 0x36a47(%rip), %rsi     # 0xc9fb8
leaq 0x37056(%rip), %rcx     # 0xca5ce
movl $0x91e, %edx            # imm = 0x91E
xorl %eax, %eax
callq 0x60031
movq 0x18(%rbx), %r8
testq %r8, %r8
je 0x935b7
movq 0x10(%rbx), %r9
cmpq %r9, %r8
jae 0x935b7
leaq 0x36f6c(%rip), %rdi     # 0xca509
leaq 0x36a14(%rip), %rsi     # 0xc9fb8
leaq 0x3704e(%rip), %rcx     # 0xca5f9
movl $0x921, %edx            # imm = 0x921
xorl %eax, %eax
callq 0x60031
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x935e6
leaq 0x36f3d(%rip), %rdi     # 0xca509
leaq 0x369e5(%rip), %rsi     # 0xc9fb8
leaq 0x37038(%rip), %rcx     # 0xca612
movl $0x922, %edx            # imm = 0x922
xorl %eax, %eax
callq 0x60031
leaq 0x36f1c(%rip), %r14     # 0xca509
leaq 0x369c4(%rip), %r15     # 0xc9fb8
leaq 0x3703f(%rip), %r12     # 0xca63a
xorl %r13d, %r13d
cmpq 0x10(%rbx), %r13
jae 0x9362d
movq 0x8(%rbx), %rax
movzbl (%rax,%r13), %r8d
cmpb $0x9, %r8b
jg 0x93628
movq %r14, %rdi
movq %r15, %rsi
movl $0x927, %edx            # imm = 0x927
movq %r12, %rcx
xorl %eax, %eax
callq 0x60031
incq %r13
jmp 0x935fe
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_external_b_alloc
vd_t bcore_tbman_external_b_alloc( vd_t current_ptr, uz_t requested_bytes, uz_t* granted_bytes )
{
    if( requested_bytes == 0 )
    {
        if( current_ptr ) free( current_ptr );
        current_ptr = NULL;
        if( granted_bytes ) *granted_bytes = 0;
    }
    else
    {
        if( current_ptr )
        {
            current_ptr = realloc( current_ptr, requested_bytes );
        }
        else
        {
            current_ptr = malloc( requested_bytes );
        }
        if( !current_ptr ) ERR( "Failed allocating %zu bytes", requested_bytes );
        if( granted_bytes ) *granted_bytes = requested_bytes;
    }
    return current_ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
testq %rsi, %rsi
je 0x936a7
movq %rsi, %r14
testq %rdi, %rdi
je 0x936b7
movq %r14, %rsi
callq 0xd3f0
jmp 0x936bf
callq 0xd220
xorl %r14d, %r14d
movl $0x0, %r15d
jmp 0x936eb
movq %r14, %rdi
callq 0xd160
movq %rax, %r15
testq %rax, %rax
jne 0x936eb
leaq 0x37632(%rip), %rdi     # 0xcad00
leaq 0x37648(%rip), %rsi     # 0xcad1d
leaq 0x3764f(%rip), %rcx     # 0xcad2b
movl $0xa2, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x60031
testq %rbx, %rbx
je 0x936f3
movq %r14, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_down
void bcore_tbman_s_down( bcore_tbman_s* o )
{
    tbman_s_lock( o );
    external_manager_s_down( &o->external_manager );
    down_manager_s_down( &o->down_manager );

    if( o->data )
    {
        for( uz_t i = 0; i < o->size; i++ ) block_manager_s_discard( o->data[ i ] );
        free( o->data );
    }

    bcore_btree_vd_s_discard( o->internal_btree );

    if( o->block_size_array ) free( o->block_size_array );

    tbman_s_unlock( o );
    bcore_mutex_s_down( &o->mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x97ae2
leaq 0x40(%r14), %rdi
callq 0x96f03
movq 0xb0(%r14), %rdi
callq 0xa41b3
movq 0xb8(%r14), %rdi
callq 0xa2dc8
leaq 0xe0(%r14), %rdi
callq 0x96f03
leaq 0x150(%r14), %rdi
callq 0x96f03
leaq 0x1c0(%r14), %rdi
callq 0x96f03
leaq 0x230(%r14), %rdi
callq 0x96f03
movq 0x2a0(%r14), %rdi
callq 0xa41b3
cmpq $0x0, (%r14)
je 0x93be8
xorl %r12d, %r12d
movq (%r14), %rdi
cmpq 0x8(%r14), %r12
jae 0x93be3
movq (%rdi,%r12,8), %r15
testq %r15, %r15
je 0x93bde
movq %r15, %rdi
callq 0x96f03
movq %r15, %rdi
callq 0xd220
incq %r12
jmp 0x93bbc
callq 0xd220
movq 0x38(%r14), %rdi
callq 0xa41b3
movq 0x30(%r14), %rdi
callq 0xd220
movq %rbx, %rdi
callq 0x97b12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x979f9
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_create
bcore_tbman_s* bcore_tbman_s_create( uz_t pool_size, uz_t min_block_size, uz_t max_block_size, uz_t stepping_method, bl_t full_align )
{
    bcore_tbman_s* o = malloc( sizeof( bcore_tbman_s ) );
    if( !o ) ERR( "Failed allocating %zu bytes", sizeof( bcore_tbman_s ) );
    bcore_tbman_s_init( o, pool_size, min_block_size, max_block_size, stepping_method, full_align );
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl $0x2e8, %edi            # imm = 0x2E8
callq 0xd160
movq %rax, %r12
testq %rax, %rax
jne 0x93c68
leaq 0x37112(%rip), %rdi     # 0xcad5a
leaq 0x370ce(%rip), %rsi     # 0xcad1d
leaq 0x370d5(%rip), %rcx     # 0xcad2b
movl $0x2e8, %r8d            # imm = 0x2E8
movl $0x71d, %edx            # imm = 0x71D
xorl %eax, %eax
callq 0x60031
movzbl %bpl, %r9d
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x93792
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_tbman.c
// Function: bcore_tbman_s_fork
vd_t bcore_tbman_s_fork( bcore_tbman_s* o, vd_t ptr )
{
    if( !ptr ) return NULL;
    tbman_s_lock( o );
    tbman_s_fork( o, ptr );
    tbman_s_unlock( o );
    return ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0x93dbc
movq %rdi, %r13
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x97ae2
movq 0x38(%r13), %rdi
movq %rbx, %rsi
callq 0xa4867
testq %rax, %rax
je 0x93d43
movq %rax, %r12
movq %rbx, %r15
subq %rax, %r15
cmpq 0x10(%r13), %r15
jae 0x93d43
movq 0x8(%r12), %r13
movq 0x30(%r12), %rcx
testq %rcx, %rcx
jne 0x93d32
movzwl 0x10(%r12), %esi
shll $0x3, %esi
pushq $0x1
popq %rdi
callq 0xd370
movq %rax, %rcx
movq %rax, 0x30(%r12)
movq %r15, %rax
xorl %edx, %edx
divq %r13
movzwl %ax, %eax
leaq (%rcx,%rax,8), %r12
jmp 0x93db0
movq 0xb8(%r13), %rdi
movq %rbx, %rsi
callq 0xa349e
movq %rax, %r15
testq %rax, %rax
jne 0x93d7b
leaq 0x374dd(%rip), %rdi     # 0xcb23e
leaq 0x36fb5(%rip), %rsi     # 0xcad1d
leaq 0x374e7(%rip), %rcx     # 0xcb256
movl $0x511, %edx            # imm = 0x511
xorl %eax, %eax
callq 0x60031
movq 0x8(%r15), %r12
movq %rbx, %rax
subq (%r15), %rax
cmpq (%r12), %rax
jb 0x93dac
leaq 0x374ac(%rip), %rdi     # 0xcb23e
leaq 0x36f84(%rip), %rsi     # 0xcad1d
leaq 0x374b6(%rip), %rcx     # 0xcb256
movl $0x513, %edx            # imm = 0x513
xorl %eax, %eax
callq 0x60031
addq $0x8, %r12
incq (%r12)
movq %r14, %rdi
callq 0x97b12
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_release
void bcore_tbman_s_release( bcore_tbman_s* o, vd_t ptr )
{
    if( !ptr ) return;
    tbman_s_lock( o );
    tbman_s_release( o, ptr );
    tbman_s_unlock( o );
}

// Assembly:
testq %rsi, %rsi
je 0x93e00
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c0(%rdi), %r15
movq %r15, %rdi
callq 0x97ae2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x93e01
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x97b12
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: tbman_s_release
static void tbman_s_release( bcore_tbman_s* o, vd_t ptr )
{
    vd_t block_ptr = bcore_btree_vd_s_largest_below_equal( o->internal_btree, ptr );
    if( block_ptr && ( ( ptrdiff_t )( (u0_t*)ptr - (u0_t*)block_ptr ) < o->pool_size ) )
    {
        token_manager_s_release( block_ptr, ptr );
    }
    else
    {
        external_manager_s_release( &o->external_manager, ptr );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0xa4867
testq %rax, %rax
je 0x93e3f
movq %r14, %rcx
subq %rax, %rcx
cmpq 0x10(%rbx), %rcx
jae 0x93e3f
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x96f6d
movq 0xb8(%rbx), %rdi
movq %r14, %rsi
callq 0xa349e
movq %rax, %r15
testq %rax, %rax
jne 0x93e77
leaq 0x37464(%rip), %rdi     # 0xcb2c1
leaq 0x36eb9(%rip), %rsi     # 0xcad1d
leaq 0x373eb(%rip), %rcx     # 0xcb256
movl $0x51d, %edx            # imm = 0x51D
xorl %eax, %eax
callq 0x60031
addq $0x40, %rbx
movq (%r15), %rsi
movq 0x8(%r15), %r12
subq %rsi, %r14
cmpq (%r12), %r14
jb 0x93eaf
leaq 0x3742f(%rip), %rdi     # 0xcb2c1
leaq 0x36e84(%rip), %rsi     # 0xcad1d
leaq 0x373b6(%rip), %rcx     # 0xcb256
movl $0x51f, %edx            # imm = 0x51F
xorl %eax, %eax
callq 0x60031
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x971cc
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_release_obj
void bcore_tbman_s_release_obj( bcore_tbman_s* o, fp_down_obj down, vd_t ptr )
{
    if( !ptr ) return;
    tbman_s_lock( o );
    tbman_s_release_obj( o, down, ptr );
    tbman_s_unlock( o );
}

// Assembly:
testq %rdx, %rdx
je 0x93f9b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x97ae2
testq %r14, %r14
je 0x9401d
movq 0x38(%r13), %rdi
movq %r15, %rsi
callq 0xa4867
testq %rax, %rax
je 0x93f9c
movq %rax, %r12
movq %r15, %rax
subq %r12, %rax
cmpq 0x10(%r13), %rax
jae 0x93f9c
movq 0x8(%r12), %rbp
movq 0x30(%r12), %rcx
xorl %edx, %edx
divq %rbp
movzwl %ax, %r13d
imulq %r13, %rbp
addq %r12, %rbp
testq %rcx, %rcx
je 0x94092
movq (%rcx,%r13,8), %rax
testq %rax, %rax
je 0x940c4
decq %rax
movq %rax, (%rcx,%r13,8)
cmpq %r15, %rbp
jne 0x940fa
movq 0x38(%r12), %rax
testq %rax, %rax
jne 0x93f75
movq %r12, %rdi
callq 0x97286
movq 0x38(%r12), %rax
cmpq $0x0, (%rax,%r13,8)
jne 0x940fa
movq 0x40(%r12), %rdi
movq %r14, %rsi
callq 0x9729f
movq 0x38(%r12), %rcx
movq %rax, (%rcx,%r13,8)
jmp 0x940fa
retq
movq 0xb8(%r13), %rdi
movq %r15, %rsi
callq 0xa349e
movq %rax, %r12
testq %rax, %rax
jne 0x93fd4
leaq 0x37433(%rip), %rdi     # 0xcb3ed
leaq 0x36d5c(%rip), %rsi     # 0xcad1d
leaq 0x3728e(%rip), %rcx     # 0xcb256
movl $0x528, %edx            # imm = 0x528
xorl %eax, %eax
callq 0x60031
movq (%r12), %rbp
movq 0x8(%r12), %r12
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x9402d
decq %rax
movq %rax, 0x8(%r12)
cmpq %r15, %rbp
jne 0x940fa
cmpq $0x0, 0x10(%r12)
jne 0x940fa
movq 0xd0(%r13), %rdi
movq %r14, %rsi
callq 0x9729f
movq %rax, 0x10(%r12)
jmp 0x940fa
movq %r13, %rdi
movq %r15, %rsi
callq 0x93e01
jmp 0x940fa
leaq 0x40(%r13), %rdi
cmpq $0x0, 0x10(%r12)
jne 0x94085
movq %rdi, (%rsp)
movq 0xd8(%r13), %rdi
callq 0x97b12
cmpq %r15, %rbp
je 0x9406f
leaq 0x37398(%rip), %rdi     # 0xcb3ed
leaq 0x36cc1(%rip), %rsi     # 0xcad1d
leaq 0x37295(%rip), %rcx     # 0xcb2f8
movl $0x53e, %edx            # imm = 0x53E
xorl %eax, %eax
callq 0x60031
movq %r15, %rdi
callq *%r14
movq 0xd8(%r13), %rdi
callq 0x97ae2
movq (%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x971cc
jmp 0x940fa
movq 0x18(%r12), %rdi
callq 0x97b12
cmpq %r15, %rbp
je 0x940df
leaq 0x37234(%rip), %rdi     # 0xcb2dc
leaq 0x36c6e(%rip), %rsi     # 0xcad1d
leaq 0x37242(%rip), %rcx     # 0xcb2f8
movl $0x1d9, %edx            # imm = 0x1D9
xorl %eax, %eax
callq 0x60031
jmp 0x940df
movq 0x38(%r12), %rax
testq %rax, %rax
je 0x940d5
cmpq $0x0, (%rax,%r13,8)
jne 0x940ef
movq 0x18(%r12), %rdi
callq 0x97b12
movq %r15, %rdi
callq *%r14
movq 0x18(%r12), %rdi
callq 0x97ae2
movq %r12, %rdi
movl %r13d, %esi
callq 0x96f7e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x97b12
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_references
uz_t bcore_tbman_s_references( bcore_tbman_s* o, vc_t ptr )
{
    if( !ptr ) return 0;
    tbman_s_lock( o );
    uz_t n = tbman_s_references( o, ptr );
    tbman_s_unlock( o );
    return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x949d5
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x97ae2
movq 0x38(%r15), %rdi
movq %r14, %rsi
callq 0xa4867
testq %rax, %rax
je 0x949a9
movq %rax, %rcx
movq %r14, %rax
subq %rcx, %rax
cmpq 0x10(%r15), %rax
jae 0x949a9
movq 0x30(%rcx), %rsi
testq %rsi, %rsi
je 0x949ee
xorl %edx, %edx
divq 0x8(%rcx)
movzwl %ax, %eax
leaq (%rsi,%rax,8), %rcx
jmp 0x949cd
movq 0xb8(%r15), %rdi
movq %r14, %rsi
callq 0xa349e
testq %rax, %rax
je 0x949da
movq 0x8(%rax), %rcx
subq (%rax), %r14
cmpq (%rcx), %r14
jae 0x949da
addq $0x8, %rcx
movq (%rcx), %r14
incq %r14
jmp 0x949dd
xorl %r14d, %r14d
jmp 0x949e5
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x97b12
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %r14
jmp 0x949dd
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_b_alloc
vd_t bcore_tbman_s_b_alloc( bcore_tbman_s* o, vd_t current_ptr, uz_t requested_bytes, uz_t* granted_bytes )
{
    tbman_s_lock( o );
    vd_t ret = NULL;
    if( requested_bytes == 0 )
    {
        if( current_ptr )
        {
            tbman_s_mem_free( o, current_ptr, NULL );
        }
        if( granted_bytes ) *granted_bytes = 0;
    }
    else
    {
        if( current_ptr )
        {
            ret = tbman_s_mem_realloc( o, current_ptr, NULL, requested_bytes, granted_bytes );
        }
        else
        {
            ret = tbman_s_mem_alloc( o, requested_bytes, granted_bytes );
        }
    }
    tbman_s_unlock( o );
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x97ae2
testq %r13, %r13
je 0x94a37
movq %r12, %rdi
testq %r15, %r15
je 0x94a57
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %rcx
movq %r14, %r8
callq 0x94ae9
jmp 0x94a62
testq %r15, %r15
je 0x94a49
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x94a7a
testq %r14, %r14
je 0x94a52
andq $0x0, (%r14)
xorl %r14d, %r14d
jmp 0x94a65
movq %r13, %rsi
movq %r14, %rdx
callq 0x94cc2
movq %rax, %r14
movq %rbx, %rdi
callq 0x97b12
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: tbman_s_mem_free
static void tbman_s_mem_free( bcore_tbman_s* o, vd_t current_ptr, const uz_t* current_bytes )
{
    if( current_bytes && *current_bytes <= o->max_block_size && o->aligned )
    {
        token_manager_s* token_manager = ( token_manager_s* )( ( intptr_t )current_ptr & ~( intptr_t )( o->pool_size - 1 ) );
        token_manager_s_free( token_manager, current_ptr );
    }
    else
    {
        vd_t block_ptr = bcore_btree_vd_s_largest_below_equal( o->internal_btree, current_ptr );
        if( block_ptr && ( ( ptrdiff_t )( (u0_t*)current_ptr - (u0_t*)block_ptr ) < o->pool_size ) )
        {
            token_manager_s_free( block_ptr, current_ptr );
        }
        else
        {
            external_manager_s_free( &o->external_manager, current_ptr );
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x94aa4
movq (%rdx), %rax
cmpq 0x20(%r14), %rax
ja 0x94aa4
cmpb $0x1, 0x28(%r14)
jne 0x94aa4
xorl %edi, %edi
subq 0x10(%r14), %rdi
andq %rbx, %rdi
jmp 0x94ac4
movq 0x38(%r14), %rdi
movq %rbx, %rsi
callq 0xa4867
testq %rax, %rax
je 0x94ad3
movq %rbx, %rcx
subq %rax, %rcx
cmpq 0x10(%r14), %rcx
jae 0x94ad3
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x96f6d
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x976ae
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: tbman_s_mem_alloc
static vd_t tbman_s_mem_alloc( bcore_tbman_s* o, uz_t requested_bytes, uz_t* granted_bytes )
{
    block_manager_s* block_manager = NULL;
    for( uz_t i = 0; i < o->size; i++ )
    {
        if( requested_bytes <= o->block_size_array[ i ] )
        {
            block_manager = o->data[ i ];
            break;
        }
    }

    vd_t reserved_ptr = NULL;
    if( block_manager )
    {
        reserved_ptr = block_manager_s_alloc( block_manager );
        if( granted_bytes ) *granted_bytes = block_manager->block_size;
    }
    else
    {
        reserved_ptr = external_manager_s_malloc( &o->external_manager, requested_bytes, granted_bytes );
    }

    return reserved_ptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x94d0b
movq 0x30(%rdi), %rdx
cmpq %rsi, (%rdx,%rax,8)
jae 0x94ce3
incq %rax
jmp 0x94ccf
movq (%rdi), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x94d0b
movq %r14, %rdi
callq 0x972b8
testq %rbx, %rbx
je 0x94d03
movq 0x8(%r14), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x40, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x976fe
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_bn_alloc
vd_t bcore_tbman_s_bn_alloc( bcore_tbman_s* o, vd_t current_ptr, uz_t current_bytes, uz_t requested_bytes, uz_t* granted_bytes )
{
    tbman_s_lock( o );
    vd_t ret = NULL;
    if( requested_bytes == 0 )
    {
        if( current_bytes ) // 0 means current_ptr may not be used for free or realloc
        {
            tbman_s_mem_free( o, current_ptr, &current_bytes );
        }
        if( granted_bytes ) *granted_bytes = 0;
    }
    else
    {
        if( current_bytes ) // 0 means current_ptr may not be used for free or realloc
        {
            ret = tbman_s_mem_realloc( o, current_ptr, &current_bytes, requested_bytes, granted_bytes );
        }
        else
        {
            ret = tbman_s_mem_alloc( o, requested_bytes, granted_bytes );
        }
    }
    tbman_s_unlock( o );
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, (%rsp)
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x97ae2
testq %r13, %r13
je 0x94d6b
testq %rbp, %rbp
je 0x94d8c
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
movq %r14, %r8
callq 0x94ae9
jmp 0x94d9a
testq %rbp, %rbp
je 0x94d7e
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x94a7a
testq %r14, %r14
je 0x94d87
andq $0x0, (%r14)
xorl %r14d, %r14d
jmp 0x94d9d
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x94cc2
movq %rax, %r14
movq %rbx, %rdi
callq 0x97b12
movq %r14, %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_tbman.c
// Function: bcore_tbman_s_get_instance
void bcore_tbman_s_get_instance( bcore_tbman_s* o, vc_t ptr, vd_t* root, uz_t* granted_space )
{
    tbman_s_lock( o );
    vd_t block_ptr = bcore_btree_vd_s_largest_below_equal( o->internal_btree, ( vd_t )ptr );
    if( block_ptr && ( ( ptrdiff_t )( (u0_t*)ptr - (u0_t*)block_ptr ) < o->pool_size ) )
    {
        token_manager_s* token_manager = block_ptr;
        if( root ) *root = token_manager_s_root( token_manager, ptr );
        if( granted_space ) *granted_space = token_manager->block_size;
    }
    else
    {
        external_manager_s_get_instance( &o->external_manager, ptr, root, granted_space );
    }
    tbman_s_unlock( o );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x97ae2
movq 0x38(%rbp), %rdi
movq %r13, %rsi
callq 0xa4867
testq %rax, %rax
je 0x94ebf
movq %rax, %r12
movq %r13, %rax
subq %r12, %rax
cmpq 0x10(%rbp), %rax
jae 0x94ebf
testq %r15, %r15
je 0x94eb0
movq 0x8(%r12), %rcx
xorl %esi, %esi
xorl %edx, %edx
divq %rcx
movzwl 0x10(%r12), %edx
imulq %rax, %rcx
addq %r12, %rcx
cmpq %rdx, %rax
cmovaeq %rsi, %rcx
movq %rcx, (%r15)
testq %rbx, %rbx
je 0x94f3e
addq $0x8, %r12
jmp 0x94f37
movq 0xb8(%rbp), %rdi
movq %r13, %rsi
callq 0xa349e
movq %rax, %rbp
testq %rax, %rax
jne 0x94ef7
leaq 0x36689(%rip), %rdi     # 0xcb566
leaq 0x35e39(%rip), %rsi     # 0xcad1d
leaq 0x3669b(%rip), %rcx     # 0xcb586
movl $0x4ae, %edx            # imm = 0x4AE
xorl %eax, %eax
callq 0x60031
movq 0x8(%rbp), %r12
subq (%rbp), %r13
cmpq (%r12), %r13
jb 0x94f26
leaq 0x3665a(%rip), %rdi     # 0xcb566
leaq 0x35e0a(%rip), %rsi     # 0xcad1d
leaq 0x3633c(%rip), %rcx     # 0xcb256
movl $0x4b0, %edx            # imm = 0x4B0
xorl %eax, %eax
callq 0x60031
testq %r15, %r15
je 0x94f32
movq (%rbp), %rax
movq %rax, (%r15)
testq %rbx, %rbx
je 0x94f3e
movq (%r12), %rax
movq %rax, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x97b12
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_total_granted_space
uz_t bcore_tbman_s_total_granted_space( bcore_tbman_s* o )
{
    tbman_s_lock( o );
    uz_t space = tbman_s_total_alloc( o );
    tbman_s_unlock( o );
    return space;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x97ae2
movq %rbx, %rdi
callq 0x950fd
movq %rax, %rbx
movq %r14, %rdi
callq 0x97b12
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_total_instances
uz_t bcore_tbman_s_total_instances( bcore_tbman_s* o )
{
    tbman_s_lock( o );
    uz_t size = tbman_s_total_instances( o );
    tbman_s_unlock( o );
    return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x97ae2
movq %rbx, %rdi
callq 0x95157
movq %rax, %rbx
movq %r14, %rdi
callq 0x97b12
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_total_references
uz_t bcore_tbman_s_total_references( bcore_tbman_s* o )
{
    tbman_s_lock( o );
    uz_t size = tbman_s_total_references( o );
    tbman_s_unlock( o );
    return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x97ae2
movq %rbx, %rdi
callq 0x951b1
movq %rax, %rbx
movq %r14, %rdi
callq 0x97b12
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: bcore_tbman_s_for_each_instance
void bcore_tbman_s_for_each_instance( bcore_tbman_s* o, void (*cb)( vd_t arg, vd_t ptr, uz_t space ), vd_t arg )
{
    if( !cb ) return;
    sz_t size = bcore_tbman_s_total_instances( o );
    if( !size ) return;

    bcore_tbman_mnode_arr arr;
    arr.data  = malloc( sizeof( bcore_tbman_mnode ) * size );
    arr.space = size;
    arr.size  = 0;

    tbman_s_lock( o );
    tbman_s_for_each_instance( o, for_each_instance_collect_callback, &arr );
    tbman_s_unlock( o );

    assert( arr.size == arr.space );

    for( sz_t i = 0; i < size; i++ ) cb( arg, arr.data[ i ].p, arr.data[ i ].s );

    free( arr.data );
}

// Assembly:
testq %rsi, %rsi
je 0x9532e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x95123
testq %rax, %rax
je 0x95320
movq %rax, %rdi
shlq $0x4, %rdi
movq %rax, %r15
callq 0xd160
movq %rax, %rbp
movq %rax, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %r15, 0x20(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0x2c0(%r12), %rdi
movq %rdi, (%rsp)
callq 0x97ae2
movq 0x8(%r12), %rax
addq $0x8, %rbp
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %rdx
jae 0x952b3
movq (%r12), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %edi, %edi
cmpq 0x20(%rsi), %rdi
jae 0x952ae
movq 0x18(%rsi), %r8
movq (%r8,%rdi,8), %r8
movzwl 0x12(%r8), %r9d
movq %rcx, %r10
shlq $0x4, %r10
addq %rbp, %r10
addl %r9d, %r9d
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x952a9
movzwl 0x48(%r8,%r11), %r13d
movq 0x8(%r8), %r15
imulq %r15, %r13
addq %r8, %r13
movq %r13, -0x8(%r10,%r11,8)
movq %r15, (%r10,%r11,8)
incq %rcx
movq %rcx, 0x18(%rsp)
addq $0x2, %r11
jmp 0x9527c
incq %rdi
jmp 0x95259
incq %rdx
jmp 0x9524a
leaq 0x75(%rip), %rax        # 0x9532f
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rdx)
movq 0xb8(%r12), %rdi
leaq 0x24d2(%rip), %rsi      # 0x977ac
callq 0xa36f1
movq (%rsp), %rdi
callq 0x97b12
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
testq %rax, %rax
cmovgq %rax, %r12
pushq $0x8
popq %r15
movq 0x10(%rsp), %rdi
subq $0x1, %r12
jb 0x9531b
movq -0x8(%rdi,%r15), %rsi
movq (%rdi,%r15), %rdx
movq %rbx, %rdi
callq *%r14
addq $0x10, %r15
jmp 0x952fb
callq 0xd220
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: block_manager_s_total_alloc
static uz_t block_manager_s_total_alloc( const block_manager_s* o )
{
    uz_t sum = 0;
    for( uz_t i = 0; i < o->size; i++ )
    {
        sum += token_manager_s_total_alloc( o->data[ i ] );
    }
    return sum;
}

// Assembly:
movq 0x20(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x95c48
movq 0x18(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
movzwl 0x12(%rsi), %r8d
imulq 0x8(%rsi), %r8
addq %r8, %rax
incq %rdx
jmp 0x95c29
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: block_manager_s_total_space
static uz_t block_manager_s_total_space( const block_manager_s* o )
{
    uz_t sum = 0;
    for( uz_t i = 0; i < o->size; i++ )
    {
        sum += token_manager_s_total_space( o->data[ i ] );
    }
    return sum;
}

// Assembly:
movq 0x20(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x95c6f
movq 0x18(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
movzwl 0x10(%rsi), %r8d
addq (%rsi), %rax
leaq (%rax,%r8,2), %rax
incq %rdx
jmp 0x95c51
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: tbman_s_internal_total_alloc
static uz_t tbman_s_internal_total_alloc( const bcore_tbman_s* o )
{
    uz_t sum = 0;
    for( uz_t i = 0; i < o->size; i++ )
    {
        sum += block_manager_s_total_alloc( o->data[ i ] );
    }
    return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x95cc8
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x95c21
addq %rax, %r14
incq %r12
jmp 0x95caf
movq %r14, %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_tbman.c
// Function: tbman_s_internal_total_instances
static uz_t tbman_s_internal_total_instances( const bcore_tbman_s* o )
{
    uz_t sum = 0;
    for( uz_t i = 0; i < o->size; i++ )
    {
        sum += block_manager_s_total_instances( o->data[ i ] );
    }
    return sum;
}

// Assembly:
movq 0x8(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rcx, %rdx
je 0x95d41
movq (%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x20(%rsi), %r9
xorl %r8d, %r8d
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x95d39
movq 0x18(%rsi), %r11
movq (%r11,%r10,8), %r11
movzwl 0x12(%r11), %r11d
addq %r11, %r8
incq %r10
jmp 0x95d1f
addq %r8, %rax
incq %rdx
jmp 0x95d09
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: tbman_s_internal_total_references
static uz_t tbman_s_internal_total_references( const bcore_tbman_s* o )
{
    uz_t sum = 0;
    for( uz_t i = 0; i < o->size; i++ )
    {
        sum += block_manager_s_total_references( o->data[ i ] );
    }
    return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rcx, %rdx
je 0x95ddb
movq (%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x20(%rsi), %r9
xorl %r8d, %r8d
xorl %r10d, %r10d
cmpq %r9, %r10
je 0x95dd3
movq 0x18(%rsi), %r11
movq (%r11,%r10,8), %r11
movzwl 0x12(%r11), %ebx
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq %r15, %rbx
je 0x95dcb
incq %r14
movq 0x30(%r11), %r12
testq %r12, %r12
je 0x95dc6
movzwl 0x48(%r11,%r15,2), %r13d
addq (%r12,%r13,8), %r14
incq %r15
jmp 0x95dab
addq %r14, %r8
incq %r10
jmp 0x95d93
addq %r8, %rax
incq %rdx
jmp 0x95d7d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: instance_diagnostics
static void instance_diagnostics( vd_t arg, vd_t ptr, uz_t space )
{
    printf( "ptr = %p, space = %5zu", ptr, space );
    if( bcore_name_try_name( ( ( tp_t* )ptr )[ 0 ] ) )
    {
        printf( ", aware of = '%s'", nameof( ( ( tp_t* )ptr )[ 0 ] ) );
        if( bcore_name_try_name( ( ( tp_t* )ptr )[ 1 ] ) )
        {
            printf( ", spect of = '%s'", nameof( ( ( tp_t* )ptr )[ 1 ] ) );
        }
    }
    printf( "\n" );
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x35948(%rip), %rdi     # 0xcb746
xorl %eax, %eax
callq 0xd060
movq (%rbx), %rdi
callq 0x71db6
testq %rax, %rax
je 0x95e53
movq (%rbx), %rdi
callq 0x71db6
leaq 0x3593c(%rip), %rdi     # 0xcb75d
movq %rax, %rsi
xorl %eax, %eax
callq 0xd060
movq 0x8(%rbx), %rdi
callq 0x71db6
testq %rax, %rax
je 0x95e53
movq 0x8(%rbx), %rdi
callq 0x71db6
leaq 0x35926(%rip), %rdi     # 0xcb76f
movq %rax, %rsi
xorl %eax, %eax
callq 0xd060
pushq $0xa
popq %rdi
popq %rbx
jmp 0xd150
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: block_manager_s_init
static void block_manager_s_init
    (
        block_manager_s* o,
        vd_t parent,
        uz_t pool_size,
        uz_t block_size,
        bl_t align,
        fp_lost_alignment lost_alignment_fp,
        bcore_btree_vd_s* internal_btree,
        down_manager_s* down_manager,
        bcore_mutex_s* mutex
    )
{
    bcore_memzero( o, sizeof( *o ) );
    o->parent = parent;
    o->aligned = true;
    o->sweep_hysteresis = 0.125;
    o->pool_size = pool_size;
    o->block_size = block_size;
    o->align = align;
    o->lost_alignment_fp = lost_alignment_fp;
    o->internal_btree = internal_btree;
    o->down_manager = down_manager;
    o->mutex = mutex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0x70
popq %rsi
callq 0x6028b
movq %r12, 0x48(%r13)
movb $0x1, 0x40(%r13)
movabsq $0x3fc0000000000000, %rax # imm = 0x3FC0000000000000
movq %rax, 0x38(%r13)
movq %r15, (%r13)
movq %r14, 0x8(%r13)
movb %bpl, 0x10(%r13)
movq %rbx, 0x50(%r13)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x58(%r13)
movq 0x50(%rsp), %rax
movq %rax, 0x68(%r13)
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_tbman.c
// Function: block_manager_s_down
static void block_manager_s_down( block_manager_s* o )
{
    if( o->data )
    {
        for( uz_t i = 0; i < o->size; i++ ) token_manager_s_discard( o->data[ i ] );
        free( o->data );
        o->data = NULL;
        o->size = o->space = 0;
    }
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0x96f47
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
cmpq 0x20(%rbx), %r15
jae 0x96f31
movq (%rdi,%r15,8), %rdi
callq 0x96f48
incq %r15
jmp 0x96f19
callq 0xd220
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: block_manager_s_empty_tail
static uz_t block_manager_s_empty_tail( const block_manager_s* o )
{
    if( o->size == 0 ) return 0;
    uz_t empty_index = o->size;
    while( empty_index > 0 && token_manager_s_is_empty( o->data[ empty_index - 1 ] ) ) empty_index--;
    return o->size - empty_index;
}

// Assembly:
movq 0x20(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x971cb
subq $0x1, %rcx
jb 0x971cb
movq 0x18(%rdi), %rdx
movq (%rdx,%rcx,8), %rdx
cmpw $0x0, 0x12(%rdx)
jne 0x971cb
incq %rax
jmp 0x971b1
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: external_manager_s_free_ext
static void external_manager_s_free_ext( external_manager_s* o, vd_t ptr, ext_s* ext )
{
    // reference control
    if( ext->rc_count )
    {
        ext->rc_count--;
        return;
    }

    if( ext->rc_down )
    {
        down_s* down = ext->rc_down;
        bcore_mutex_s_unlock( o->mutex );
        down->_( down, ptr );
        bcore_mutex_s_lock( o->mutex );
        assert( o->down_manager );
        down_s_discard( o->down_manager, down );
        ext->rc_down = NULL;
    }

    bcore_btree_pp_s_remove( o->ex_btree, ptr );
    ext_s_discard( o, ext );
    free( ptr );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x971f3
decq %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x97238
movq 0x98(%r15), %rdi
callq 0x97b12
movq %r12, %rdi
movq %r14, %rsi
callq *(%r12)
movq 0x98(%r15), %rdi
callq 0x97ae2
movq 0x90(%r15), %rdi
movq %r12, %rsi
callq 0x9716d
andq $0x0, 0x10(%rbx)
movq 0x78(%r15), %rdi
movq %r14, %rsi
callq 0xa35a4
cmpb $0x1, 0x88(%r15)
jne 0x9725c
xorl %edi, %edi
subq 0x80(%r15), %rdi
andq %rbx, %rdi
jmp 0x9726b
movq 0x70(%r15), %rdi
movq %rbx, %rsi
callq 0xa4867
movq %rax, %rdi
movq %rbx, %rsi
callq 0x96f6d
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd220
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: down_obj_s_create
static down_obj_s* down_obj_s_create( down_manager_s* o, fp_down_obj fp )
{
    down_obj_s* down = block_manager_s_alloc( &o->bm_down_obj );
    down->_._ = ( fp_down )_down_obj;
    down->fp = fp;
    return down;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x972b8
leaq 0x2ef(%rip), %rcx       # 0x9759e
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: down_arg_s_create
static down_arg_s* down_arg_s_create( down_manager_s* o, fp_down_arg fp, vc_t arg )
{
    down_arg_s* down = block_manager_s_alloc( &o->bm_down_arg );
    down->_._ = ( fp_down )_down_arg;
    down->fp = fp;
    down->arg = arg;
    return down;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
addq $0x70, %rdi
callq 0x972b8
leaq 0x13(%rip), %rcx        # 0x975d4
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: down_obj_arr_s_create
static down_obj_arr_s* down_obj_arr_s_create( down_manager_s* o, fp_down_obj fp, uz_t size, uz_t step )
{
    down_obj_arr_s* down = block_manager_s_alloc( &o->bm_down_obj_arr );
    down->_._ = ( fp_down )_down_obj_arr;
    down->fp = fp;
    down->size = size;
    down->step = step;
    return down;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
addq $0xe0, %rdi
callq 0x972b8
leaq -0x75(%rip), %rcx       # 0x975de
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: down_arg_arr_s_create
static down_arg_arr_s* down_arg_arr_s_create( down_manager_s* o, fp_down_arg fp, vc_t arg, uz_t size, uz_t step )
{
    down_arg_arr_s* down = block_manager_s_alloc( &o->bm_down_arg_arr );
    down->_._ = ( fp_down )_down_arg_arr;
    down->fp = fp;
    down->arg = arg;
    down->size = size;
    down->step = step;
    return down;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
addq $0x150, %rdi            # imm = 0x150
callq 0x972b8
leaq -0x89(%rip), %rcx       # 0x97606
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%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_tbman.c
// Function: external_manager_s_free
static void external_manager_s_free( external_manager_s* o, vd_t ptr )
{
    vd_t* ext_p = bcore_btree_pp_s_val( o->ex_btree, ptr );
    if( !ext_p )
    {
        ERR( "Attempt to free invalid memory" );
    }
    external_manager_s_free_ext( o, ptr, *ext_p );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x78(%rdi), %rdi
callq 0xa34a6
movq %rax, %r15
testq %rax, %rax
jne 0x976eb
leaq 0x33dbc(%rip), %rdi     # 0xcb48d
leaq 0x33645(%rip), %rsi     # 0xcad1d
leaq 0x33dc6(%rip), %rcx     # 0xcb4a5
movl $0x4a4, %edx            # imm = 0x4A4
xorl %eax, %eax
callq 0x60031
movq (%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x971cc
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: external_manager_s_malloc
static vd_t external_manager_s_malloc( external_manager_s* o, uz_t requested_bytes, uz_t* granted_bytes )
{
    vd_t ptr = aligned_alloc( TBMAN_ALIGN, requested_bytes );
    if( !ptr ) ERR( "Failed allocating %zu bytes.", requested_bytes );
    if( granted_bytes ) *granted_bytes = requested_bytes;
    ext_s* ext = ext_s_create( o );
    ext->size = requested_bytes;
    if( bcore_btree_pp_s_set( o->ex_btree, ptr, ext ) != 1 ) ERR( "Registering new address failed" );
    return ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0xd1d0
movq %rax, %rbx
testq %rax, %rax
jne 0x97745
leaq 0x33de8(%rip), %rdi     # 0xcb510
leaq 0x335ee(%rip), %rsi     # 0xcad1d
leaq 0x33df4(%rip), %rcx     # 0xcb52a
movl $0x47a, %edx            # imm = 0x47A
movq %r15, %r8
xorl %eax, %eax
callq 0x60031
testq %r12, %r12
je 0x9774e
movq %r15, (%r12)
movq %r14, %rdi
callq 0x972b8
movq %rax, %r12
pushq $0x18
popq %rsi
movq %rax, %rdi
callq 0x6028b
movq %r15, (%r12)
movq 0x78(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xa34eb
cmpl $0x1, %eax
je 0x9779d
leaq 0x33d8d(%rip), %rdi     # 0xcb510
leaq 0x33593(%rip), %rsi     # 0xcad1d
leaq 0x33db6(%rip), %rcx     # 0xcb547
movl $0x47e, %edx            # imm = 0x47E
xorl %eax, %eax
callq 0x60031
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq