LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: st_s_show_line_context
st_s* st_s_show_line_context( const st_s* o, uz_t pos )
{
    uz_t start = st_s_posofline( o, pos );
    uz_t end = st_s_find_char( o, pos, o->size, '\n' );
    st_s* s = st_s_create();
    st_s_push_st_d( s, st_s_crop( o, start, end ) );
    st_s_push_char( s, '\n' );
    st_s_push_char_n( s, ' ', pos - start );
    st_s_push_char(   s, '^' );
    st_s_push_char( s, '\n' );
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdx
cmpq %rsi, %rdx
movq %rsi, %r14
cmovbq %rdx, %r14
testq %r14, %r14
je 0x1166e3
movq 0x8(%r15), %rax
cmpb $0xa, -0x1(%rax,%r14)
je 0x1166e3
decq %r14
jne 0x1166d3
xorl %r14d, %r14d
movq %r15, %rdi
movq %rbx, %rsi
movl $0xa, %ecx
callq 0x1158c3
movq %rax, %r13
movl $0x20, %esi
xorl %edi, %edi
xorl %edx, %edx
callq 0xc832f
movq %rax, %r12
movabsq $-0x503db0e6e1c2e704, %rax # imm = 0xAFC24F191E3D18FC
movq %rax, (%r12)
leaq 0x3cfd3(%rip), %rax     # 0x1536ef
movq %rax, 0x8(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x11526b
movq %r12, %rdi
movq %rax, %rsi
callq 0x11556c
movq %r12, %rdi
movl $0xa, %esi
callq 0x115381
subq %r14, %rbx
movq %r12, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq 0x115408
movq %r12, %rdi
movl $0x5e, %esi
callq 0x115381
movq %r12, %rdi
movl $0xa, %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x115381
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: st_s_parse_errorf
static uz_t st_s_parse_errorf( const st_s* o, fp_st_s_parse_err errfp, vd_t arg, sz_t idx, sc_t format, ... )
{
    va_list args;
    va_start( args, format );
    st_s* msg = st_s_createvf( format, args );
    errfp( arg, o, idx, msg );
    st_s_discard( msg );
    va_end( args );
    return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbp
leaq 0x30(%rsp), %rcx
movq %r9, 0x28(%rcx)
testb %al, %al
je 0x118491
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rsp), %r14
movq %rcx, 0x10(%r14)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%r14)
movl $0x20, %esi
xorl %edi, %edi
xorl %edx, %edx
callq 0xc832f
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x113f9c
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq *0x8(%rsp)
testq %r15, %r15
je 0x1184f6
leaq -0x4157(%rip), %rdi     # 0x114397
movq %r15, %rsi
callq 0xc8352
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: st_s_parse_em_fv
er_t st_s_parse_em_fv( const st_s* o, uz_t start, uz_t end, uz_t* out_idx, sc_t format, va_list args )
{
    er_t err = 0;
    uz_t idx = st_s_parse_efv( o, start, end, st_s_parse_em_callback, &err, format, args );
    if( out_idx ) *out_idx = idx;
    return err;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %r8, %rax
movq %rcx, %rbx
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
movq %r9, (%rsp)
leaq 0x1b(%rip), %rcx        # 0x11893e
movq %rax, %r9
callq 0x1168ee
testq %rbx, %rbx
je 0x118933
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: st_s_parse_em_callback
static uz_t st_s_parse_em_callback( vd_t arg, const st_s* o, uz_t idx, st_s* msg )
{
    ASSERT( arg );
    er_t id = TYPEOF_parse_error;
    ( *( er_t* )arg ) = id;
    bcore_error_push_sc( id, msg->sc );
    return idx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
testq %rdi, %rdi
jne 0x11897a
leaq 0x1fcef(%rip), %rdi     # 0x138647
leaq 0x3fa5c(%rip), %rsi     # 0x1583bb
leaq 0x3eae1(%rip), %rdx     # 0x157447
leaq 0x3e5cb(%rip), %rcx     # 0x156f38
movl $0x88f, %r8d            # imm = 0x88F
xorl %eax, %eax
callq 0xc8053
movabsq $0x690af8765815ec4d, %rdi # imm = 0x690AF8765815EC4D
movq %rdi, (%r15)
movq 0x8(%r14), %rsi
callq 0xc86db
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: st_s_parse_em_fa
er_t st_s_parse_em_fa( const st_s* o, uz_t start, uz_t end, uz_t* out_idx, sc_t format, ... )
{
    va_list args;
    va_start( args, format );
    er_t err = st_s_parse_em_fv( o, start, end, out_idx, format, args );
    va_end( args );
    return err;
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
movq %r8, %r10
movq %rcx, %rbx
leaq 0x30(%rsp), %rcx
movq %r9, 0x28(%rcx)
testb %al, %al
je 0x1189ee
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000028, %rcx     # imm = 0x3000000028
movq %rcx, (%rax)
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
movq %rax, (%rsp)
leaq -0xe9(%rip), %rcx       # 0x11893e
movq %r10, %r9
callq 0x1168ee
testq %rbx, %rbx
je 0x118a37
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_st.c
// Function: c_char
static char c_char( sc_t o, uz_t on, sc_t f, uz_t* fi )
{
    uz_t i = *fi;
    char c = 3;  // ETX (end of text) when index is out of range
    if( f[ i ] == '\'' )
    {
        c = f[ ++i ];
        if( !f[ i ] || f[ ++i ] != '\'' ) ERR( "Format '%s' at position %zu: '<char>' expected.", f, i - 2 );
        i++;
    }
    else if( f[ i ] == '[' )
    {
        uz_t i0 = i;
        i++;
        int idx = atoi( f + i );
        if( idx >= 0 && idx < on ) c = o[ idx ];
        while( f[ i ] && f[ i ] != ']' ) i++;
        if( !f[ i ] || f[ i ] != ']' ) ERR( "Format '%s' at position %zu: [<index>] expected.", f, i0 );
        i++;
    }
    else
    {
        ERR( "Format '%s' at position %zu: '<char>' or [<index>] expected.", f, i );
    }
    *fi = i;
    return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq (%rcx), %r15
movzbl (%rdx,%r15), %eax
cmpl $0x5b, %eax
je 0x119dca
cmpl $0x27, %eax
jne 0x119e0a
movb 0x1(%r14,%r15), %bpl
testb %bpl, %bpl
je 0x119e62
leaq 0x2(%r15), %r12
cmpb $0x27, 0x2(%r14,%r15)
jne 0x119e68
jmp 0x119e91
movq %rsi, %r13
movq %rdi, %r12
leaq (%r15,%r14), %rdi
incq %rdi
callq 0xd2c0
movb $0x3, %bpl
testl %eax, %eax
js 0x119dee
movl %eax, %eax
cmpq %r13, %rax
jae 0x119dee
movb (%r12,%rax), %bpl
leaq 0x2(%r15), %r12
movzbl -0x1(%r14,%r12), %eax
testl %eax, %eax
je 0x119e39
cmpl $0x5d, %eax
je 0x119e94
incq %r12
jmp 0x119df2
leaq 0x3d591(%rip), %rdi     # 0x1573a2
leaq 0x3d120(%rip), %rsi     # 0x156f38
leaq 0x3d5eb(%rip), %rcx     # 0x15740a
movl $0x543, %edx            # imm = 0x543
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0xc80f6
movb $0x3, %bpl
movq %r15, %r12
jmp 0x119e94
leaq 0x3d562(%rip), %rdi     # 0x1573a2
leaq 0x3d0f1(%rip), %rsi     # 0x156f38
leaq 0x3d58b(%rip), %rcx     # 0x1573d9
movl $0x53e, %edx            # imm = 0x53E
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0xc80f6
jmp 0x119e94
incq %r15
movq %r15, %r12
leaq -0x2(%r12), %r9
leaq 0x3d52e(%rip), %rdi     # 0x1573a2
leaq 0x3d0bd(%rip), %rsi     # 0x156f38
leaq 0x3d527(%rip), %rcx     # 0x1573a9
movl $0x534, %edx            # imm = 0x534
movq %r14, %r8
xorl %eax, %eax
callq 0xc80f6
incq %r12
movq %r12, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0x119f05
movq %r12, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x39812(%rip), %r9      # 0x1536ef
cmovneq %rax, %r9
leaq 0x387e9(%rip), %rdi     # 0x1526d1
leaq 0x3d049(%rip), %rsi     # 0x156f38
leaq 0x3d59e(%rip), %rcx     # 0x157494
movl $0x8af, %edx            # imm = 0x8AF
movq %r12, %r8
xorl %eax, %eax
callq 0xc80f6
leaq 0x18(%r14), %r12
cmpq $0x0, 0x18(%r14)
jne 0x119f18
movq %r14, %rdi
callq 0x115160
movq (%r12), %rsi
testq %rsi, %rsi
je 0x119f42
movq 0x10(%r14), %rax
leaq (%rbx,%rax), %rdx
incq %rdx
cmpq %rdx, %rsi
jae 0x119f63
movq 0x8(%r14), %rdi
leaq (%rsi,%rsi), %rax
cmpq %rdx, %rax
cmovaq %rax, %rdx
jmp 0x119f57
leaq 0x1(%rbx), %rax
cmpq $0x7, %rbx
movl $0x8, %edx
cmovaeq %rax, %rdx
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rcx
callq 0xc8334
movq %rax, 0x8(%r14)
movq 0x8(%r14), %rdi
addq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc83f1
movq 0x10(%r14), %rax
addq %rbx, %rax
movq %rax, 0x10(%r14)
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_O1/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 0x119ff5
movq %r12, %rdi
callq 0xe0cbc
testq %rax, %rax
leaq 0x39722(%rip), %r9      # 0x1536ef
cmovneq %rax, %r9
leaq 0x38d14(%rip), %rdi     # 0x152cec
leaq 0x3cf59(%rip), %rsi     # 0x156f38
leaq 0x3d4ae(%rip), %rcx     # 0x157494
movl $0x8c5, %edx            # imm = 0x8C5
movq %r12, %r8
xorl %eax, %eax
callq 0xc80f6
cmpq $0x0, 0x18(%r14)
je 0x11a01d
leaq 0x38ce9(%rip), %rdi     # 0x152cec
leaq 0x3cf2e(%rip), %rsi     # 0x156f38
leaq 0x3d4ad(%rip), %rcx     # 0x1574be
movl $0x8c7, %edx            # imm = 0x8C7
xorl %eax, %eax
callq 0xc80f6
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0xc83f1
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_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
xorl %esi, %esi
callq 0x1166ad
movq %rax, %rbx
movl $0x20, %esi
xorl %edi, %edi
xorl %edx, %edx
callq 0xc832f
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x113f9c
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdx
leaq 0x3d46a(%rip), %rdi     # 0x1574fe
xorl %eax, %eax
callq 0xc8053
testq %r14, %r14
je 0x11a0af
leaq -0x5d10(%rip), %rdi     # 0x114397
movq %r14, %rsi
callq 0xc8352
testq %rbx, %rbx
je 0x11a0ce
leaq -0x5d24(%rip), %rdi     # 0x114397
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc8352
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x11a114
leaq 0x2b0a4(%rip), %rdi     # 0x14519e
leaq 0x3ce37(%rip), %rsi     # 0x156f38
leaq 0x3d3b6(%rip), %rcx     # 0x1574be
movl $0x8de, %edx            # imm = 0x8DE
xorl %eax, %eax
callq 0xc80f6
movq 0x10(%rbx), %rdx
movq %r15, (%rsp)
leaq -0x399d(%rip), %rcx     # 0x116786
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1168ee
addq %rax, 0x8(%rbx)
subq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x11a181
leaq 0x38de4(%rip), %rdi     # 0x152f4b
leaq 0x3cdca(%rip), %rsi     # 0x156f38
leaq 0x3d349(%rip), %rcx     # 0x1574be
movl $0x8e8, %edx            # imm = 0x8E8
xorl %eax, %eax
callq 0xc80f6
movq 0x10(%rbx), %rdx
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movq %r15, (%rsp)
leaq -0x185f(%rip), %rcx     # 0x11893e
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %r8
movq %r14, %r9
callq 0x1168ee
movq (%r12), %rcx
addq %rax, 0x8(%rbx)
subq %rax, 0x10(%rbx)
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0x11a26d
leaq 0x2af26(%rip), %rdi     # 0x145179
leaq 0x3ccde(%rip), %rsi     # 0x156f38
leaq 0x3d25d(%rip), %rcx     # 0x1574be
movl $0x904, %edx            # imm = 0x904
xorl %eax, %eax
callq 0xc80f6
testq %rbx, %rbx
jle 0x11a293
leaq 0x2af00(%rip), %rdi     # 0x145179
leaq 0x3ccb8(%rip), %rsi     # 0x156f38
leaq 0x38898(%rip), %rcx     # 0x152b1f
movl $0x905, %edx            # imm = 0x905
xorl %eax, %eax
callq 0xc80f6
xorl %eax, %eax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rsp, %r12
movq %rax, (%r12)
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x11c199
movq 0x8(%r14), %r13
addq 0x10(%r14), %r13
addq %rbx, %r13
movq %r13, %rax
subq (%r15), %rax
cmpq (%r12), %rax
jb 0x11a2eb
leaq 0x2aea8(%rip), %rdi     # 0x145179
leaq 0x3cc60(%rip), %rsi     # 0x156f38
leaq 0x3d23e(%rip), %rcx     # 0x15751d
movl $0x90f, %edx            # imm = 0x90F
xorl %eax, %eax
callq 0xc80f6
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_O1/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
movl $0x20, %esi
movq %r14, %rdi
callq 0x101bff
movq (%rbx), %r8
cmpq %r14, %r8
je 0x11a350
leaq 0x3d14a(%rip), %rdi     # 0x157480
leaq 0x3cbfb(%rip), %rsi     # 0x156f38
leaq 0x3d201(%rip), %rcx     # 0x157545
movl $0x91e, %edx            # imm = 0x91E
xorl %eax, %eax
callq 0xc80f6
movq 0x18(%rbx), %r8
testq %r8, %r8
je 0x11a383
movq 0x10(%rbx), %r9
cmpq %r9, %r8
jae 0x11a383
leaq 0x3d117(%rip), %rdi     # 0x157480
leaq 0x3cbc8(%rip), %rsi     # 0x156f38
leaq 0x3d1f9(%rip), %rcx     # 0x157570
movl $0x921, %edx            # imm = 0x921
xorl %eax, %eax
callq 0xc80f6
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x11a3b2
leaq 0x3d0e8(%rip), %rdi     # 0x157480
leaq 0x3cb99(%rip), %rsi     # 0x156f38
leaq 0x3d1e3(%rip), %rcx     # 0x157589
movl $0x922, %edx            # imm = 0x922
xorl %eax, %eax
callq 0xc80f6
cmpq $0x0, 0x10(%rbx)
je 0x11a3fe
leaq 0x3d0c0(%rip), %r14     # 0x157480
leaq 0x3cb71(%rip), %r15     # 0x156f38
leaq 0x3d1e3(%rip), %r12     # 0x1575b1
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movzbl (%rax,%r13), %r8d
cmpb $0x9, %r8b
jg 0x11a3f5
movq %r14, %rdi
movq %r15, %rsi
movl $0x927, %edx            # imm = 0x927
movq %r12, %rcx
xorl %eax, %eax
callq 0xc80f6
incq %r13
cmpq 0x10(%rbx), %r13
jb 0x11a3d1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11a44b
movq %rsi, %r14
testq %rdi, %rdi
je 0x11a460
movq %r14, %rsi
callq 0xd3e0
jmp 0x11a468
testq %rdi, %rdi
je 0x11a455
callq 0xd220
xorl %r14d, %r14d
movl $0x0, %r15d
jmp 0x11a494
movq %r14, %rdi
callq 0xd160
movq %rax, %r15
testq %rax, %rax
jne 0x11a494
leaq 0x3d801(%rip), %rdi     # 0x157c78
leaq 0x3d817(%rip), %rsi     # 0x157c95
leaq 0x3d81e(%rip), %rcx     # 0x157ca3
movl $0xa2, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0xc80f6
testq %rbx, %rbx
je 0x11a49c
movq %r14, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11f515
leaq 0x40(%r14), %rdi
callq 0x11ea00
movq 0xb0(%r14), %rdi
callq 0x131795
movq 0xb8(%r14), %rdi
callq 0x130377
leaq 0xe0(%r14), %rdi
callq 0x11ea00
leaq 0x150(%r14), %rdi
callq 0x11ea00
leaq 0x1c0(%r14), %rdi
callq 0x11ea00
leaq 0x230(%r14), %rdi
callq 0x11ea00
movq 0x2a0(%r14), %rdi
callq 0x131795
cmpq $0x0, (%r14)
je 0x11ab2b
cmpq $0x0, 0x8(%r14)
je 0x11ab23
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x11ab1a
movq %r15, %rdi
callq 0x11ea00
movq %r15, %rdi
callq 0xd220
incq %r12
cmpq 0x8(%r14), %r12
jb 0x11aafe
movq (%r14), %rdi
callq 0xd220
movq 0x38(%r14), %rdi
callq 0x131795
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x11ab42
callq 0xd220
movq %rbx, %rdi
callq 0x11f547
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11f3ee
// File: /workspace/github_c_makefile_star2_O1/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 0x11abb0
leaq 0x3d142(%rip), %rdi     # 0x157cd2
leaq 0x3d0fe(%rip), %rsi     # 0x157c95
leaq 0x3d105(%rip), %rcx     # 0x157ca3
movl $0x2e8, %r8d            # imm = 0x2E8
movl $0x71d, %edx            # imm = 0x71D
xorl %eax, %eax
callq 0xc80f6
movzbl %bpl, %r9d
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x11a53b
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x11ad18
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x11f515
movq 0x38(%r13), %rdi
movq %rbx, %rsi
callq 0x131e3e
testq %rax, %rax
je 0x11ac9d
movq %rax, %r15
movq %rbx, %r12
subq %rax, %r12
cmpq 0x10(%r13), %r12
jae 0x11ac9d
movq 0x8(%r15), %rbp
cmpq $0x0, 0x30(%r15)
jne 0x11ac87
movzwl 0x10(%r15), %r13d
shll $0x3, %r13d
movq %r13, %rdi
callq 0xd160
movq %rax, 0x30(%r15)
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0xd090
movq %r12, %rax
xorl %edx, %edx
divq %rbp
movzwl %ax, %r12d
shll $0x3, %r12d
addq 0x30(%r15), %r12
jmp 0x11ad0a
movq 0xb8(%r13), %rdi
movq %rbx, %rsi
callq 0x130a36
movq %rax, %r15
testq %rax, %rax
jne 0x11acd5
leaq 0x3d4fb(%rip), %rdi     # 0x1581b6
leaq 0x3cfd3(%rip), %rsi     # 0x157c95
leaq 0x3d505(%rip), %rcx     # 0x1581ce
movl $0x511, %edx            # imm = 0x511
xorl %eax, %eax
callq 0xc80f6
movq 0x8(%r15), %r12
movq %rbx, %rax
subq (%r15), %rax
cmpq (%r12), %rax
jb 0x11ad06
leaq 0x3d4ca(%rip), %rdi     # 0x1581b6
leaq 0x3cfa2(%rip), %rsi     # 0x157c95
leaq 0x3d4d4(%rip), %rcx     # 0x1581ce
movl $0x513, %edx            # imm = 0x513
xorl %eax, %eax
callq 0xc80f6
addq $0x8, %r12
incq (%r12)
movq %r14, %rdi
callq 0x11f547
jmp 0x11ad1a
xorl %ebx, %ebx
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_O1/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 0x11ad63
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c0(%rdi), %r15
movq %r15, %rdi
callq 0x11f515
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11ad64
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11f547
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x131e3e
testq %rax, %rax
je 0x11ada8
movq %rax, %rdi
movq %r14, %rax
subq %rdi, %rax
cmpq 0x10(%rbx), %rax
jae 0x11ada8
xorl %edx, %edx
divq 0x8(%rdi)
movzwl %ax, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11ea7f
movq 0xb8(%rbx), %rdi
movq %r14, %rsi
callq 0x130a36
movq %rax, %r15
testq %rax, %rax
jne 0x11ade0
leaq 0x3d473(%rip), %rdi     # 0x158239
leaq 0x3cec8(%rip), %rsi     # 0x157c95
leaq 0x3d3fa(%rip), %rcx     # 0x1581ce
movl $0x51d, %edx            # imm = 0x51D
xorl %eax, %eax
callq 0xc80f6
addq $0x40, %rbx
movq 0x8(%r15), %r12
subq (%r15), %r14
cmpq (%r12), %r14
jb 0x11ae12
leaq 0x3d441(%rip), %rdi     # 0x158239
leaq 0x3ce96(%rip), %rsi     # 0x157c95
leaq 0x3d3c8(%rip), %rcx     # 0x1581ce
movl $0x51f, %edx            # imm = 0x51F
xorl %eax, %eax
callq 0xc80f6
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11ecf5
// File: /workspace/github_c_makefile_star2_O1/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 0x11ba99
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x11f515
movq 0x38(%r15), %rdi
movq %r14, %rsi
callq 0x131e3e
testq %rax, %rax
je 0x11ba6d
movq %rax, %rcx
movq %r14, %rax
subq %rcx, %rax
cmpq 0x10(%r15), %rax
jae 0x11ba6d
movq 0x30(%rcx), %rsi
testq %rsi, %rsi
je 0x11bab2
xorl %edx, %edx
divq 0x8(%rcx)
movzwl %ax, %eax
leaq (%rsi,%rax,8), %rcx
jmp 0x11ba91
movq 0xb8(%r15), %rdi
movq %r14, %rsi
callq 0x130a36
testq %rax, %rax
je 0x11ba9e
movq 0x8(%rax), %rcx
subq (%rax), %r14
cmpq (%rcx), %r14
jae 0x11ba9e
addq $0x8, %rcx
movq (%rcx), %r14
incq %r14
jmp 0x11baa1
xorl %r14d, %r14d
jmp 0x11baa9
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x11f547
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %r14d
jmp 0x11baa1
// File: /workspace/github_c_makefile_star2_O1/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 0x11f515
testq %r13, %r13
je 0x11bafd
movq %r12, %rdi
testq %r15, %r15
je 0x11bb20
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %rcx
movq %r14, %r8
callq 0x11bbbe
jmp 0x11bb2b
testq %r15, %r15
je 0x11bb0f
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x11bb43
testq %r14, %r14
je 0x11bb1b
movq $0x0, (%r14)
xorl %r14d, %r14d
jmp 0x11bb2e
movq %r13, %rsi
movq %r14, %rdx
callq 0x11bdb7
movq %rax, %r14
movq %rbx, %rdi
callq 0x11f547
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0x11bb73
movq (%rdx), %rax
cmpq 0x20(%r14), %rax
ja 0x11bb73
cmpb $0x1, 0x28(%r14)
jne 0x11bb73
xorl %edi, %edi
subq 0x10(%r14), %rdi
andq %rbx, %rdi
subq %rdi, %rbx
movq %rbx, %rax
jmp 0x11bb93
movq 0x38(%r14), %rdi
movq %rbx, %rsi
callq 0x131e3e
testq %rax, %rax
je 0x11bba8
movq %rax, %rdi
movq %rbx, %rax
subq %rdi, %rax
cmpq 0x10(%r14), %rax
jae 0x11bba8
xorl %edx, %edx
divq 0x8(%rdi)
movzwl %ax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11ea7f
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f127
// File: /workspace/github_c_makefile_star2_O1/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), %rax
testq %rax, %rax
je 0x11bde0
movq 0x30(%rdi), %rcx
xorl %r14d, %r14d
xorl %edx, %edx
cmpq %rsi, (%rcx,%rdx,8)
jae 0x11bde5
incq %rdx
cmpq %rdx, %rax
jne 0x11bdd0
jmp 0x11bdec
xorl %r14d, %r14d
jmp 0x11bdec
movq (%rdi), %rax
movq (%rax,%rdx,8), %r14
testq %r14, %r14
je 0x11be0d
movq %r14, %rdi
callq 0x11edc1
testq %rbx, %rbx
je 0x11be05
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 0x11f177
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, 0x8(%rsp)
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x11f515
movq 0x8(%rsp), %rax
testq %r13, %r13
je 0x11be74
testq %rax, %rax
je 0x11be9a
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
movq %r14, %r8
callq 0x11bbbe
jmp 0x11bea8
testq %rax, %rax
je 0x11be89
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x11bb43
testq %r14, %r14
je 0x11be95
movq $0x0, (%r14)
xorl %r14d, %r14d
jmp 0x11beab
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x11bdb7
movq %rax, %r14
movq %rbx, %rdi
callq 0x11f547
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11f515
movq 0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x131e3e
testq %rax, %rax
je 0x11bfcc
movq %rax, %r12
movq %r13, %rax
subq %r12, %rax
cmpq 0x10(%rbp), %rax
jae 0x11bfcc
testq %r15, %r15
je 0x11bfbd
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 0x11c04b
addq $0x8, %r12
jmp 0x11c044
movq 0xb8(%rbp), %rdi
movq %r13, %rsi
callq 0x130a36
movq %rax, %rbp
testq %rax, %rax
jne 0x11c004
leaq 0x3c4f4(%rip), %rdi     # 0x1584de
leaq 0x3bca4(%rip), %rsi     # 0x157c95
leaq 0x3c506(%rip), %rcx     # 0x1584fe
movl $0x4ae, %edx            # imm = 0x4AE
xorl %eax, %eax
callq 0xc80f6
movq 0x8(%rbp), %r12
subq (%rbp), %r13
cmpq (%r12), %r13
jb 0x11c033
leaq 0x3c4c5(%rip), %rdi     # 0x1584de
leaq 0x3bc75(%rip), %rsi     # 0x157c95
leaq 0x3c1a7(%rip), %rcx     # 0x1581ce
movl $0x4b0, %edx            # imm = 0x4B0
xorl %eax, %eax
callq 0xc80f6
testq %r15, %r15
je 0x11c03f
movq (%rbp), %rax
movq %rax, (%r15)
testq %rbx, %rbx
je 0x11c04b
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 0x11f547
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x11f515
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq 0xb8(%rbx), %rdi
leaq 0x302c(%rip), %rsi      # 0x11f233
movq %r15, %rdx
callq 0x130cb1
movq (%r15), %r15
movq %rbx, %rdi
callq 0x11d149
movq %rax, %rbx
addq %r15, %rbx
movq %r14, %rdi
callq 0x11f547
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x11f515
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq 0xb8(%rbx), %rdi
leaq 0x2fd0(%rip), %rsi      # 0x11f23a
movq %r15, %rdx
callq 0x130cb1
movq (%r15), %r15
movq %rbx, %rdi
callq 0x11d19f
movq %rax, %rbx
addq %r15, %rbx
movq %r14, %rdi
callq 0x11f547
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x11f515
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq 0xb8(%rbx), %rdi
leaq 0x2f71(%rip), %rsi      # 0x11f23e
movq %r15, %rdx
callq 0x130cb1
movq (%r15), %r15
movq %rbx, %rdi
callq 0x11d1ee
movq %rax, %rbx
addq %r15, %rbx
movq %r14, %rdi
callq 0x11f547
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11c440
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x11c235
testq %rax, %rax
je 0x11c432
movq %rax, %r15
movq %rax, %rdi
shlq $0x4, %rdi
callq 0xd160
movq %rax, (%rsp)
movq %r15, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x2c0(%r12), %r13
movq %r13, %rdi
callq 0x11f515
cmpq $0x0, 0x8(%r12)
je 0x11c3d0
xorl %eax, %eax
movq (%r12), %rcx
movq (%rcx,%rax,8), %rcx
cmpq $0x0, 0x20(%rcx)
je 0x11c3c6
xorl %edx, %edx
movq 0x18(%rcx), %rsi
movq (%rsi,%rdx,8), %rsi
movzwl 0x12(%rsi), %edi
testq %rdi, %rdi
je 0x11c3bd
xorl %r8d, %r8d
movzwl 0x48(%rsi,%r8,2), %r9d
movq 0x8(%rsi), %r10
imulq %r10, %r9
addq %rsi, %r9
movq (%rsp), %r11
movq 0x8(%rsp), %rbp
shlq $0x4, %rbp
movq %r9, (%r11,%rbp)
movq %r10, 0x8(%r11,%rbp)
incq 0x8(%rsp)
incq %r8
cmpq %r8, %rdi
jne 0x11c389
incq %rdx
cmpq 0x20(%rcx), %rdx
jb 0x11c375
incq %rax
cmpq 0x8(%r12), %rax
jb 0x11c364
leaq 0x6a(%rip), %rax        # 0x11c441
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq %rsp, %rax
movq %rax, 0x8(%rdx)
movq 0xb8(%r12), %rdi
leaq 0x2e32(%rip), %rsi      # 0x11f227
callq 0x130cb1
movq %r13, %rdi
callq 0x11f547
testq %r15, %r15
jle 0x11c429
movl $0x8, %r12d
movq (%rsp), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq *%r14
addq $0x10, %r12
decq %r15
jne 0x11c40d
movq (%rsp), %rdi
callq 0xd220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x11d19c
pushq %rbx
movq (%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %r8
movq 0x20(%r8), %rdi
testq %rdi, %rdi
je 0x11d18c
movq 0x18(%r8), %r9
xorl %r10d, %r10d
xorl %r8d, %r8d
movq (%r9,%r10,8), %r11
movzwl 0x12(%r11), %ebx
imulq 0x8(%r11), %rbx
addq %rbx, %r8
incq %r10
cmpq %r10, %rdi
jne 0x11d171
jmp 0x11d18f
xorl %r8d, %r8d
addq %r8, %rax
incq %rsi
cmpq %rcx, %rsi
jne 0x11d15a
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rcx, %rcx
je 0x11d1eb
movq (%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %r8
movq 0x20(%r8), %rdi
testq %rdi, %rdi
je 0x11d1dc
movq 0x18(%r8), %r9
xorl %r10d, %r10d
xorl %r8d, %r8d
movq (%r9,%r10,8), %r11
movzwl 0x12(%r11), %r11d
addq %r11, %r8
incq %r10
cmpq %r10, %rdi
jne 0x11d1c6
jmp 0x11d1df
xorl %r8d, %r8d
addq %r8, %rax
incq %rsi
cmpq %rcx, %rsi
jne 0x11d1af
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x11d27e
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %r8
movq 0x20(%r8), %rdi
testq %rdi, %rdi
je 0x11d266
movq 0x18(%r8), %r9
xorl %r10d, %r10d
xorl %r8d, %r8d
movq (%r9,%r10,8), %r11
movzwl 0x12(%r11), %ebx
testq %rbx, %rbx
je 0x11d256
movq 0x30(%r11), %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
incq %r14
testq %r15, %r15
je 0x11d24c
movzwl 0x48(%r11,%r12,2), %r13d
addq (%r15,%r13,8), %r14
incq %r12
cmpq %r12, %rbx
jne 0x11d23a
jmp 0x11d259
xorl %r14d, %r14d
addq %r14, %r8
incq %r10
cmpq %rdi, %r10
jne 0x11d222
jmp 0x11d269
xorl %r8d, %r8d
addq %r8, %rax
incq %rsi
cmpq %rcx, %rsi
jne 0x11d20b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b424(%rip), %rdi     # 0x1586be
xorl %eax, %eax
callq 0xd060
movq (%rbx), %rdi
callq 0xe0cbc
testq %rax, %rax
je 0x11d2ef
movq (%rbx), %rdi
callq 0xe0cbc
leaq 0x3b418(%rip), %rdi     # 0x1586d5
movq %rax, %rsi
xorl %eax, %eax
callq 0xd060
movq 0x8(%rbx), %rdi
callq 0xe0cbc
testq %rax, %rax
je 0x11d2ef
movq 0x8(%rbx), %rdi
callq 0xe0cbc
leaq 0x3b402(%rip), %rdi     # 0x1586e7
movq %rax, %rsi
xorl %eax, %eax
callq 0xd060
movl $0xa, %edi
popq %rbx
jmp 0xd150
// File: /workspace/github_c_makefile_star2_O1/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 0x11ea4f
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
cmpq $0x0, 0x20(%rdi)
je 0x11ea33
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x11ea50
incq %r15
cmpq 0x20(%rbx), %r15
jb 0x11ea1d
movq (%r14), %rdi
callq 0xd220
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_tbman.c
// Function: down_s_discard
static void down_s_discard( down_manager_s* o, down_s* down )
{
    if( o->aligned )
    {
        token_manager_s* token_manager = ( token_manager_s* )( ( intptr_t )down & ~( intptr_t )( o->pool_size - 1 ) );
        token_manager_s_free( token_manager, down );
    }
    else
    {
        token_manager_s_free( bcore_btree_vd_s_largest_below_equal( o->tm_btree, down ), down );
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
cmpb $0x1, 0x1d0(%rdi)
jne 0x11ecce
xorl %edi, %edi
subq 0x1c8(%rax), %rdi
andq %rbx, %rdi
subq %rdi, %rbx
jmp 0x11ece3
movq 0x1c0(%rax), %rdi
movq %rbx, %rsi
callq 0x131e3e
movq %rax, %rdi
subq %rax, %rbx
movq %rbx, %rax
xorl %edx, %edx
divq 0x8(%rdi)
movzwl %ax, %esi
popq %rbx
jmp 0x11ea7f
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x11ed1c
decq %rax
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x11ed64
movq 0x98(%r15), %rdi
callq 0x11f547
movq %r12, %rdi
movq %rbx, %rsi
callq *(%r12)
movq 0x98(%r15), %rdi
callq 0x11f515
movq 0x90(%r15), %rdi
movq %r12, %rsi
callq 0x11ecad
movq $0x0, 0x10(%r14)
movq 0x78(%r15), %rdi
movq %rbx, %rsi
callq 0x130b4a
cmpb $0x1, 0x88(%r15)
jne 0x11ed8b
xorl %edi, %edi
subq 0x80(%r15), %rdi
andq %r14, %rdi
subq %rdi, %r14
jmp 0x11ed9d
movq 0x70(%r15), %rdi
movq %r14, %rsi
callq 0x131e3e
movq %rax, %rdi
subq %rax, %r14
movq %r14, %rax
xorl %edx, %edx
divq 0x8(%rdi)
movzwl %ax, %esi
callq 0x11ea7f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd220
// File: /workspace/github_c_makefile_star2_O1/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 0x130a3e
movq %rax, %r15
testq %rax, %rax
jne 0x11f164
leaq 0x392bb(%rip), %rdi     # 0x158405
leaq 0x38b44(%rip), %rsi     # 0x157c95
leaq 0x392c5(%rip), %rcx     # 0x15841d
movl $0x4a4, %edx            # imm = 0x4A4
xorl %eax, %eax
callq 0xc80f6
movq (%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x11ecf5