LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x10d31f
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 0xbe7cb
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x109050
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq *0x8(%rsp)
testq %r15, %r15
je 0x10d384
leaq -0x3f2b(%rip), %rdi     # 0x109451
movq %r15, %rsi
callq 0xbe7ee
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_O3/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        # 0x10d7db
movq %rax, %r9
callq 0x10b9e1
testq %rbx, %rbx
je 0x10d7d0
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10d817
leaq 0x1fe52(%rip), %rdi     # 0x12d647
leaq 0x3fc17(%rip), %rsi     # 0x14d413
leaq 0x3ec6c(%rip), %rdx     # 0x14c46f
leaq 0x3e756(%rip), %rcx     # 0x14bf60
movl $0x88f, %r8d            # imm = 0x88F
xorl %eax, %eax
callq 0xbe4ef
movabsq $0x690af8765815ec4d, %rdi # imm = 0x690AF8765815EC4D
movq %rdi, (%r15)
movq 0x8(%r14), %rsi
callq 0xbeb67
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10d88b
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       # 0x10d7db
movq %r10, %r9
callq 0x10b9e1
testq %rbx, %rbx
je 0x10d8d4
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10ebd4
cmpl $0x27, %eax
jne 0x10ec14
movb 0x1(%r14,%r15), %bpl
testb %bpl, %bpl
je 0x10ec6c
leaq 0x2(%r15), %r12
cmpb $0x27, 0x2(%r14,%r15)
jne 0x10ec72
jmp 0x10ec9b
movq %rsi, %r13
movq %rdi, %r12
leaq (%r15,%r14), %rdi
incq %rdi
callq 0xd2c0
movb $0x3, %bpl
testl %eax, %eax
js 0x10ebf8
movl %eax, %eax
cmpq %r13, %rax
jae 0x10ebf8
movb (%r12,%rax), %bpl
leaq 0x2(%r15), %r12
movzbl -0x1(%r14,%r12), %eax
testl %eax, %eax
je 0x10ec43
cmpl $0x5d, %eax
je 0x10ec9e
incq %r12
jmp 0x10ebfc
leaq 0x3d7af(%rip), %rdi     # 0x14c3ca
leaq 0x3d33e(%rip), %rsi     # 0x14bf60
leaq 0x3d809(%rip), %rcx     # 0x14c432
movl $0x543, %edx            # imm = 0x543
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0xbe592
movb $0x3, %bpl
movq %r15, %r12
jmp 0x10ec9e
leaq 0x3d780(%rip), %rdi     # 0x14c3ca
leaq 0x3d30f(%rip), %rsi     # 0x14bf60
leaq 0x3d7a9(%rip), %rcx     # 0x14c401
movl $0x53e, %edx            # imm = 0x53E
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0xbe592
jmp 0x10ec9e
incq %r15
movq %r15, %r12
leaq -0x2(%r12), %r9
leaq 0x3d74c(%rip), %rdi     # 0x14c3ca
leaq 0x3d2db(%rip), %rsi     # 0x14bf60
leaq 0x3d745(%rip), %rcx     # 0x14c3d1
movl $0x534, %edx            # imm = 0x534
movq %r14, %r8
xorl %eax, %eax
callq 0xbe592
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_O3/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 0x10ed0f
movq %r12, %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x39a2e(%rip), %r9      # 0x148715
cmovneq %rax, %r9
leaq 0x38a05(%rip), %rdi     # 0x1476f7
leaq 0x3d267(%rip), %rsi     # 0x14bf60
leaq 0x3d7bc(%rip), %rcx     # 0x14c4bc
movl $0x8af, %edx            # imm = 0x8AF
movq %r12, %r8
xorl %eax, %eax
callq 0xbe592
leaq 0x18(%r14), %r12
movq 0x18(%r14), %rsi
testq %rsi, %rsi
jne 0x10ed2d
movq %r14, %rdi
callq 0x10a227
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x10ed4e
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
leaq (%rbx,%rax), %rdx
incq %rdx
cmpq %rdx, %rsi
jae 0x10ed72
leaq (%rsi,%rsi), %rax
cmpq %rdx, %rax
cmovaq %rax, %rdx
jmp 0x10ed63
leaq 0x1(%rbx), %rax
cmpq $0x7, %rbx
movl $0x8, %edx
cmovaeq %rax, %rdx
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rcx
callq 0xbe7d0
movq %rax, %rdi
movq %rax, 0x8(%r14)
addq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xbe87d
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_O3/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 0x10ee00
movq %r12, %rdi
callq 0xd6ec4
testq %rax, %rax
leaq 0x3993d(%rip), %r9      # 0x148715
cmovneq %rax, %r9
leaq 0x38f2f(%rip), %rdi     # 0x147d12
leaq 0x3d176(%rip), %rsi     # 0x14bf60
leaq 0x3d6cb(%rip), %rcx     # 0x14c4bc
movl $0x8c5, %edx            # imm = 0x8C5
movq %r12, %r8
xorl %eax, %eax
callq 0xbe592
cmpq $0x0, 0x18(%r14)
je 0x10ee28
leaq 0x38f04(%rip), %rdi     # 0x147d12
leaq 0x3d14b(%rip), %rsi     # 0x14bf60
leaq 0x3d6ca(%rip), %rcx     # 0x14c4e6
movl $0x8c7, %edx            # imm = 0x8C7
xorl %eax, %eax
callq 0xbe592
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0xbe87d
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_O3/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, %r14
movq %rsi, %r15
xorl %esi, %esi
callq 0x10b7ae
movq %rax, %rbx
movl $0x20, %esi
xorl %edi, %edi
xorl %edx, %edx
callq 0xbe7cb
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x109050
movq 0x8(%rbx), %rsi
movq 0x8(%r12), %rdx
leaq 0x3d686(%rip), %rdi     # 0x14c526
xorl %eax, %eax
callq 0xbe4ef
leaq -0x5a5d(%rip), %r14     # 0x109451
movq %r14, %rdi
movq %r12, %rsi
callq 0xbe7ee
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbe7ee
// File: /workspace/github_c_makefile_star2_O3/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 0x10ef09
leaq 0x2b127(%rip), %rdi     # 0x13a016
leaq 0x3d06a(%rip), %rsi     # 0x14bf60
leaq 0x3d5e9(%rip), %rcx     # 0x14c4e6
movl $0x8de, %edx            # imm = 0x8DE
xorl %eax, %eax
callq 0xbe592
movq 0x10(%rbx), %rdx
movq %r15, (%rsp)
leaq -0x3691(%rip), %rcx     # 0x10b887
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
movq %r14, %r9
callq 0x10b9e1
addq %rax, 0x8(%rbx)
subq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10ef76
leaq 0x39015(%rip), %rdi     # 0x147f71
leaq 0x3cffd(%rip), %rsi     # 0x14bf60
leaq 0x3d57c(%rip), %rcx     # 0x14c4e6
movl $0x8e8, %edx            # imm = 0x8E8
xorl %eax, %eax
callq 0xbe592
movq 0x10(%rbx), %rdx
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movq %r15, (%rsp)
leaq -0x17b7(%rip), %rcx     # 0x10d7db
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %r8
movq %r14, %r9
callq 0x10b9e1
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_O3/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 0x10f062
leaq 0x2afa9(%rip), %rdi     # 0x139ff1
leaq 0x3cf11(%rip), %rsi     # 0x14bf60
leaq 0x3d490(%rip), %rcx     # 0x14c4e6
movl $0x904, %edx            # imm = 0x904
xorl %eax, %eax
callq 0xbe592
testq %rbx, %rbx
jle 0x10f088
leaq 0x2af83(%rip), %rdi     # 0x139ff1
leaq 0x3ceeb(%rip), %rsi     # 0x14bf60
leaq 0x38ac9(%rip), %rcx     # 0x147b45
movl $0x905, %edx            # imm = 0x905
xorl %eax, %eax
callq 0xbe592
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 0x110f08
movq 0x8(%r14), %r13
addq 0x10(%r14), %r13
addq %rbx, %r13
movq %r13, %rax
subq (%r15), %rax
cmpq (%r12), %rax
jb 0x10f0e0
leaq 0x2af2b(%rip), %rdi     # 0x139ff1
leaq 0x3ce93(%rip), %rsi     # 0x14bf60
leaq 0x3d471(%rip), %rcx     # 0x14c545
movl $0x90f, %edx            # imm = 0x90F
xorl %eax, %eax
callq 0xbe592
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_O3/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 0xf7451
movq (%rbx), %r8
cmpq %r14, %r8
je 0x10f145
leaq 0x3d37d(%rip), %rdi     # 0x14c4a8
leaq 0x3ce2e(%rip), %rsi     # 0x14bf60
leaq 0x3d434(%rip), %rcx     # 0x14c56d
movl $0x91e, %edx            # imm = 0x91E
xorl %eax, %eax
callq 0xbe592
movq 0x18(%rbx), %r8
testq %r8, %r8
je 0x10f178
movq 0x10(%rbx), %r9
cmpq %r9, %r8
jae 0x10f178
leaq 0x3d34a(%rip), %rdi     # 0x14c4a8
leaq 0x3cdfb(%rip), %rsi     # 0x14bf60
leaq 0x3d42c(%rip), %rcx     # 0x14c598
movl $0x921, %edx            # imm = 0x921
xorl %eax, %eax
callq 0xbe592
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpb $0x0, (%rcx,%rax)
je 0x10f1ab
leaq 0x3d31b(%rip), %rdi     # 0x14c4a8
leaq 0x3cdcc(%rip), %rsi     # 0x14bf60
leaq 0x3d416(%rip), %rcx     # 0x14c5b1
movl $0x922, %edx            # imm = 0x922
xorl %eax, %eax
callq 0xbe592
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x10f1f8
leaq 0x3d2f1(%rip), %r14     # 0x14c4a8
leaq 0x3cda2(%rip), %r15     # 0x14bf60
leaq 0x3d414(%rip), %r12     # 0x14c5d9
xorl %r13d, %r13d
movq 0x8(%rbx), %rcx
movzbl (%rcx,%r13), %r8d
cmpb $0x9, %r8b
jg 0x10f1f0
movq %r14, %rdi
movq %r15, %rsi
movl $0x927, %edx            # imm = 0x927
movq %r12, %rcx
xorl %eax, %eax
callq 0xbe592
movq 0x10(%rbx), %rax
incq %r13
cmpq %rax, %r13
jb 0x10f1c8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10f243
movq %rsi, %r14
testq %rdi, %rdi
je 0x10f258
movq %r14, %rsi
callq 0xd3f0
jmp 0x10f260
testq %rdi, %rdi
je 0x10f24d
callq 0xd220
xorl %r14d, %r14d
movl $0x0, %r15d
jmp 0x10f28c
movq %r14, %rdi
callq 0xd160
movq %rax, %r15
testq %rax, %rax
jne 0x10f28c
leaq 0x3da61(%rip), %rdi     # 0x14ccd0
leaq 0x3da77(%rip), %rsi     # 0x14cced
leaq 0x3da7e(%rip), %rcx     # 0x14ccfb
movl $0xa2, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0xbe592
testq %rbx, %rbx
je 0x10f294
movq %r14, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1142c9
leaq 0x40(%r14), %rdi
callq 0x11370c
movq 0xb0(%r14), %rdi
callq 0x126205
movq 0xb8(%r14), %rdi
callq 0x124d3a
leaq 0xe0(%r14), %rdi
callq 0x11370c
leaq 0x150(%r14), %rdi
callq 0x11370c
leaq 0x1c0(%r14), %rdi
callq 0x11370c
leaq 0x230(%r14), %rdi
callq 0x11370c
movq 0x2a0(%r14), %rdi
callq 0x126205
movq (%r14), %rdi
testq %rdi, %rdi
je 0x10f948
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x10f943
xorl %r12d, %r12d
movq (%r14), %rcx
movq (%rcx,%r12,8), %r15
testq %r15, %r15
je 0x10f938
movq %r15, %rdi
callq 0x11370c
movq %r15, %rdi
callq 0xd220
movq 0x8(%r14), %rax
incq %r12
cmpq %rax, %r12
jb 0x10f918
movq (%r14), %rdi
callq 0xd220
movq 0x38(%r14), %rdi
callq 0x126205
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x10f95f
callq 0xd220
movq %rbx, %rdi
callq 0x1142fb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1141a2
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x2e8, %edi            # imm = 0x2E8
callq 0xd160
movq %rax, %rbx
testq %rax, %rax
je 0x10f9af
movzbl %bpl, %r9d
movq %rbx, %rdi
jmp 0x10f9dc
leaq 0x3d374(%rip), %rdi     # 0x14cd2a
leaq 0x3d330(%rip), %rsi     # 0x14cced
leaq 0x3d337(%rip), %rcx     # 0x14ccfb
movl $0x2e8, %r8d            # imm = 0x2E8
movl $0x71d, %edx            # imm = 0x71D
xorl %eax, %eax
callq 0xbe592
movzbl %bpl, %r9d
xorl %edi, %edi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x10f333
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_O3/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 0x10fb31
movq %rdi, %r13
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x1142c9
movq 0x38(%r13), %rdi
movq %rbx, %rsi
callq 0x1268f9
testq %rax, %rax
je 0x10fab8
movq %rax, %r12
movq %rbx, %r15
subq %rax, %r15
cmpq 0x10(%r13), %r15
jae 0x10fab8
movq 0x8(%r12), %r13
movq 0x30(%r12), %rcx
testq %rcx, %rcx
jne 0x10faa7
movzwl 0x10(%r12), %esi
shll $0x3, %esi
movl $0x1, %edi
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 0x10fb25
movq 0xb8(%r13), %rdi
movq %rbx, %rsi
callq 0x12543c
movq %rax, %r15
testq %rax, %rax
jne 0x10faf0
leaq 0x3d738(%rip), %rdi     # 0x14d20e
leaq 0x3d210(%rip), %rsi     # 0x14cced
leaq 0x3d742(%rip), %rcx     # 0x14d226
movl $0x511, %edx            # imm = 0x511
xorl %eax, %eax
callq 0xbe592
movq 0x8(%r15), %r12
movq %rbx, %rax
subq (%r15), %rax
cmpq (%r12), %rax
jb 0x10fb21
leaq 0x3d707(%rip), %rdi     # 0x14d20e
leaq 0x3d1df(%rip), %rsi     # 0x14cced
leaq 0x3d711(%rip), %rcx     # 0x14d226
movl $0x513, %edx            # imm = 0x513
xorl %eax, %eax
callq 0xbe592
addq $0x8, %r12
incq (%r12)
movq %r14, %rdi
callq 0x1142fb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_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 0x10fb75
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c0(%rdi), %r15
movq %r15, %rdi
callq 0x1142c9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10fb76
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1142fb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1268f9
testq %rax, %rax
je 0x10fbba
movq %rax, %rdi
movq %r14, %rax
subq %rdi, %rax
cmpq 0x10(%rbx), %rax
jae 0x10fbba
xorl %edx, %edx
divq 0x8(%rdi)
movzwl %ax, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11378d
movq 0xb8(%rbx), %rdi
movq %r14, %rsi
callq 0x12543c
movq %rax, %r15
testq %rax, %rax
jne 0x10fbf2
leaq 0x3d6b9(%rip), %rdi     # 0x14d291
leaq 0x3d10e(%rip), %rsi     # 0x14cced
leaq 0x3d640(%rip), %rcx     # 0x14d226
movl $0x51d, %edx            # imm = 0x51D
xorl %eax, %eax
callq 0xbe592
addq $0x40, %rbx
movq (%r15), %rsi
movq 0x8(%r15), %r12
subq %rsi, %r14
cmpq (%r12), %r14
jb 0x10fc2a
leaq 0x3d684(%rip), %rdi     # 0x14d291
leaq 0x3d0d9(%rip), %rsi     # 0x14cced
leaq 0x3d60b(%rip), %rcx     # 0x14d226
movl $0x51f, %edx            # imm = 0x51F
xorl %eax, %eax
callq 0xbe592
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1139f9
// File: /workspace/github_c_makefile_star2_O3/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 0x10fd30
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 0x1142c9
testq %r14, %r14
je 0x10fdbd
movq 0x38(%r13), %rdi
movq %r15, %rsi
callq 0x1268f9
testq %rax, %rax
je 0x10fd31
movq %rax, %r12
movq %r15, %rax
subq %r12, %rax
cmpq 0x10(%r13), %rax
jae 0x10fd31
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 0x10fe32
movq (%rcx,%r13,8), %rax
testq %rax, %rax
je 0x10fe64
decq %rax
movq %rax, (%rcx,%r13,8)
cmpq %r15, %rbp
jne 0x10fe9a
movq 0x38(%r12), %rax
testq %rax, %rax
jne 0x10fcff
movzwl 0x10(%r12), %esi
shll $0x3, %esi
movl $0x1, %edi
callq 0xd370
movq %rax, 0x38(%r12)
cmpq $0x0, (%rax,%r13,8)
jne 0x10fe9a
movq 0x40(%r12), %rdi
callq 0x113ac5
leaq 0x4153(%rip), %rcx      # 0x113e6e
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq 0x38(%r12), %rcx
movq %rax, (%rcx,%r13,8)
jmp 0x10fe9a
retq
movq 0xb8(%r13), %rdi
movq %r15, %rsi
callq 0x12543c
movq %rax, %r12
testq %rax, %rax
jne 0x10fd69
leaq 0x3d66e(%rip), %rdi     # 0x14d3bd
leaq 0x3cf97(%rip), %rsi     # 0x14cced
leaq 0x3d4c9(%rip), %rcx     # 0x14d226
movl $0x528, %edx            # imm = 0x528
xorl %eax, %eax
callq 0xbe592
movq (%r12), %rbp
movq 0x8(%r12), %r12
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x10fdcd
decq %rax
movq %rax, 0x8(%r12)
cmpq %r15, %rbp
jne 0x10fe9a
cmpq $0x0, 0x10(%r12)
jne 0x10fe9a
movq 0xd0(%r13), %rdi
callq 0x113ac5
leaq 0x40c2(%rip), %rcx      # 0x113e6e
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x10(%r12)
jmp 0x10fe9a
movq %r13, %rdi
movq %r15, %rsi
callq 0x10fb76
jmp 0x10fe9a
leaq 0x40(%r13), %rdi
cmpq $0x0, 0x10(%r12)
jne 0x10fe25
movq %rdi, (%rsp)
movq 0xd8(%r13), %rdi
callq 0x1142fb
cmpq %r15, %rbp
je 0x10fe0f
leaq 0x3d5c8(%rip), %rdi     # 0x14d3bd
leaq 0x3cef1(%rip), %rsi     # 0x14cced
leaq 0x3d4c5(%rip), %rcx     # 0x14d2c8
movl $0x53e, %edx            # imm = 0x53E
xorl %eax, %eax
callq 0xbe592
movq %r15, %rdi
callq *%r14
movq 0xd8(%r13), %rdi
callq 0x1142c9
movq (%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1139f9
jmp 0x10fe9a
movq 0x18(%r12), %rdi
callq 0x1142fb
cmpq %r15, %rbp
je 0x10fe7f
leaq 0x3d464(%rip), %rdi     # 0x14d2ac
leaq 0x3ce9e(%rip), %rsi     # 0x14cced
leaq 0x3d472(%rip), %rcx     # 0x14d2c8
movl $0x1d9, %edx            # imm = 0x1D9
xorl %eax, %eax
callq 0xbe592
jmp 0x10fe7f
movq 0x38(%r12), %rax
testq %rax, %rax
je 0x10fe75
cmpq $0x0, (%rax,%r13,8)
jne 0x10fe8f
movq 0x18(%r12), %rdi
callq 0x1142fb
movq %r15, %rdi
callq *%r14
movq 0x18(%r12), %rdi
callq 0x1142c9
movq %r12, %rdi
movl %r13d, %esi
callq 0x11378d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1142fb
// File: /workspace/github_c_makefile_star2_O3/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 0x110820
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2c0(%rdi), %rbx
movq %rbx, %rdi
callq 0x1142c9
movq 0x38(%r15), %rdi
movq %r14, %rsi
callq 0x1268f9
testq %rax, %rax
je 0x1107f4
movq %rax, %rcx
movq %r14, %rax
subq %rcx, %rax
cmpq 0x10(%r15), %rax
jae 0x1107f4
movq 0x30(%rcx), %rsi
testq %rsi, %rsi
je 0x110839
xorl %edx, %edx
divq 0x8(%rcx)
movzwl %ax, %eax
leaq (%rsi,%rax,8), %rcx
jmp 0x110818
movq 0xb8(%r15), %rdi
movq %r14, %rsi
callq 0x12543c
testq %rax, %rax
je 0x110825
movq 0x8(%rax), %rcx
subq (%rax), %r14
cmpq (%rcx), %r14
jae 0x110825
addq $0x8, %rcx
movq (%rcx), %r14
incq %r14
jmp 0x110828
xorl %r14d, %r14d
jmp 0x110830
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1142fb
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %r14d
jmp 0x110828
// File: /workspace/github_c_makefile_star2_O3/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 0x1142c9
testq %r13, %r13
je 0x110884
movq %r12, %rdi
testq %r15, %r15
je 0x1108a7
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %rcx
movq %r14, %r8
callq 0x110945
jmp 0x1108b2
testq %r15, %r15
je 0x110896
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1108ca
testq %r14, %r14
je 0x1108a2
movq $0x0, (%r14)
xorl %r14d, %r14d
jmp 0x1108b5
movq %r13, %rsi
movq %r14, %rdx
callq 0x110b36
movq %rax, %r14
movq %rbx, %rdi
callq 0x1142fb
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_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 0x1108fa
movq (%rdx), %rax
cmpq 0x20(%r14), %rax
ja 0x1108fa
cmpb $0x1, 0x28(%r14)
jne 0x1108fa
xorl %edi, %edi
subq 0x10(%r14), %rdi
andq %rbx, %rdi
subq %rdi, %rbx
movq %rbx, %rax
jmp 0x11091a
movq 0x38(%r14), %rdi
movq %rbx, %rsi
callq 0x1268f9
testq %rax, %rax
je 0x11092f
movq %rax, %rdi
movq %rbx, %rax
subq %rdi, %rax
cmpq 0x10(%r14), %rax
jae 0x11092f
xorl %edx, %edx
divq 0x8(%rdi)
movzwl %ax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11378d
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x113ed9
// File: /workspace/github_c_makefile_star2_O3/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 0x110b84
movq 0x30(%rdi), %rdx
xorl %ecx, %ecx
cmpq %rsi, (%rdx,%rcx,8)
jae 0x110b5c
incq %rcx
cmpq %rcx, %rax
jne 0x110b4c
jmp 0x110b84
movq (%rdi), %rax
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x110b84
movq %r14, %rdi
callq 0x113ac5
testq %rbx, %rbx
je 0x110b7c
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 0x113f29
// File: /workspace/github_c_makefile_star2_O3/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 0x1142c9
testq %r13, %r13
je 0x110be4
testq %rbp, %rbp
je 0x110c08
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
movq %r14, %r8
callq 0x110945
jmp 0x110c16
testq %rbp, %rbp
je 0x110bf7
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1108ca
testq %r14, %r14
je 0x110c03
movq $0x0, (%r14)
xorl %r14d, %r14d
jmp 0x110c19
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x110b36
movq %rax, %r14
movq %rbx, %rdi
callq 0x1142fb
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_O3/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 0x1142c9
movq 0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x1268f9
testq %rax, %rax
je 0x110d3b
movq %rax, %r12
movq %r13, %rax
subq %r12, %rax
cmpq 0x10(%rbp), %rax
jae 0x110d3b
testq %r15, %r15
je 0x110d2c
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 0x110dba
addq $0x8, %r12
jmp 0x110db3
movq 0xb8(%rbp), %rdi
movq %r13, %rsi
callq 0x12543c
movq %rax, %rbp
testq %rax, %rax
jne 0x110d73
leaq 0x3c7dd(%rip), %rdi     # 0x14d536
leaq 0x3bf8d(%rip), %rsi     # 0x14cced
leaq 0x3c7ef(%rip), %rcx     # 0x14d556
movl $0x4ae, %edx            # imm = 0x4AE
xorl %eax, %eax
callq 0xbe592
movq 0x8(%rbp), %r12
subq (%rbp), %r13
cmpq (%r12), %r13
jb 0x110da2
leaq 0x3c7ae(%rip), %rdi     # 0x14d536
leaq 0x3bf5e(%rip), %rsi     # 0x14cced
leaq 0x3c490(%rip), %rcx     # 0x14d226
movl $0x4b0, %edx            # imm = 0x4B0
xorl %eax, %eax
callq 0xbe592
testq %r15, %r15
je 0x110dae
movq (%rbp), %rax
movq %rax, (%r15)
testq %rbx, %rbx
je 0x110dba
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 0x1142fb
// File: /workspace/github_c_makefile_star2_O3/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 0x1142c9
movq 0xb8(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
leaq 0x306f(%rip), %rsi      # 0x113fe5
movq %r15, %rdx
callq 0x1256b7
movq (%r15), %r15
movq %rbx, %rdi
callq 0x111ef1
movq %rax, %rbx
addq %r15, %rbx
movq %r14, %rdi
callq 0x1142fb
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1142c9
movq 0xb8(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
leaq 0x3013(%rip), %rsi      # 0x113fec
movq %r15, %rdx
callq 0x1256b7
movq (%r15), %r15
movq %rbx, %rdi
callq 0x111f47
movq %rax, %rbx
addq %r15, %rbx
movq %r14, %rdi
callq 0x1142fb
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1142c9
movq 0xb8(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
leaq 0x2fb4(%rip), %rsi      # 0x113ff0
movq %r15, %rdx
callq 0x1256b7
movq (%r15), %r15
movq %rbx, %rdi
callq 0x111f96
movq %rax, %rbx
addq %r15, %rbx
movq %r14, %rdi
callq 0x1142fb
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1111e8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x110fa4
testq %rax, %rax
je 0x1111da
movq %rax, %r15
movq %rbx, 0x30(%rsp)
movq %rax, %rdi
shlq $0x4, %rdi
callq 0xd160
movq %rax, %rbp
movq %rax, 0x10(%rsp)
movq %r15, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
leaq 0x2c0(%r12), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1142c9
movq %r12, 0x8(%rsp)
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x111169
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
addq $0x8, %rbp
xorl %edx, %edx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movq 0x20(%rdi), %r9
testq %r9, %r9
je 0x111161
xorl %r8d, %r8d
movq 0x18(%rdi), %r10
movq (%r10,%r8,8), %r10
movzwl 0x12(%r10), %r12d
testq %r12, %r12
je 0x111159
movq 0x8(%r10), %r9
movq %rdx, %r11
shlq $0x4, %r11
addq %rbp, %r11
leal (%r12,%r12), %r13d
addq %r12, %rdx
xorl %r12d, %r12d
movzwl 0x48(%r10,%r12), %ebx
imulq %r9, %rbx
addq %r10, %rbx
movq %rbx, -0x8(%r11,%r12,8)
movq %r9, (%r11,%r12,8)
addq $0x2, %r12
cmpq %r12, %r13
jne 0x111131
movq %rdx, 0x18(%rsp)
movq 0x20(%rdi), %r9
incq %r8
cmpq %r9, %r8
jb 0x111107
incq %rsi
cmpq %rax, %rsi
jb 0x1110f7
movq 0x8(%rsp), %rax
movq 0xb8(%rax), %rdi
leaq 0x6d(%rip), %rax        # 0x1111e9
leaq 0x38(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rdx)
leaq 0x2e45(%rip), %rsi      # 0x113fd9
callq 0x1256b7
movq 0x28(%rsp), %rdi
callq 0x1142fb
testq %r15, %r15
movq 0x30(%rsp), %rbx
jle 0x1111d0
movl $0x8, %r12d
movq 0x10(%rsp), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq *%r14
addq $0x10, %r12
decq %r15
jne 0x1111b3
movq 0x10(%rsp), %rdi
callq 0xd220
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_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 0x111f44
pushq %rbx
movq (%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %r8
movq 0x20(%r8), %rdi
testq %rdi, %rdi
je 0x111f34
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 0x111f19
jmp 0x111f37
xorl %r8d, %r8d
addq %r8, %rax
incq %rsi
cmpq %rcx, %rsi
jne 0x111f02
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x111f93
movq (%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %r8
movq 0x20(%r8), %rdi
testq %rdi, %rdi
je 0x111f84
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 0x111f6e
jmp 0x111f87
xorl %r8d, %r8d
addq %r8, %rax
incq %rsi
cmpq %rcx, %rsi
jne 0x111f57
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x112026
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 0x11200e
movq 0x18(%r8), %r9
xorl %r10d, %r10d
xorl %r8d, %r8d
movq (%r9,%r10,8), %r11
movzwl 0x12(%r11), %ebx
testq %rbx, %rbx
je 0x111ffe
movq 0x30(%r11), %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
incq %r14
testq %r15, %r15
je 0x111ff4
movzwl 0x48(%r11,%r12,2), %r13d
addq (%r15,%r13,8), %r14
incq %r12
cmpq %r12, %rbx
jne 0x111fe2
jmp 0x112001
xorl %r14d, %r14d
addq %r14, %r8
incq %r10
cmpq %rdi, %r10
jne 0x111fca
jmp 0x112011
xorl %r8d, %r8d
addq %r8, %rax
incq %rsi
cmpq %rcx, %rsi
jne 0x111fb3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b6d4(%rip), %rdi     # 0x14d716
xorl %eax, %eax
callq 0xd060
movq (%rbx), %rdi
callq 0xd6ec4
testq %rax, %rax
je 0x112097
movq (%rbx), %rdi
callq 0xd6ec4
leaq 0x3b6c8(%rip), %rdi     # 0x14d72d
movq %rax, %rsi
xorl %eax, %eax
callq 0xd060
movq 0x8(%rbx), %rdi
callq 0xd6ec4
testq %rax, %rax
je 0x112097
movq 0x8(%rbx), %rdi
callq 0xd6ec4
leaq 0x3b6b2(%rip), %rdi     # 0x14d73f
movq %rax, %rsi
xorl %eax, %eax
callq 0xd060
movl $0xa, %edi
popq %rbx
jmp 0xd150
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x113758
leaq 0x18(%rbx), %r14
cmpq $0x0, 0x20(%rbx)
je 0x113744
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x11375e
incq %r15
cmpq 0x20(%rbx), %r15
jb 0x11372b
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_O3/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 0x1139d2
xorl %edi, %edi
subq 0x1c8(%rax), %rdi
andq %rbx, %rdi
subq %rdi, %rbx
jmp 0x1139e7
movq 0x1c0(%rax), %rdi
movq %rbx, %rsi
callq 0x1268f9
movq %rax, %rdi
subq %rax, %rbx
movq %rbx, %rax
xorl %edx, %edx
divq 0x8(%rdi)
movzwl %ax, %esi
popq %rbx
jmp 0x11378d