LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_main_help
void xoico_main_help( x_sink* sink )
{
    // xoico_main.x:21:1
    
    x_sink_push_sc(sink,"Xoila Compiler: (C) J.B.Steffens\n"
        "Usage:\n"
        "$ xoico [options] xoico <xoico-config-file> [<xoico-config-file> ...]   #normal operation\n"
        "$ xoico --help                                                          #displays this text\n"
        "\n"
        "Options:\n"
        "-d : Dry run. Target files are not modified.\n"
        "-e : Always expand: Expands a target even if its hash value has not changed.\n"
        "-f : Force overwrite target files. Use with care.\n"
        "-O <folder>: Output folder for this target and all dependencies.\n"
    );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x156218(%rip), %rax    # 0x1a9ab0
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r14, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r14, %rdx
je 0x538ee
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r14, %rdx
je 0x538ee
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r14, %rdx
je 0x538ee
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r14, %rdx
jne 0x53935
movq (%rax,%rcx), %r15
testq %r15, %r15
jne 0x5391e
movabsq $0x5ea8cabb93ff3b7e, %rdi # imm = 0x5EA8CABB93FF3B7E
movq %r14, %rsi
callq 0xf3f85
movq %rax, %r15
leaq 0x15619d(%rip), %rdi    # 0x1a9ab0
movq %r14, %rsi
movq %rax, %rdx
callq 0x12128c
leaq 0xe96a1(%rip), %rdx     # 0x13cfc6
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10908b
xorl %r15d, %r15d
jmp 0x538f2
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: main
BETH_SIGNAL_DEFINE( xoico )

int main( int argc, char** argv )
{
    BETH_USE( xoico );
    bcore_arr_st_s* args = bcore_arr_st_s_create();
    for( sz_t i = 0; i < argc; i++ ) bcore_arr_st_s_push_sc( args, argv[ i ] );
    int retv = xoico_main_main( args );
    bcore_arr_st_s_discard( args );
    BETH_CLOSEV( 0 );
    return retv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq -0x8b(%rip), %rdi       # 0x594db
callq 0x5967c
xorl %eax, %eax
callq 0xc3651
movq %rax, %r14
testl %ebp, %ebp
jle 0x59593
movslq %ebp, %r15
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
callq 0xc3965
incq %r12
cmpq %r12, %r15
jne 0x5957f
movq %r14, %rdi
callq 0x5393a
movl %eax, %ebx
movq %r14, %rdi
callq 0xc366e
xorl %edi, %edi
callq 0x59831
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.c
// Function: bcore_register_signal_handler
void bcore_register_signal_handler( bcore_fp_signal_handler signal_handler )
{
    init();
    if( signal_handler )
    {
        bcore_signal_s signal_init0 = bcore_signal_init( TYPEOF_all, TYPEOF_init0, NULL );
        bcore_signal_s signal_init1 = bcore_signal_init( TYPEOF_all, TYPEOF_init1, NULL );
        bcore_mutex_s_lock( &mutex );
        bl_t not_registered =
            bcore_arr_fp_s_find( signal_handler_arr_fp_g, 0, -1, ( fp_t )signal_handler )
                == signal_handler_arr_fp_g->size;

        if( not_registered )
        {
            signal_handler( &signal_init0 );
            signal_handler( &signal_init1 );
            bcore_arr_fp_s_push( signal_handler_arr_fp_g, ( fp_t )signal_handler );
        }

        bcore_mutex_s_unlock( &mutex );
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x14998f(%rip), %rdi    # 0x1a2f58
leaq 0x3da(%rip), %rsi       # 0x599aa
callq 0x11f8a7
testq %rbx, %rbx
je 0x59674
leaq 0x20(%rsp), %rdi
movabsq $-0x190f64e6fae6255c, %r14 # imm = 0xE6F09B190519DAA4
movabsq $0x6a72cf8f8250f179, %rdx # imm = 0x6A72CF8F8250F179
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xe9d9b
leaq 0x8(%rsp), %rdi
movabsq $0x6a72ce8f8250efc6, %rdx # imm = 0x6A72CE8F8250EFC6
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xe9d9b
leaq 0x149907(%rip), %rdi    # 0x1a2f28
callq 0x11f515
movq 0x149923(%rip), %rdi    # 0x1a2f50
xorl %esi, %esi
movq $-0x1, %rdx
movq %rbx, %rcx
callq 0xc4680
movq 0x14990b(%rip), %rcx    # 0x1a2f50
cmpq 0x10(%rcx), %rax
jne 0x59668
leaq 0x20(%rsp), %rdi
callq *%rbx
leaq 0x8(%rsp), %rdi
callq *%rbx
movq 0x1498f0(%rip), %rdi    # 0x1a2f50
movq %rbx, %rsi
callq 0xc450f
leaq 0x1498b9(%rip), %rdi    # 0x1a2f28
callq 0x11f547
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.c
// Function: bcore_register_signal_handler_with_deep_dependencies
void bcore_register_signal_handler_with_deep_dependencies( bcore_fp_signal_handler signal_handler )
{
    init();
    if( !signal_handler ) return;
    bcore_arr_fp_s* arr = bcore_arr_fp_s_create();
    bcore_push_signal_handler_with_dependencies_unique_recursive( signal_handler, arr );
    for( sz_t i = 0; i < arr->size; i++ )
    {
        bcore_register_signal_handler( ( bcore_fp_signal_handler )arr->data[ i ] );
    }
    bcore_arr_fp_s_discard( arr );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1498ce(%rip), %rdi    # 0x1a2f58
leaq 0x319(%rip), %rsi       # 0x599aa
callq 0x11f8a7
testq %r14, %r14
je 0x596df
xorl %eax, %eax
callq 0xc434b
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x596e7
cmpq $0x0, 0x10(%rbx)
je 0x596d0
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x595b8
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x596ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc437a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.c
// Function: bcore_push_signal_handler_with_dependencies_unique_recursive
static void bcore_push_signal_handler_with_dependencies_unique_recursive
(
    bcore_fp_signal_handler signal_handler,
    bcore_arr_fp_s* arr
)
{
    if( !signal_handler ) return;

    if( bcore_arr_fp_s_find( arr, 0, -1, ( fp_t )signal_handler ) == arr->size ) // if not yet registered
    {
        bcore_arr_fp_s* arr1 = bcore_arr_fp_s_create();
        bcore_push_dependencies( signal_handler, arr1 );
        BFOR_EACH( i, arr1 )
        {
            bcore_push_signal_handler_with_dependencies_unique_recursive( ( bcore_fp_signal_handler )arr1->data[ i ], arr );
        }

        bcore_arr_fp_s_push( arr, ( fp_t )signal_handler );
        bcore_arr_fp_s_discard( arr1 );
    }
}

// Assembly:
testq %rdi, %rdi
je 0x59792
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
movq $-0x1, %rdx
movq %rbx, %rcx
callq 0xc4680
cmpq 0x10(%r14), %rax
jne 0x59787
xorl %eax, %eax
callq 0xc434b
movq %rax, %r15
movq %rsp, %r12
movabsq $-0x190f64e6fae6255c, %rsi # imm = 0xE6F09B190519DAA4
movabsq $0x2c61b4d51672db73, %rdx # imm = 0x2C61B4D51672DB73
movq %r12, %rdi
movq %rax, %rcx
callq 0xe9d9b
movq %r12, %rdi
callq *%rbx
testq %r15, %r15
je 0x59774
cmpq $0x0, 0x10(%r15)
je 0x59774
xorl %r12d, %r12d
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x596e7
incq %r12
cmpq 0x10(%r15), %r12
jb 0x5975b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc450f
movq %r15, %rdi
callq 0xc437a
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.c
// Function: bcore_down
void bcore_down( s2_t verbosity )
{
    if( !signal_handler_arr_fp_g ) return;

    bcore_mutex_s_lock( &mutex );
    if( !signal_handler_arr_fp_g ) ERR( "Shutdown race condition detected: Do not call bcore_down from multiple threads." );

    bcore_signal_s signal_down1 = bcore_signal_init( TYPEOF_all, TYPEOF_down1, &verbosity );
    bcore_signal_s signal_down0 = bcore_signal_init( TYPEOF_all, TYPEOF_down0, &verbosity );

    // shut down all but first library in reverse order
    for( uz_t i = signal_handler_arr_fp_g->size - 1; i > 0; i-- )
    {
        ( ( bcore_fp_signal_handler )signal_handler_arr_fp_g->data[ i ] )( &signal_down1 );
        ( ( bcore_fp_signal_handler )signal_handler_arr_fp_g->data[ i ] )( &signal_down0 );
    }

    bcore_arr_fp_s_discard( signal_handler_arr_fp_g );
    signal_handler_arr_fp_g = NULL;

    bcore_mutex_s_unlock( &mutex );
    bcore_mutex_s_down( &mutex );

    bcore_general_signal_handler( &signal_down1 );

    if( verbosity > 0 )
    {
        bcore_msg( "\nBeth global system's memory usage (bytes):\n");
        uz_t space = bcore_tbman_total_granted_space();
        bcore_msg( "Total ................. % 7zu\n", space );
    }

    bcore_general_signal_handler( &signal_down0 );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, 0xc(%rsp)
cmpq $0x0, 0x14970a(%rip)    # 0x1a2f50
je 0x59976
leaq 0x1496d5(%rip), %rdi    # 0x1a2f28
callq 0x11f515
cmpq $0x0, 0x1496f0(%rip)    # 0x1a2f50
jne 0x59883
leaq 0xe895b(%rip), %rdi     # 0x1421c4
leaq 0xe895f(%rip), %rsi     # 0x1421cf
leaq 0xe8960(%rip), %rcx     # 0x1421d7
movl $0xbc, %edx
xorl %eax, %eax
callq 0xc80f6
leaq 0x28(%rsp), %rdi
movabsq $-0x190f64e6fae6255c, %rbx # imm = 0xE6F09B190519DAA4
movabsq $-0x69a05654ee793a14, %rdx # imm = 0x965FA9AB1186C5EC
leaq 0xc(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rcx
callq 0xe9d9b
leaq 0x10(%rsp), %rdi
movabsq $-0x69a05554ee793861, %rdx # imm = 0x965FAAAB1186C79F
movq %rbx, %rsi
movq %r14, %rcx
callq 0xe9d9b
movq 0x149683(%rip), %rax    # 0x1a2f50
movq 0x10(%rax), %r15
decq %r15
je 0x59909
leaq 0x28(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq 0x149669(%rip), %rax    # 0x1a2f50
movq 0x8(%rax), %rax
movq %rbx, %rdi
callq *(%rax,%r15,8)
movq 0x149657(%rip), %rax    # 0x1a2f50
movq 0x8(%rax), %rax
movq %r14, %rdi
callq *(%rax,%r15,8)
decq %r15
jne 0x598e0
movq 0x149640(%rip), %rdi    # 0x1a2f50
callq 0xc437a
movq $0x0, 0x149630(%rip) # 0x1a2f50
leaq 0x149601(%rip), %rbx    # 0x1a2f28
movq %rbx, %rdi
callq 0x11f547
movq %rbx, %rdi
callq 0x11f3ee
leaq 0x28(%rsp), %rdi
callq 0xe9daa
cmpl $0x0, 0xc(%rsp)
jle 0x5996c
leaq 0xe88d8(%rip), %rdi     # 0x142227
xorl %eax, %eax
callq 0xc7e11
callq 0x11c4a0
leaq 0xe88f2(%rip), %rdi     # 0x142254
movq %rax, %rsi
xorl %eax, %eax
callq 0xc7e11
leaq 0x10(%rsp), %rdi
callq 0xe9daa
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.c
// Function: init_once
static void init_once()
{
    /** System wide settings
     *  Locale settings can afffect printf and scanf using a decimal point vs a decimal comma.
     *  Within beth a decimal point is preferred at all times.
     *
     *  We should enforce it via setlocale below because scanf is used to scan floating point
     *  data from text sources. E.g. via btml, btcl etc. Variable treatment can make parameter
     *  files unreadable across platforms.
     */
    setlocale( LC_ALL, "C" );

    /// bcore-library initialization
    bcore_signal_s signal_init0 = bcore_signal_init( TYPEOF_all, TYPEOF_init0, NULL );
    bcore_signal_s signal_init1 = bcore_signal_init( TYPEOF_all, TYPEOF_init1, NULL );

    bcore_general_signal_handler( &signal_init0 );
    bcore_general_signal_handler( &signal_init1 );

    bcore_mutex_s_init( &mutex );
    signal_handler_arr_fp_g = bcore_arr_fp_s_create();
    bcore_arr_fp_s_push( signal_handler_arr_fp_g, ( fp_t )bcore_general_signal_handler );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0xf580b(%rip), %rsi     # 0x14f1c5
movl $0x6, %edi
callq 0xd3f0
leaq 0x18(%rsp), %rbx
movabsq $-0x190f64e6fae6255c, %r14 # imm = 0xE6F09B190519DAA4
movabsq $0x6a72cf8f8250f179, %rdx # imm = 0x6A72CF8F8250F179
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xe9d9b
movq %rsp, %r15
movabsq $0x6a72ce8f8250efc6, %rdx # imm = 0x6A72CE8F8250EFC6
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xe9d9b
movq %rbx, %rdi
callq 0xe9daa
leaq 0x90397(%rip), %rbx     # 0xe9daa
movq %r15, %rdi
callq 0xe9daa
leaq 0x149506(%rip), %rdi    # 0x1a2f28
callq 0x11f33c
xorl %eax, %eax
callq 0xc434b
movq %rax, 0x14951b(%rip)    # 0x1a2f50
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc450f
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_inst_create
x_inst* x_inst_create( tp_t type )
{
    // bcore_x_inst.h:97:1
    
    if( type != 0 && !x_stamp_t_is_aware(type ) )
    {
        ERR_fa( "Function 'x_inst:create' can only be used for aware types. Use 'x_inst:t_create' instead." );
    }
    return ((x_inst*)( bcore_inst_t_create(type )));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x59bc2
movq %rdi, %rbx
leaq 0x150695(%rip), %rax    # 0x1aa0f8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rdi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rdi, %rdx
je 0x59abd
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %rbx, %rdx
je 0x59abd
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %rbx, %rdx
je 0x59abd
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %rbx, %rdx
jne 0x59bcc
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0x59aed
movabsq $0x541d0401d4dcff33, %rdi # imm = 0x541D0401D4DCFF33
movq %rbx, %rsi
callq 0xf3f85
movq %rax, %r14
leaq 0x150616(%rip), %rdi    # 0x1aa0f8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r14, %rdi
xorl %esi, %esi
callq 0x10decf
testb %al, %al
jne 0x59b1c
leaq 0xe89a6(%rip), %rdi     # 0x1424a8
leaq 0xe89ad(%rip), %rsi     # 0x1424b6
leaq 0xe89b1(%rip), %rcx     # 0x1424c1
movl $0x6f, %edx
xorl %eax, %eax
callq 0xc825d
testq %rbx, %rbx
je 0x59bc2
leaq 0x14f93c(%rip), %rax    # 0x1a9468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rbx, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rbx, %rdx
je 0x59b82
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %rbx, %rdx
je 0x59b82
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %rbx, %rdx
je 0x59b82
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %rbx, %rdx
jne 0x59bd4
movq (%rax,%rcx), %rdi
testq %rdi, %rdi
jne 0x59bb5
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %rbx, %rsi
callq 0xf3f85
movq %rax, %r14
leaq 0x14f8c1(%rip), %rdi    # 0x1a9468
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0xa8(%rdi)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
jmp 0x59ac1
xorl %edi, %edi
jmp 0x59b86
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_source_point_s_clone_source
x_source* x_source_point_s_clone_source( const x_source_point_s* o )
{
    // bcore_x_source.h:211:1
    
    x_source* source = x_source_a_clone(o->source);
    x_source_set_index(source,o->index );
    return  source;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x5a596
movq (%r14), %rsi
movabsq $0x2e28ff78616384dd, %rdi # imm = 0x2E28FF78616384DD
callq 0x1222bd
movq (%r14), %r15
leaq 0x14ef6f(%rip), %rax    # 0x1a9468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x5a553
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x5a553
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x5a553
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x5a64f
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5a583
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14eef0(%rip), %rdi    # 0x1a9468
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %r14, %rsi
callq *0xc0(%r12)
movq %rax, %r14
jmp 0x5a599
xorl %r14d, %r14d
movq 0x10(%rbx), %rbx
movq (%r14), %r15
leaq 0x14f721(%rip), %rax    # 0x1a9cc8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x5a5fd
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x5a5fd
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x5a5fd
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x5a64a
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5a62d
movabsq $-0x7e8ee9b9b4bbaa8, %rdi # imm = 0xF817116464B44558
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14f6a6(%rip), %rdi    # 0x1a9cc8
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10aa6e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x5a601
xorl %r12d, %r12d
jmp 0x5a557
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_source_get_d_dir
st_s* x_source_get_d_dir( const x_source* o )
{
    // bcore_x_source.h:158:1
    
    sc_t file = x_source_get_file(o);
    if( !file ) return  NULL;
    return  bcore_file_folder_path(file );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x14eac1(%rip), %rax    # 0x1a9cc8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r14, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r14, %rdx
je 0x5b25d
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r14, %rdx
je 0x5b25d
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r14, %rdx
je 0x5b25d
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r14, %rdx
jne 0x5b2b2
movq (%rax,%rcx), %r15
testq %r15, %r15
jne 0x5b28d
movabsq $-0x7e8ee9b9b4bbaa8, %rdi # imm = 0xF817116464B44558
movq %r14, %rsi
callq 0xf3f85
movq %rax, %r15
leaq 0x14ea46(%rip), %rdi    # 0x1a9cc8
movq %r14, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10aa35
testq %rax, %rax
je 0x5b2aa
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc8e31
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x5b261
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_push_d
x_inst* x_array_t_push_d( x_array* o, tp_t t, x_inst* v )
{
    // bcore_x_array.h:210:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
    
        if( p->item_p )
        {
            bcore_array_p_push( p, ( bcore_array* )o, sr_psm( p->item_p, v ) );
        }
        else
        {
            bcore_array_p_push( p, ( bcore_array* )o, sr_asm( v ) );
        }
    
        if( p->is_of_links )
        {
            return v;
        }
        else if( p->is_static )
        {
            uz_t size = 0;
            u0_t* data = bcore_array_p_get_d_data_size( p, o, &size );
            return ( x_inst* )( data + p->item_p->size * ( size - 1 ) );
        }
        else
        {
            return bcore_array_p_get_last( p, ( bcore_array* )o ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x14da5e(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5b41c
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x5b41c
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x5b41c
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x5b4f4
movq (%rax,%rcx), %r15
testq %r15, %r15
jne 0x5b44c
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r15
leaq 0x14d9df(%rip), %rdi    # 0x1a8e20
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq 0x28(%r15), %rax
testq %rax, %rax
jne 0x5b466
testq %rbx, %rbx
je 0x5b464
movq (%rbx), %rdi
callq 0x1123e1
jmp 0x5b466
xorl %eax, %eax
movq %rbx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl $0x2, %eax
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0xf7857
cmpb $0x0, 0x42(%r15)
jne 0x5b4e5
cmpb $0x1, 0x40(%r15)
jne 0x5b4cf
leaq 0x18(%rsp), %rbx
movq $0x0, (%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf826a
movq 0x28(%r15), %rcx
movq (%rbx), %rbx
decq %rbx
imulq 0x18(%rcx), %rbx
addq %rax, %rbx
jmp 0x5b4e5
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf7833
movq (%rbx), %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x5b420
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_push_c
x_inst* x_array_t_push_c( x_array* o, tp_t t, const x_inst* v )
{
    // bcore_x_array.h:244:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
    
        if( p->item_p )
        {
            bcore_array_p_push( p, ( bcore_array* )o, sr_pwc( p->item_p, v ) );
        }
        else
        {
            bcore_array_p_push( p, ( bcore_array* )o, sr_awc( v ) );
        }
    
        if( p->is_of_links )
        {
            uz_t size = 0;
            x_inst** data = bcore_array_p_get_d_data_size( p, o, &size );
            return data[ size - 1 ];
        }
        else if( p->is_static )
        {
            uz_t size = 0;
            u0_t* data = bcore_array_p_get_d_data_size( p, o, &size );
            return ( x_inst* )( data + p->item_p->size * ( size - 1 ) );
        }
        else
        {
            return bcore_array_p_get_last( p, ( bcore_array* )o ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x14d909(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5b571
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x5b571
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x5b571
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x5b66d
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0x5b5a1
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r14
leaq 0x14d88a(%rip), %rdi    # 0x1a8e20
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq 0x28(%r14), %rax
testq %rax, %rax
jne 0x5b5bb
testq %r15, %r15
je 0x5b5b9
movq (%r15), %rdi
callq 0x1123e1
jmp 0x5b5bb
xorl %eax, %eax
movq %r15, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl $0x1, %eax
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf7857
cmpb $0x1, 0x42(%r14)
jne 0x5b613
leaq 0x18(%rsp), %r15
movq $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf826a
movq (%r15), %rcx
movq -0x8(%rax,%rcx,8), %rax
jmp 0x5b661
cmpb $0x1, 0x40(%r14)
jne 0x5b64b
leaq 0x18(%rsp), %r15
movq $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf826a
movq %rax, %rcx
movq 0x28(%r14), %rdx
movq (%r15), %rax
decq %rax
imulq 0x18(%rdx), %rax
addq %rcx, %rax
jmp 0x5b661
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf7833
movq (%r15), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
jmp 0x5b575
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_push_t
x_inst* x_array_t_push_t( x_array* o, tp_t t, tp_t val_type )
{
    // bcore_x_array.h:280:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
        bcore_array_p_push( p, ( bcore_array* )o, sr_t_create( val_type ) );
    
        if( p->is_of_links )
        {
            uz_t size = 0;
            x_inst** data = bcore_array_p_get_d_data_size( p, o, &size );
            return data[ size - 1 ];
        }
        else if( p->is_static )
        {
            uz_t size = 0;
            u0_t* data = bcore_array_p_get_d_data_size( p, o, &size );
            return ( x_inst* )( data + p->item_p->size * ( size - 1 ) );
        }
        else
        {
            return bcore_array_p_get_last( p, ( bcore_array* )o ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x14d790(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5b6ea
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x5b6ea
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x5b6ea
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x5b7e8
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0x5b71a
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r14
leaq 0x14d711(%rip), %rdi    # 0x1a8e20
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r15, %rdi
callq 0x112326
movq %rax, %r12
testq %r15, %r15
je 0x5b734
movq %r15, %rdi
callq 0x1123e1
jmp 0x5b736
xorl %eax, %eax
movq %r12, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl $0x2, %eax
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf7857
cmpb $0x1, 0x42(%r14)
jne 0x5b78e
leaq 0x18(%rsp), %r15
movq $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf826a
movq (%r15), %rcx
movq -0x8(%rax,%rcx,8), %rax
jmp 0x5b7dc
cmpb $0x1, 0x40(%r14)
jne 0x5b7c6
leaq 0x18(%rsp), %r15
movq $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf826a
movq %rax, %rcx
movq 0x28(%r14), %rdx
movq (%r15), %rax
decq %rax
imulq 0x18(%rdx), %rax
addq %rcx, %rax
jmp 0x5b7dc
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf7833
movq (%r15), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
jmp 0x5b6ee
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_set_d
x_inst* x_array_t_set_d( x_array* o, tp_t t, sz_t index, x_inst* v )
{
    // bcore_x_array.h:352:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
    
        if( p->item_p )
        {
            bcore_array_p_set( p, ( bcore_array* )o, index, sr_psm( p->item_p, v ) );
        }
        else
        {
            bcore_array_p_set( p, ( bcore_array* )o, index, sr_asm( v ) );
        }
    
        if( p->is_of_links )
        {
            return v;
        }
        else if( p->is_static )
        {
            u0_t* data = bcore_array_p_get_d_data( p, o );
            return ( x_inst* )( data + p->item_p->size * index );
        }
        else
        {
            return bcore_array_p_get( p, ( bcore_array* )o, index ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x14d43f(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5ba3b
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0x5ba3b
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0x5ba3b
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0x5bb0d
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5ba6b
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r13, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14d3c0(%rip), %rdi    # 0x1a8e20
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq 0x28(%r12), %rax
testq %rax, %rax
jne 0x5ba86
testq %r15, %r15
je 0x5ba84
movq (%r15), %rdi
callq 0x1123e1
jmp 0x5ba86
xorl %eax, %eax
movq %r15, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl $0x2, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf83af
cmpb $0x0, 0x42(%r12)
jne 0x5bafc
cmpb $0x1, 0x40(%r12)
jne 0x5bae3
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq 0x28(%r12), %rcx
imulq 0x18(%rcx), %rbx
addq %rax, %rbx
movq %rbx, %r15
jmp 0x5bafc
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xf83a3
movq (%r15), %r15
movq %r15, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x5ba3f
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_set_c
x_inst* x_array_t_set_c( x_array* o, tp_t t, sz_t index, const x_inst* v )
{
    // bcore_x_array.h:385:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
    
        if( p->item_p )
        {
            bcore_array_p_set( p, ( bcore_array* )o, index, sr_pwc( p->item_p, v ) );
        }
        else
        {
            bcore_array_p_set( p, ( bcore_array* )o, index, sr_awc( v ) );
        }
    
        if( p->is_of_links )
        {
            x_inst** data = bcore_array_p_get_d_data( p, o );
            return data[ index ];
        }
        else if( p->is_static )
        {
            u0_t* data = bcore_array_p_get_d_data( p, o );
            return ( x_inst* )( data + p->item_p->size * index );
        }
        else
        {
            return bcore_array_p_get( p, ( bcore_array* )o, index ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x14d2eb(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5bb8f
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0x5bb8f
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0x5bb8f
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0x5bc6f
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5bbbf
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r13, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14d26c(%rip), %rdi    # 0x1a8e20
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq 0x28(%r12), %rax
testq %rax, %rax
jne 0x5bbda
testq %r15, %r15
je 0x5bbd8
movq (%r15), %rdi
callq 0x1123e1
jmp 0x5bbda
xorl %eax, %eax
movq %r15, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl $0x1, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf83af
cmpb $0x1, 0x42(%r12)
jne 0x5bc23
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq (%rax,%rbx,8), %rbx
jmp 0x5bc5e
cmpb $0x1, 0x40(%r12)
jne 0x5bc45
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq 0x28(%r12), %rcx
imulq 0x18(%rcx), %rbx
addq %rax, %rbx
jmp 0x5bc5e
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xf83a3
movq (%r15), %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x5bb93
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_set_t
x_inst* x_array_t_set_t( x_array* o, tp_t t, sz_t index, tp_t val_type )
{
    // bcore_x_array.h:419:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
        bcore_array_p_set( p, ( bcore_array* )o, index, sr_t_create( val_type ) );
    
        if( p->is_of_links )
        {
            x_inst** data = bcore_array_p_get_d_data( p, o );
            return data[ index ];
        }
        else if( p->is_static )
        {
            u0_t* data = bcore_array_p_get_d_data( p, o );
            return ( x_inst* )( data + p->item_p->size * index );
        }
        else
        {
            return bcore_array_p_get( p, ( bcore_array* )o, index ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x14d189(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5bcf1
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0x5bcf1
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0x5bcf1
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0x5bdd2
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5bd21
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r13, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14d10a(%rip), %rdi    # 0x1a8e20
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r15, %rdi
callq 0x112326
movq %rax, %r13
testq %r15, %r15
je 0x5bd3b
movq %r15, %rdi
callq 0x1123e1
jmp 0x5bd3d
xorl %eax, %eax
movq %r13, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl $0x2, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf83af
cmpb $0x1, 0x42(%r12)
jne 0x5bd86
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq (%rax,%rbx,8), %rbx
jmp 0x5bdc1
cmpb $0x1, 0x40(%r12)
jne 0x5bda8
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq 0x28(%r12), %rcx
imulq 0x18(%rcx), %rbx
addq %rax, %rbx
jmp 0x5bdc1
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xf83a3
movq (%r15), %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x5bcf5
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_insert_d
x_inst* x_array_t_insert_d( x_array* o, tp_t t, sz_t index, x_inst* v )
{
    // bcore_x_array.h:445:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
    
        if( p->item_p )
        {
            bcore_array_p_insert( p, ( bcore_array* )o, index, sr_psm( p->item_p, v ) );
        }
        else
        {
            bcore_array_p_insert( p, ( bcore_array* )o, index, sr_asm( v ) );
        }
    
        if( p->is_of_links )
        {
            return v;
        }
        else if( p->is_static )
        {
            u0_t* data = bcore_array_p_get_d_data( p, o );
            return ( x_inst* )( data + p->item_p->size * index );
        }
        else
        {
            return bcore_array_p_get( p, ( bcore_array* )o, index ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x14d026(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5be54
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0x5be54
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0x5be54
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0x5bf26
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5be84
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r13, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14cfa7(%rip), %rdi    # 0x1a8e20
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq 0x28(%r12), %rax
testq %rax, %rax
jne 0x5be9f
testq %r15, %r15
je 0x5be9d
movq (%r15), %rdi
callq 0x1123e1
jmp 0x5be9f
xorl %eax, %eax
movq %r15, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl $0x2, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf735f
cmpb $0x0, 0x42(%r12)
jne 0x5bf15
cmpb $0x1, 0x40(%r12)
jne 0x5befc
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq 0x28(%r12), %rcx
imulq 0x18(%rcx), %rbx
addq %rax, %rbx
movq %rbx, %r15
jmp 0x5bf15
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xf83a3
movq (%r15), %r15
movq %r15, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x5be58
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_insert_c
x_inst* x_array_t_insert_c( x_array* o, tp_t t, sz_t index, const x_inst* v )
{
    // bcore_x_array.h:478:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
    
        if( p->item_p )
        {
            bcore_array_p_insert( p, ( bcore_array* )o, index, sr_pwc( p->item_p, v ) );
        }
        else
        {
            bcore_array_p_insert( p, ( bcore_array* )o, index, sr_awc( v ) );
        }
    
        if( p->is_of_links )
        {
            x_inst** data = bcore_array_p_get_d_data( p, o );
            return data[ index ];
        }
        else if( p->is_static )
        {
            u0_t* data = bcore_array_p_get_d_data( p, o );
            return ( x_inst* )( data + p->item_p->size * index );
        }
        else
        {
            return bcore_array_p_get( p, ( bcore_array* )o, index ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x14ced2(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5bfa8
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0x5bfa8
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0x5bfa8
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0x5c088
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5bfd8
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r13, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14ce53(%rip), %rdi    # 0x1a8e20
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq 0x28(%r12), %rax
testq %rax, %rax
jne 0x5bff3
testq %r15, %r15
je 0x5bff1
movq (%r15), %rdi
callq 0x1123e1
jmp 0x5bff3
xorl %eax, %eax
movq %r15, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl $0x1, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf735f
cmpb $0x1, 0x42(%r12)
jne 0x5c03c
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq (%rax,%rbx,8), %rbx
jmp 0x5c077
cmpb $0x1, 0x40(%r12)
jne 0x5c05e
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq 0x28(%r12), %rcx
imulq 0x18(%rcx), %rbx
addq %rax, %rbx
jmp 0x5c077
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xf83a3
movq (%r15), %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x5bfac
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_insert_t
x_inst* x_array_t_insert_t( x_array* o, tp_t t, sz_t index, tp_t val_type )
{
    // bcore_x_array.h:512:1
    
    
        const bcore_array_s* p = bcore_array_s_get_typed( t );
        bcore_array_p_insert( p, ( bcore_array* )o, index, sr_t_create( val_type ) );
    
        if( p->is_of_links )
        {
            x_inst** data = bcore_array_p_get_d_data( p, o );
            return data[ index ];
        }
        else if( p->is_static )
        {
            u0_t* data = bcore_array_p_get_d_data( p, o );
            return ( x_inst* )( data + p->item_p->size * index );
        }
        else
        {
            return bcore_array_p_get( p, ( bcore_array* )o, index ).o;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x14cd70(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rsi, %rdx
je 0x5c10a
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0x5c10a
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0x5c10a
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0x5c1eb
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x5c13a
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r13, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x14ccf1(%rip), %rdi    # 0x1a8e20
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r15, %rdi
callq 0x112326
movq %rax, %r13
testq %r15, %r15
je 0x5c154
movq %r15, %rdi
callq 0x1123e1
jmp 0x5c156
xorl %eax, %eax
movq %r13, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl $0x2, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf735f
cmpb $0x1, 0x42(%r12)
jne 0x5c19f
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq (%rax,%rbx,8), %rbx
jmp 0x5c1da
cmpb $0x1, 0x40(%r12)
jne 0x5c1c1
movq %r12, %rdi
movq %r14, %rsi
callq 0xf730c
movq 0x28(%r12), %rcx
imulq 0x18(%rcx), %rbx
addq %rax, %rbx
jmp 0x5c1da
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xf83a3
movq (%r15), %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x5c10e
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_array_t_c_get_sr
sr_s x_array_t_c_get_sr( const x_array* o, tp_t t, sz_t index )
{
    // bcore_x_array.h:538:1
    
    sr_s sr = bcore_array_t_get( t, ((const bcore_array*)(o)), index );
    if( sr_s_is_weak(&(sr)) ) sr_s_set_const(&(sr),true );
    return  sr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14cc11(%rip), %rax    # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0x5c265
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x5c265
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x5c265
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x5c2c3
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x5c295
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0x14cb96(%rip), %rdi    # 0x1a8e20
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xf83a3
movq 0x10(%rbx), %rax
testb $0x2, %al
jne 0x5c2b6
orq $0x1, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0x5c269
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_stamp_path_s_to_sink
const x_stamp_path_s* x_stamp_path_s_to_sink( const x_stamp_path_s* o, bcore_sink* sink )
{
    // bcore_x_stamp.h:245:1
    
    for(sz_t i = 0; i < o->size; i++ )
    {
        if( i > 0 ) bcore_sink_a_push_fa(sink,".", o->data[ i ] );
        if( o->data[ i ] == TYPEOF_x_stamp_path_s_array_index )
        {
            i++;
            bcore_sink_a_push_fa(sink,"[#<tp_t>]", o->data[ i ] );
        }
        else
        {
            bcore_sink_a_push_fa(sink,"#<sc_t>", bnameof( o->data[ i ] ) );
        }
    }
    return  o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x5c814
movq %rsi, %r14
leaq 0xdf3ec(%rip), %r15     # 0x13bb93
movabsq $-0x20efc6351cd3a688, %rbp # imm = 0xDF1039CAE32C5978
leaq 0xf34ac(%rip), %r13     # 0x14fc64
xorl %r12d, %r12d
testq %r12, %r12
jle 0x5c7d5
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x109273
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
cmpq %rbp, %rdi
jne 0x5c7f6
movq 0x8(%rax,%r12,8), %rdx
incq %r12
movq %r14, %rdi
leaq 0xe5df8(%rip), %rsi     # 0x1425ec
jmp 0x5c804
callq 0xe0cbc
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x109273
incq %r12
cmpq 0x10(%rbx), %r12
jb 0x5c7bb
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.xo.c
// Function: x_stamp_t_m_get_sr
sr_s x_stamp_t_m_get_sr( x_stamp* o, tp_t t, tp_t name )
{
    // bcore_x_stamp.h:409:1
    
    const bcore_via_s* p = bcore_via_s_get_typed( t );
    sz_t index = bcore_via_p_nget_index( p, ((const bcore_via*)(o)), name );
    if( index < 0 ) return  sr_null();
    return  bcore_via_p_iget( p, ((const bcore_via*)(o)), index );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14c15b(%rip), %rax    # 0x1aa0f8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0x5dff3
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x5dff3
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x5dff3
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x5e064
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x5e023
movabsq $0x541d0401d4dcff33, %rdi # imm = 0x541D0401D4DCFF33
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0x14c0e0(%rip), %rdi    # 0x1aa0f8
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10d7e8
testq %rax, %rax
js 0x5e049
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x10ca2c
jmp 0x5e057
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0x5dff7
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_stamp_t_m_get_sr_i
sr_s x_stamp_t_m_get_sr_i( x_stamp* o, tp_t t, sz_t index )
{
    // bcore_x_stamp.h:419:1
    
    const bcore_via_s* p = bcore_via_s_get_typed( t );
    if( index < 0 || index >= bcore_via_p_get_size( p, ((const bcore_via*)(o)) ) ) return  sr_null();
    return  bcore_via_p_iget( p, ((const bcore_via*)(o)), index );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14c073(%rip), %rax    # 0x1aa0f8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0x5e0db
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x5e0db
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x5e0db
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x5e144
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x5e10b
movabsq $0x541d0401d4dcff33, %rdi # imm = 0x541D0401D4DCFF33
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0x14bff8(%rip), %rdi    # 0x1aa0f8
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
testq %r14, %r14
js 0x5e129
cmpq %r14, 0x20(%r13)
jbe 0x5e129
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x10ca2c
jmp 0x5e137
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0x5e0df