LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btcl_random_s_btcl_function
er_t x_btcl_random_s_btcl_function( const x_btcl_random_s* o, tp_t name, const x_source_point_s* sp, x_btcl_frame_s* lexical_frame, const bcore_arr_sr_s* args, sr_s* result )
{
    // bcore_x_btcl_random.x:59:5
    
    switch( name )
    {
        case TYPEOF_list:
        {BLM_INIT_LEVEL(3);
            x_btcl_list_s* list = ((x_btcl_list_s*)BLM_LEVEL_T_PUSH(3,x_btcl_list_s,x_btcl_list_s_create()));
            x_btcl_random_s_fill_list(o,sz_max( 0, sr_s_to_f3(&(args->data[0])) ), list );
            sr_s_asm(result,((x_btcl_list_s*)bcore_fork(list)) );
            BLM_RETURNV(er_t, 0)
        BLM_DOWN();}
    
        default: return  x_source_point_s_parse_error_fa(sp,"Invalid function name '#<sc_t>'.", bnameof( name ) );
    }
    return  0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movabsq $-0x40886552968b7ebf, %rax # imm = 0xBF779AAD69748141
cmpq %rax, %rsi
jne 0x9d533
movq %r9, %rbx
movq %r8, %r15
movq %rdi, %r14
leaq 0xfe945(%rip), %rax     # 0x19bdd0
movq (%rax), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xd6675
movq $0x3, 0x10(%r12)
callq 0x8c302
movabsq $-0x240ec4eb25c1f3e8, %rdx # imm = 0xDBF13B14DA3E0C18
movl $0x3, %esi
movq %r12, %rdi
movq %rax, %rcx
callq 0xd68a8
movq %rax, %r12
movq 0x8(%r15), %rdi
callq 0x10847b
cvttsd2si %xmm0, %rsi
xorl %r15d, %r15d
testq %rsi, %rsi
cmovleq %r15, %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x9d149
movq %r12, %rdi
callq 0xbe7e4
movq %rax, %r14
movq %rbx, %rdi
callq 0x107ca9
testq %r14, %r14
je 0x9d50c
movq (%r14), %rdi
callq 0x1074f1
movq %rax, %r15
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
callq 0xd6d2c
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rsi, %rdi
callq 0xd6ec4
leaq 0x9c1fb(%rip), %rsi     # 0x139740
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8dd3f
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btcl_test_adder_s_copy
sz_t x_btcl_test_adder_s_btcl_function_arity( const x_btcl_test_adder_s* o, tp_t name )
{
    // bcore_x_btcl_test.x:28:5
    
    switch( name )
    {
        case TYPEOF_add_a_b: return  2;
        case TYPEOF_add_a  : return  1;
        default: break;
    }
    return  -1; // return -1 to indicate that a function of given name does not exist
}

// Assembly:
cmpq %rsi, %rdi
je 0x9d78f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x52ceeacf749ab0ef, %r15 # imm = 0x52CEEACF749AB0EF
leaq 0xfed7d(%rip), %rax     # 0x19c468
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 0x9d741
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x9d741
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x9d741
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x9d74a
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x9d771
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0xfed02(%rip), %rdi     # 0x19c468
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq 0x90(%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btcl_test_adder_s_btcl_function
er_t x_btcl_test_adder_s_btcl_function( const x_btcl_test_adder_s* o, tp_t name, const x_source_point_s* sp, x_btcl_frame_s* lexical_frame, const bcore_arr_sr_s* args, sr_s* result )
{
    // bcore_x_btcl_test.x:39:5
    
    switch( name )
    {
        case TYPEOF_add_a_b: sr_s_from_f3(result,o->additive + sr_s_to_f3(&(args->data[0])) + sr_s_to_f3(&(args->data[1])) ); break;
        case TYPEOF_add_a  : sr_s_from_f3(result,o->additive + sr_s_to_f3(&(args->data[0])) ); break;
        default: return  x_source_point_s_parse_error_fa(sp,"Invalid function name '#<sc_t>'.", bnameof( name ) );
    }
    return  0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %r8, %r14
movabsq $0x22dcf9fdfce6cd70, %rax # imm = 0x22DCF9FDFCE6CD70
cmpq %rax, %rsi
je 0x9da3f
movabsq $-0x27a629443cbaa973, %rax # imm = 0xD859D6BBC345568D
cmpq %rax, %rsi
jne 0x9da6d
movsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
callq 0x10847b
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
addq $0x18, %rdi
jmp 0x9da4e
movsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
callq 0x10847b
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x108138
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rsi, %rdi
callq 0xd6ec4
leaq 0x9bcc1(%rip), %rsi     # 0x139740
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8dd3f
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_hmap_tp_s_copy
bcore_arr_tp_s* x_hmap_tp_s_get_key_arr( const x_hmap_tp_s* o, bcore_arr_tp_s* key_arr )
{
    // bcore_x_hmap.h:124:5
    
    bcore_arr_tp_s_set_size(key_arr,0 );
    sz_t size = x_hmap_tp_s_size(o);
    tp_t key = 0;
    for(sz_t i = 0; i < size; i++ ) if( (key = x_hmap_tp_s_idx_key(o,i )) ) bcore_arr_tp_s_push(key_arr,key );
    return  key_arr;
}

// Assembly:
cmpq %rsi, %rdi
je 0x9e3be
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x1ba738e6b01c5241, %r15 # imm = 0x1BA738E6B01C5241
leaq 0xfe14e(%rip), %rax     # 0x19c468
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 0x9e370
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x9e370
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x9e370
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x9e379
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x9e3a0
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0xfe0d3(%rip), %rdi     # 0x19c468
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq 0x90(%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_hmap_tp_s_m_get_val_arr
x_array* x_hmap_tp_s_m_get_val_arr( x_hmap_tp_s* o, x_array* val_arr )
{
    // bcore_x_hmap.h:135:5
    
    x_array_set_size(val_arr,0 );
    sz_t size = x_hmap_tp_s_size(o);
    for(sz_t i = 0; i < size; i++ ) if( x_hmap_tp_s_idx_key(o,i ) ) x_array_push_d(val_arr,((x_inst*)bcore_fork(x_hmap_tp_s_m_idx_val(o,i ))) );
    return  val_arr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
leaq 0xfd7c1(%rip), %rax     # 0x19be20
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 0x9e6b5
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x9e6b5
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x9e6b5
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x9e6be
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x9e6e5
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0xfd746(%rip), %rdi     # 0x19be20
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xec548
addq $0x8, %r14
movq %r14, %rdi
callq 0xccb0a
testq %rax, %rax
jle 0x9e742
movq %rax, %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xccb0f
testq %rax, %rax
je 0x9e73a
movq %r14, %rdi
movq %r12, %rsi
callq 0xccb1c
movq %rax, %rdi
callq 0xbe7e4
movq (%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x55b79
incq %r12
cmpq %r12, %r15
jne 0x9e709
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.xo.c
// Function: x_hmap_tp_s_c_get_val_arr
x_array* x_hmap_tp_s_c_get_val_arr( const x_hmap_tp_s* o, x_array* val_arr )
{
    // bcore_x_hmap.h:143:5
    
    x_array_set_size(val_arr,0 );
    sz_t size = x_hmap_tp_s_size(o);
    for(sz_t i = 0; i < size; i++ ) if( x_hmap_tp_s_idx_key(o,i ) ) x_array_push_d(val_arr,x_inst_clone(x_hmap_tp_s_c_idx_val(o,i )) );
    return  val_arr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rsp)
movq (%rsi), %r15
leaq 0xfd6b3(%rip), %rax     # 0x19be20
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 0x9e7c3
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x9e7c3
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x9e7c3
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x9e7cc
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x9e7f3
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0xfd638(%rip), %rdi     # 0x19be20
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r12, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xec548
addq $0x8, %r14
movq %r14, %rdi
callq 0xccb0a
testq %rax, %rax
jle 0x9e901
movq %rax, %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xccb0f
testq %rax, %rax
je 0x9e8f5
movq %r14, %rdi
movq %r12, %rsi
callq 0xccb1c
testq %rax, %rax
je 0x9e8e7
movq %rax, %rbp
movq (%rax), %r13
leaq 0xfdc17(%rip), %rdx     # 0x19c468
movl (%rdx), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%rdx,%rax,8), %rcx
movq 0x18(%rdx,%rax,8), %rdx
andq %r13, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
movl $0x8, %ecx
cmpq %r13, %rdx
je 0x9e8a6
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0x9e8a6
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0x9e8a6
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0x9e8af
movq (%rax,%rcx), %rbx
testq %rbx, %rbx
jne 0x9e8d6
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r13, %rsi
callq 0xe9bc5
movq %rax, %rbx
leaq 0xfdb9d(%rip), %rdi     # 0x19c468
movq %r13, %rsi
movq %rax, %rdx
callq 0x115fac
movq %rbx, %rdi
movq %rbp, %rsi
callq *0xc0(%rbx)
movq %rax, %rdx
jmp 0x9e8e9
xorl %edx, %edx
movq (%rsp), %rdi
movq (%rdi), %rsi
callq 0x55b79
incq %r12
cmpq %r12, %r15
jne 0x9e81c
movq (%rsp), %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.xo.c
// Function: x_hmap_tp_st_s_create_st_status
st_s* x_hmap_tp_st_s_create_st_status( const x_hmap_tp_st_s* o )
{
    // bcore_x_hmap.x:23:1
    
    st_s* string = st_s_create();
    st_s_push_fa(string,"keys ........... #<sz_t>\n", x_hmap_tp_keys(((const x_hmap_tp*)(o))) );
    st_s_push_fa(string,"nodes .......... #<sz_t>\n", x_hmap_tp_size(((const x_hmap_tp*)(o))) );
    st_s_push_fa(string,"keys/nodes ..... #<f3_t>\n", x_hmap_tp_size(((const x_hmap_tp*)(o))) > 0 ? ( f3_t )( x_hmap_tp_keys(((const x_hmap_tp*)(o))) ) / x_hmap_tp_size(((const x_hmap_tp*)(o))) : 0 );
    return  string;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccae6
leaq 0x9a9ca(%rip), %rsi     # 0x139761
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a8a5
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccb0a
leaq 0x9a9bf(%rip), %rsi     # 0x13977b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a8a5
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccb0a
testq %rax, %rax
jle 0x9ee22
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccae6
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccb0a
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x9ee26
xorpd %xmm0, %xmm0
leaq 0x9a968(%rip), %rsi     # 0x139795
movq %rbx, %rdi
movb $0x1, %al
callq 0x10a8a5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_hmap_tp_m_map_
x_hmap_tp_s* x_hmap_tp_m_map_( x_hmap_tp* o )
{
    // bcore_x_hmap.h:153:5
    
    assert( x_stamp_is_aware(((const x_stamp*)(o))) );
    x_inst* map = x_stamp_m_get_i(((x_stamp*)(o)),0 );
    if( !map || map->_ != TYPEOF_x_hmap_tp_s ) ERR_fa( "First element of '#<sc_t>' must be of type '#<sc_t>'", bnameof( o->_ ), bnameof( ((tp_t)(TYPEOF_x_hmap_tp_s)) ) );
    return  ((x_hmap_tp_s*)(map));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r15
movabsq $0x1ba738e6b01c5241, %rbx # imm = 0x1BA738E6B01C5241
movq (%rdi), %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x5858a
testb $0x2, 0x10(%r14)
jne 0x9ee85
movq 0x18(%rsp), %r14
testq %r14, %r14
je 0x9ee9d
cmpq %rbx, (%r14)
jne 0x9eea0
jmp 0x9eeda
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
xorl %r14d, %r14d
movq (%r15), %rdi
callq 0xd6ec4
movq %rax, %r15
movq %rbx, %rdi
callq 0xd6ec4
leaq 0x9a8f5(%rip), %rdi     # 0x1397af
leaq 0x9846d(%rip), %rsi     # 0x13732e
leaq 0x9a8f8(%rip), %rcx     # 0x1397c0
movl $0x239f, %edx           # imm = 0x239F
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xbe6f9
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_hmap_tp_c_map_
const x_hmap_tp_s* x_hmap_tp_c_map_( const x_hmap_tp* o )
{
    // bcore_x_hmap.h:161:5
    
    assert( x_stamp_is_aware(((const x_stamp*)(o))) );
    const x_inst* map = x_stamp_c_get_i(((const x_stamp*)(o)),0 );
    if( !map || map->_ != TYPEOF_x_hmap_tp_s ) ERR_fa( "First element of '#<sc_t>' must be of type '#<sc_t>'", bnameof( o->_ ), bnameof( ((tp_t)(TYPEOF_x_hmap_tp_s)) ) );
    return  ((const x_hmap_tp_s*)(map));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5858a
movq 0x10(%r14), %rax
testb $0x2, %al
jne 0x9ef68
orq $0x1, %rax
movq %rax, 0x28(%rsp)
movabsq $0x1ba738e6b01c5241, %r15 # imm = 0x1BA738E6B01C5241
testb $0x2, %al
jne 0x9ef87
movq 0x18(%rsp), %r14
testq %r14, %r14
je 0x9ef9f
cmpq %r15, (%r14)
jne 0x9efa2
jmp 0x9efdc
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0xd6ec4
movq %rax, %rbx
movq %r15, %rdi
callq 0xd6ec4
leaq 0x9a839(%rip), %rdi     # 0x1397f5
leaq 0x9836b(%rip), %rsi     # 0x13732e
leaq 0x9a7f6(%rip), %rcx     # 0x1397c0
movl $0x23a9, %edx           # imm = 0x23A9
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xbe6f9
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_hmap_tp_m_getf
x_inst* x_hmap_tp_m_getf( x_hmap_tp* o, tp_t key )
{
    // bcore_x_hmap.h:186:5
    
    x_inst* inst = x_hmap_tp_s_m_get(x_hmap_tp_m_map_(o),key );
    if( !inst ) inst = x_hmap_tp_s_set_d(x_hmap_tp_m_map_(o),key, x_inst_create(x_hmap_tp_a_TE(o) ) );
    if( !inst ) ERR_fa( "'#<sc_t>.m_getf:' stamp must define transient type 'TE'.", bnameof( o->_ ) );
    return  inst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9ee42
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0xcc468
testq %rax, %rax
je 0x9f078
movq (%rax), %r15
testq %r15, %r15
jne 0x9f174
movq %rbx, %rdi
callq 0x9ee42
movq %rax, %r15
movq (%rbx), %r12
leaq 0xfc6c3(%rip), %rax     # 0x19b750
movl 0xfc6bd(%rip), %ecx     # 0x19b750
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 0x9f0e7
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x9f0e7
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x9f0e7
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x9f0f0
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x9f117
movabsq $0x3683902fe0ac12b7, %rdi # imm = 0x3683902FE0AC12B7
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0xfc644(%rip), %rdi     # 0x19b750
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %rbx, %rdi
callq *0x10(%r13)
movq %rax, %rdi
callq 0x54314
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xcc584
testq %rax, %rax
je 0x9f145
movq (%rax), %r15
testq %r15, %r15
jne 0x9f174
movq (%rbx), %rdi
callq 0xd6ec4
leaq 0x9a6b2(%rip), %rdi     # 0x139806
leaq 0x981d3(%rip), %rsi     # 0x13732e
leaq 0x9a6b5(%rip), %rcx     # 0x139817
xorl %r15d, %r15d
movl $0x23b3, %edx           # imm = 0x23B3
movq %rax, %r8
xorl %eax, %eax
callq 0xbe6f9
movq %r15, %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.xo.c
// Function: x_hmap_tp_test_map_s_create_st_status
st_s* x_hmap_tp_test_map_s_create_st_status( const x_hmap_tp_test_map_s* o )
{
    // bcore_x_hmap.x:43:5
    
    st_s* string = st_s_create();
    st_s_push_fa(string,"keys ........... #<sz_t>\n", x_hmap_tp_keys(((const x_hmap_tp*)(o))) );
    st_s_push_fa(string,"nodes .......... #<sz_t>\n", x_hmap_tp_size(((const x_hmap_tp*)(o))) );
    st_s_push_fa(string,"keys/nodes ..... #<f3_t>\n", x_hmap_tp_size(((const x_hmap_tp*)(o))) > 0 ? ( f3_t )( x_hmap_tp_keys(((const x_hmap_tp*)(o))) ) / x_hmap_tp_size(((const x_hmap_tp*)(o))) : 0 );
    return  string;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %eax, %eax
callq 0x109c82
movq %rax, %rbx
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccae6
leaq 0x9944f(%rip), %rsi     # 0x139761
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a8a5
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccb0a
leaq 0x99444(%rip), %rsi     # 0x13977b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a8a5
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccb0a
testq %rax, %rax
jle 0xa039d
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccae6
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x9ef36
leaq 0x8(%rax), %rdi
callq 0xccb0a
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xa03a1
xorpd %xmm0, %xmm0
leaq 0x993ed(%rip), %rsi     # 0x139795
movq %rbx, %rdi
movb $0x1, %al
callq 0x10a8a5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_deque_inst_s_set_space
x_deque_inst_s* x_deque_inst_s_set_space( x_deque_inst_s* o, sz_t space )
{
    // bcore_x_deque.h:85:5
    
    ASSERT( space >= o->size );
    x_array_set_space(((x_array*)(&(o->adl))),space );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, 0x28(%rdi)
jle 0xa1b66
leaq 0x8bb03(%rip), %rdi     # 0x12d647
leaq 0x97f9e(%rip), %rsi     # 0x139ae9
leaq 0x97fa8(%rip), %rdx     # 0x139afa
leaq 0x957d5(%rip), %rcx     # 0x13732e
movl $0x2498, %r8d           # imm = 0x2498
xorl %eax, %eax
callq 0xbe4ef
leaq 0x8(%rbx), %r15
movq 0x8(%rbx), %r12
leaq 0xfa2ab(%rip), %rax     # 0x19be20
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 0xa1bcb
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xa1bcb
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xa1bcb
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xa1bd4
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xa1bfb
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0xfa230(%rip), %rdi     # 0x19be20
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xebeb6
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.xo.c
// Function: x_deque_inst_s_clear
x_deque_inst_s* x_deque_inst_s_clear( x_deque_inst_s* o )
{
    // bcore_x_deque.h:91:5
    
    x_array_clear(((x_array*)(&(o->adl))));
    o->first = o->size = 0;
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %r15
leaq 0xfa1f0(%rip), %rax     # 0x19be20
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 0xa1c86
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0xa1c86
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0xa1c86
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0xa1c8f
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0xa1cb6
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0xfa175(%rip), %rdi     # 0x19be20
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xebeb6
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
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.xo.c
// Function: x_deque_inst_s_inc_adl_size
x_deque_inst_s* x_deque_inst_s_inc_adl_size( x_deque_inst_s* o )
{
    // bcore_x_deque.h:105:5
    
    x_array_set_size(((x_array*)(&(o->adl))),sz_max( 1, o->adl.size * 2 ) );
    for(sz_t i = 0; i < o->first; i++ )
    {
        o->adl.data[ i + o->size ] = o->adl.data[ i ];
        o->adl.data[ i          ] = NULL;
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %r12
movq 0x18(%rdi), %rax
addq %rax, %rax
cmpq $0x2, %rax
movl $0x1, %r15d
cmovgeq %rax, %r15
leaq 0xfa117(%rip), %rax     # 0x19be20
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 0xa1d5f
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xa1d5f
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xa1d5f
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xa1d68
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xa1d8f
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0xfa09c(%rip), %rdi     # 0x19be20
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xec548
movq 0x30(%rbx), %rax
testq %rax, %rax
jle 0xa1dd4
movq 0x28(%rbx), %rcx
shlq $0x3, %rcx
xorl %edx, %edx
movq 0x10(%rbx), %rsi
leaq (%rsi,%rdx,8), %rdi
movq (%rsi,%rdx,8), %rsi
movq %rsi, (%rcx,%rdi)
movq 0x10(%rbx), %rsi
movq $0x0, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xa1db0
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.xo.c
// Function: x_deque_inst_s_push_last_d
x_inst* x_deque_inst_s_push_last_d( x_deque_inst_s* o, x_inst* inst )
{
    // bcore_x_deque.h:115:5
    
    if( o->size == o->adl.size ) x_deque_inst_s_inc_adl_size(o);
    x_inst_a_attach( &(o->adl.data[ ( o->first + o->size ) % o->adl.size ] ), (x_inst*)( inst));
    o->size++;
    return  ((x_inst*)(inst));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rcx
movq 0x28(%rdi), %rax
cmpq %rcx, %rax
jne 0xa1e08
movq %r14, %rdi
callq 0xa1cd9
movq 0x18(%r14), %rcx
movq 0x28(%r14), %rax
addq 0x30(%r14), %rax
xorl %edx, %edx
divq %rcx
leaq (,%rdx,8), %rdi
addq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xa1e34
incq 0x28(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_deque_inst_s_push_first_d
x_inst* x_deque_inst_s_push_first_d( x_deque_inst_s* o, x_inst* inst )
{
    // bcore_x_deque.h:123:5
    
    if( o->size == o->adl.size )  x_deque_inst_s_inc_adl_size(o);
    o->first = ( o->first == 0 ) ? o->adl.size - 1 : o->first - 1;
    x_inst_a_attach( &(o->adl.data[ o->first ] ), (x_inst*)( inst));
    o->size++;
    return  ((x_inst*)(inst));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0xa1f35
movq %r14, %rdi
callq 0xa1cd9
movq 0x30(%r14), %rax
testq %rax, %rax
jne 0xa1f42
movq 0x18(%r14), %rax
leaq -0x1(%rax), %rcx
movq %rcx, 0x30(%r14)
leaq -0x8(,%rax,8), %rdi
addq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xa1e34
incq 0x28(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_deque_inst_s_d_pop_last
x_inst* x_deque_inst_s_d_pop_last( x_deque_inst_s* o )
{
    // bcore_x_deque.h:132:5
    
    if( o->size == 0 ) return  NULL;
    sz_t adl_idx = x_deque_inst_s_adl_idx(o,o->size - 1 );
    x_inst* inst = ((x_inst*)(o->adl.data[ adl_idx ]));
    o->adl.data[ adl_idx ] = NULL;
    o->size--;
    return  inst;
}

// Assembly:
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0xa1f9b
decq %rcx
movq 0x30(%rdi), %rax
addq %rcx, %rax
xorl %edx, %edx
divq 0x18(%rdi)
movq 0x10(%rdi), %rsi
movq (%rsi,%rdx,8), %rax
movq $0x0, (%rsi,%rdx,8)
movq %rcx, 0x28(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_deque_inst_s_d_pop_first
x_inst* x_deque_inst_s_d_pop_first( x_deque_inst_s* o )
{
    // bcore_x_deque.h:142:5
    
    if( o->size == 0 ) return  NULL;
    x_inst* inst = ((x_inst*)(o->adl.data[ o->first ]));
    o->adl.data[ o->first ] = NULL;
    o->size--;
    o->first = ( o->first + 1 ) % o->adl.size;
    return  inst;
}

// Assembly:
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0xa1fd1
movq 0x10(%rdi), %rsi
movq 0x30(%rdi), %rax
movq (%rsi,%rax,8), %rcx
movq $0x0, (%rsi,%rax,8)
decq %rdx
movq %rdx, 0x28(%rdi)
incq %rax
xorl %edx, %edx
divq 0x18(%rdi)
movq %rdx, 0x30(%rdi)
jmp 0xa1fd3
xorl %ecx, %ecx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_deque_m_inst_
x_deque_inst_s* x_deque_m_inst_( x_deque* o )
{
    // bcore_x_deque.h:168:1
    
    assert( x_stamp_is_aware(((const x_stamp*)(o))) );
    x_inst* que = x_stamp_m_get_i(((x_stamp*)(o)),0 );
    if( !que || que->_ != TYPEOF_x_deque_inst_s ) ERR_fa( "First element of '#<sc_t>' must be of type '#<sc_t>'", bnameof( o->_ ), bnameof( ((tp_t)(TYPEOF_x_deque_inst_s)) ) );
    return  ((x_deque_inst_s*)(que));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r15
movabsq $-0x13dd24988bd0f869, %rbx # imm = 0xEC22DB67742F0797
movq (%rdi), %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x5858a
testb $0x2, 0x10(%r14)
jne 0xa2232
movq 0x18(%rsp), %r14
testq %r14, %r14
je 0xa224a
cmpq %rbx, (%r14)
jne 0xa224d
jmp 0xa2287
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
xorl %r14d, %r14d
movq (%r15), %rdi
callq 0xd6ec4
movq %rax, %r15
movq %rbx, %rdi
callq 0xd6ec4
leaq 0x978ac(%rip), %rdi     # 0x139b13
leaq 0x950c0(%rip), %rsi     # 0x13732e
leaq 0x9754b(%rip), %rcx     # 0x1397c0
movl $0x24fc, %edx           # imm = 0x24FC
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xbe6f9
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_deque_c_inst_
const x_deque_inst_s* x_deque_c_inst_( const x_deque* o )
{
    // bcore_x_deque.h:176:1
    
    assert( x_stamp_is_aware(((const x_stamp*)(o))) );
    const x_inst* que = x_stamp_c_get_i(((x_stamp*)(o)),0 );
    if( !que || que->_ != TYPEOF_x_deque_inst_s ) ERR_fa( "First element of '#<sc_t>' must be of type '#<sc_t>'", bnameof( o->_ ), bnameof( ((tp_t)(TYPEOF_x_deque_inst_s)) ) );
    return  ((const x_deque_inst_s*)(que));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5858a
movq 0x10(%r14), %rax
testb $0x2, %al
jne 0xa22c6
orq $0x1, %rax
movq %rax, 0x28(%rsp)
movabsq $-0x13dd24988bd0f869, %r15 # imm = 0xEC22DB67742F0797
testb $0x2, %al
jne 0xa22e5
movq 0x18(%rsp), %r14
testq %r14, %r14
je 0xa22fd
cmpq %r15, (%r14)
jne 0xa2300
jmp 0xa233a
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0xd6ec4
movq %rax, %rbx
movq %r15, %rdi
callq 0xd6ec4
leaq 0x97809(%rip), %rdi     # 0x139b23
leaq 0x9500d(%rip), %rsi     # 0x13732e
leaq 0x97498(%rip), %rcx     # 0x1397c0
movl $0x2506, %edx           # imm = 0x2506
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xbe6f9
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/./bcore_x_deque.h
// Function: x_deque_d_pop_last
func d x_inst* d_pop_last( m@* o )
    {
        if( o.size == 0 ) = NULL;
        sz_t adl_idx = o.adl_idx( o.size - 1 );
        d x_inst* inst = o.adl.[ adl_idx ].cast( d x_inst* );
        o.adl.[ adl_idx ] = NULL;
        o.size--;
        = inst;
    }

// Assembly:
pushq %rax
callq 0xa21ef
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0xb57ae
movq %rax, %rcx
decq %rsi
movq 0x30(%rax), %rax
addq %rsi, %rax
xorl %edx, %edx
divq 0x18(%rcx)
movq 0x10(%rcx), %rdi
movq (%rdi,%rdx,8), %rax
movq $0x0, (%rdi,%rdx,8)
movq %rsi, 0x28(%rcx)
jmp 0xb57b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/./bcore_x_deque.h
// Function: x_deque_d_pop_first
func d x_inst* d_pop_first( m@* o )
    {
        if( o.size == 0 ) = NULL;
        d x_inst* inst = o.adl.[ o.first ].cast( d x_inst* );
        o.adl.[ o.first ] = NULL;
        o.size--;
        o.first = ( o.first + 1 ) % o.adl.size;
        = inst;
    }

// Assembly:
pushq %rax
callq 0xa21ef
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0xb57ee
movq %rax, %rcx
movq 0x10(%rax), %rdi
movq 0x30(%rax), %rax
movq (%rdi,%rax,8), %rsi
movq $0x0, (%rdi,%rax,8)
decq %rdx
movq %rdx, 0x28(%rcx)
incq %rax
xorl %edx, %edx
divq 0x18(%rcx)
movq %rdx, 0x30(%rcx)
jmp 0xb57f0
xorl %esi, %esi
movq %rsi, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_copy
void bcore_arr_uz_s_copy( bcore_arr_uz_s* o, const bcore_arr_uz_s* src )
{
    if( o->space < src->size )
    {
        if( o->space > 0 ) o->data = bcore_un_alloc( sizeof( uz_t ), o->data, o->space, 0, &o->space );
        o->data = bcore_un_alloc( sizeof( uz_t ), NULL, o->space, src->size, &o->space );
    }
    bcore_u_memcpy( sizeof( uz_t ), o->data, src->data, src->size );
    o->size = src->size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdx
movq 0x10(%rsi), %rcx
cmpq %rcx, %rdx
jae 0xb5aa4
leaq 0x18(%rbx), %r15
testq %rdx, %rdx
je 0xb5aaa
movq 0x8(%rbx), %rsi
movl $0x8, %edi
xorl %ecx, %ecx
movq %r15, %r8
callq 0xbe7da
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rdx
movq 0x10(%r14), %rcx
jmp 0xb5aac
movq 0x8(%rbx), %rsi
jmp 0xb5ac6
xorl %edx, %edx
movl $0x8, %edi
xorl %esi, %esi
movq %r15, %r8
callq 0xbe7da
movq %rax, %rsi
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq 0x8(%r14), %rdx
movl $0x8, %edi
callq 0xbe8bb
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_create
BCORE_DEFINE_FUNCTION_CREATE(  bcore_arr_uz_s )
BCORE_DEFINE_FUNCTION_DISCARD( bcore_arr_uz_s )
BCORE_DEFINE_FUNCTION_CLONE(   bcore_arr_uz_s )

// ---------------------------------------------------------------------------------------------------------------------

static bcore_self_s* arr_uz_s_create_self( void )
{
    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( "bcore_arr_uz_s = bcore_array { aware_t _; uz_t [] arr; }", bcore_arr_uz_s );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_arr_uz_s_init, "bcore_fp_init", "init" );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_arr_uz_s_down, "bcore_fp_down", "down" );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_arr_uz_s_copy, "bcore_fp_copy", "copy" );
    return self;
}

// Assembly:
pushq %rbx
movl $0x20, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %rbx
movl $0x20, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $0x3cc9acead7f9ac2e, %rax # imm = 0x3CC9ACEAD7F9AC2E
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_set_space
bcore_arr_uz_s* bcore_arr_uz_s_set_space( bcore_arr_uz_s* o, uz_t space )
{
    if( o->space == 0 )
    {
        o->data = bcore_u_alloc( sizeof( uz_t ), NULL, space, &o->space );
    }
    else
    {
        o->data = bcore_un_alloc( sizeof( uz_t ), o->data, o->space, space, &o->space );
    }
    if( o->size > space ) o->size = space;
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r8
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0xb5bbc
movq 0x8(%rbx), %rsi
movl $0x8, %edi
movq %r14, %rcx
callq 0xbe7da
jmp 0xb5bce
movl $0x8, %edi
xorl %esi, %esi
movq %r14, %rdx
movq %r8, %rcx
callq 0xbe7d5
movq %rax, 0x8(%rbx)
cmpq %r14, 0x10(%rbx)
jbe 0xb5bdc
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_fill
bcore_arr_uz_s* bcore_arr_uz_s_fill( bcore_arr_uz_s* o, uz_t size, uz_t v )
{
    bcore_arr_uz_s_set_space( o, size );
    for( uz_t i = 0; i < size; i++ ) o->data[ i ] = v;
    o->size = size;
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb5b92
testq %r14, %r14
je 0xb5c11
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq %r15, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xb5c01
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_set_size
bcore_arr_uz_s* bcore_arr_uz_s_set_size( bcore_arr_uz_s* o, uz_t size )
{
    bcore_arr_uz_s_set_space( o, size );
    if( size > o->size )
    {
        for( sz_t i = o->size; i < size; i++ ) o->data[ i ] = 0;
    }
    o->size = size;
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb5b92
movq 0x10(%rbx), %rax
cmpq %r14, %rax
jae 0xb5c4a
movq 0x8(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xb5c36
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_step_fill
bcore_arr_uz_s* bcore_arr_uz_s_step_fill( bcore_arr_uz_s* o, uz_t v_start, s3_t step, uz_t size )
{
    bcore_arr_uz_s_set_space( o, size );
    uz_t v = v_start;
    for( uz_t i = 0; i < size; i++ )
    {
        o->data[ i ] = v;
        v += step;
    }
    o->size = size;
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rsi
callq 0xb5b92
testq %rbx, %rbx
je 0xb5c8f
xorl %eax, %eax
movq 0x8(%r14), %rcx
movq %r12, (%rcx,%rax,8)
addq %r15, %r12
incq %rax
cmpq %rax, %rbx
jne 0xb5c7c
movq %rbx, 0x10(%r14)
movq %r14, %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_arr.c
// Function: bcore_arr_uz_s_make_strong
void bcore_arr_uz_s_make_strong( bcore_arr_uz_s* o )
{
    if( o->size > o->space )
    {
        uz_t* data = o->data;
        o->data = bcore_u_alloc( sizeof( uz_t ), NULL, o->size, &o->space );
        bcore_u_memcpy( sizeof( uz_t ), o->data, data, o->size );
    }
}

// Assembly:
movq 0x10(%rdi), %rdx
cmpq 0x18(%rdi), %rdx
jbe 0xb5ce6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
movq 0x8(%rdi), %r14
movl $0x8, %edi
xorl %esi, %esi
callq 0xbe7d5
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rcx
movl $0x8, %edi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbe8bb
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_push
void bcore_arr_uz_s_push( bcore_arr_uz_s* o, uz_t v )
{
    if( o->size >  o->space ) bcore_arr_uz_s_make_strong( o );
    if( o->size == o->space )
    {
        o->data = bcore_un_alloc( sizeof( uz_t ), o->data, o->space, o->space > 0 ? o->space * 2 : 1, &o->space );
    }
    o->data[ o->size++ ] = v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
jbe 0xb5d0e
movq %r14, %rdi
callq 0xb5ca2
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rdx
movq 0x8(%r14), %rax
cmpq %rdx, %rcx
jne 0xb5d40
leaq 0x18(%r14), %r8
leaq (%rdx,%rdx), %rsi
testq %rdx, %rdx
movl $0x1, %ecx
cmovneq %rsi, %rcx
movl $0x8, %edi
movq %rax, %rsi
callq 0xbe7da
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_push_left
bcore_arr_uz_s* bcore_arr_uz_s_push_left( bcore_arr_uz_s* o, uz_t v )
{
    bcore_arr_uz_s_push( o, 0 );
    for( sz_t i = o->size - 1; i > 0; i-- ) o->data[ i ] = o->data[ i - 1 ];
    o->data[ 0 ] = v;
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0xb5ce7
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
testq %rcx, %rcx
jle 0xb5d89
movq 0x8(%rbx), %rcx
movq -0x10(%rcx,%rax,8), %rdx
movq %rdx, -0x8(%rcx,%rax,8)
decq %rax
cmpq $0x1, %rax
ja 0xb5d72
movq 0x8(%rbx), %rax
movq %r14, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_push_arr
bcore_arr_uz_s* bcore_arr_uz_s_push_arr( bcore_arr_uz_s* o, const bcore_arr_uz_s* arr )
{
    if( arr->size == 0 ) return o;
    if( o->size > o->space ) bcore_arr_uz_s_make_strong( o );
    if( o->size + arr->size >= o->space )
    {
        uz_t new_space = uz_max( o->space * 2, o->size + arr->size );
        o->data = bcore_un_alloc( sizeof( uz_t ), o->data, o->space, new_space, &o->space );
    }
    for( sz_t i = 0; i < arr->size; i++ ) o->data[ o->size++ ] = arr->data[ i ];
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0xb5e28
movq %rsi, %r14
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
cmpq %rdx, %rcx
jbe 0xb5dcf
movq %rbx, %rdi
callq 0xb5ca2
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
movq 0x10(%r14), %rax
addq %rax, %rcx
cmpq %rdx, %rcx
jb 0xb5dfc
leaq 0x18(%rbx), %r8
leaq (%rdx,%rdx), %rax
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq 0x8(%rbx), %rsi
movl $0x8, %edi
callq 0xbe7da
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xb5e28
xorl %eax, %eax
movq 0x8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x10(%rbx)
movq %rcx, (%rdx,%rsi,8)
incq %rax
cmpq 0x10(%r14), %rax
jb 0xb5e03
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_cmp
s2_t bcore_arr_uz_s_cmp( const bcore_arr_uz_s* o, const bcore_arr_uz_s* b )
{
    if( o->size == 0 ) return ( b->size == 0 ) ? 0 :  1;
    if( b->size == 0 ) return -1;
    uz_t min_size = uz_min( o->size, b->size );
    for( sz_t i = 0; i < min_size; i++ )
    {
        if( o->data[ i ] != b->data[ i ] ) return ( o->data[ i ] < b->data[ i ] ) ? 2 : -2;
    }
    return ( o->size == b->size ) ? 0 : ( o->size < b->size ) ? +1 : -1;
}

// Assembly:
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rcx
testq %rdx, %rdx
je 0xb5ea1
testq %rcx, %rcx
je 0xb5eaa
cmpq %rcx, %rdx
movq %rcx, %rax
cmovbq %rdx, %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
cmpq %r9, (%rdi,%r8,8)
jne 0xb5eb0
incq %r8
cmpq %r8, %rax
jne 0xb5e78
xorl %esi, %esi
cmpq %rcx, %rdx
movl $0x0, %eax
adcl $-0x1, %eax
orl $0x1, %eax
cmpq %rcx, %rdx
cmovel %esi, %eax
retq
xorl %eax, %eax
testq %rcx, %rcx
setne %al
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
setb %al
movzbl %al, %eax
leal -0x2(,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_sort
bcore_arr_uz_s* bcore_arr_uz_s_sort( bcore_arr_uz_s* o, s2_t order ) // stable mergesort
{
    if( o->space < o->size ) bcore_arr_uz_s_make_strong( o );
    uz_t* buf = bcore_u_alloc( sizeof( uz_t ), NULL, o->size >> 1, NULL );
    uz_sort( o->data, o->size, buf, order );
    bcore_free( buf );
    return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
cmpq %rdx, 0x18(%rdi)
jae 0xb5edd
movq %rbx, %rdi
callq 0xb5ca2
movq 0x10(%rbx), %rdx
shrq %rdx
movl $0x8, %edi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xbe7d5
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0xb5f13
movq %r14, %rdi
callq 0xbe7a3
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: uz_sort
static void uz_sort( uz_t* data, uz_t size, uz_t* buf, s2_t order )
{
    if( size < 2 ) return;
    uz_t size1 = size >> 1;
    uz_sort( data,         size1       , buf, order );
    uz_sort( data + size1, size - size1, buf, order );
    bcore_u_memcpy( sizeof( uz_t ), buf, data, size1 );
    if( order > 0 )
    {
        for( uz_t i = 0, w = 0, r = size1; i < size1; )
        {
            data[ w++ ] = ( r == size || buf[ i ] <= data[ r ] ) ? buf[ i++ ] : data[ r++ ];
        }
    }
    else
    {
        for( uz_t i = 0, w = 0, r = size1; i < size1; )
        {
            data[ w++ ] = ( r == size || buf[ i ] >= data[ r ] ) ? buf[ i++ ] : data[ r++ ];
        }
    }
}

// Assembly:
cmpq $0x2, %rsi
jb 0xb5fcd
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %r12
shrq %r12
movq %r12, %rsi
callq 0xb5f13
leaq (%r15,%r12,8), %rdi
movq %r14, %rsi
subq %r12, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb5f13
movl $0x8, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xbe8bb
xorl %eax, %eax
movq %r15, %rcx
movq %r12, %rdx
testl %ebp, %ebp
jle 0xb5f9c
movq (%rbx,%rax,8), %rsi
cmpq %r14, %rdx
je 0xb5f8b
movq (%r15,%rdx,8), %rdi
cmpq %rdi, %rsi
jbe 0xb5f8b
incq %rdx
movq %rdi, %rsi
jmp 0xb5f8e
incq %rax
movq %rsi, (%rcx)
addq $0x8, %rcx
cmpq %r12, %rax
jb 0xb5f71
jmp 0xb5fc5
movq (%rbx,%rax,8), %rsi
cmpq %r14, %rdx
je 0xb5fb6
movq (%r15,%rdx,8), %rdi
cmpq %rdi, %rsi
jae 0xb5fb6
incq %rdx
movq %rdi, %rsi
jmp 0xb5fb9
incq %rax
movq %rsi, (%rcx)
addq $0x8, %rcx
cmpq %r12, %rax
jb 0xb5f9c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_reorder
bcore_arr_uz_s* bcore_arr_uz_s_reorder( bcore_arr_uz_s* o, const bcore_arr_uz_s* order )
{
    if( o->space < o->size ) bcore_arr_uz_s_make_strong( o );
    uz_t buf_space = 0;
    uz_t* buf = bcore_u_alloc( sizeof( uz_t ), NULL, order->size, &buf_space );
    for( uz_t i = 0; i < order->size; i++ )
    {
        assert( order->data[ i ] < o->size );
        buf[ i ] = o->data[ order->data[ i ] ];
    }
    bcore_un_alloc( sizeof( uz_t ), o->data, o->space, 0, &o->space );
    o->data = buf;
    o->space = buf_space;
    o->size = order->size;
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
jae 0xb5fee
movq %rbx, %rdi
callq 0xb5ca2
leaq 0x18(%rbx), %r15
movq %rsp, %rcx
movq $0x0, (%rcx)
movq 0x10(%r14), %rdx
movl $0x8, %edi
xorl %esi, %esi
callq 0xbe7d5
movq %rax, %r12
cmpq $0x0, 0x10(%r14)
je 0xb6035
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq 0x8(%r14), %rdx
movq (%rdx,%rax,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%r12,%rax,8)
incq %rax
cmpq 0x10(%r14), %rax
jb 0xb6018
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl $0x8, %edi
xorl %ecx, %ecx
movq %r15, %r8
callq 0xbe7da
movq %r12, 0x8(%rbx)
movq (%rsp), %rax
movq %rax, 0x18(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
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_arr.c
// Function: bcore_arr_uz_s_create_random_permutation
bcore_arr_uz_s* bcore_arr_uz_s_create_random_permutation( u2_t ( *rg )( u2_t ), u2_t rval, uz_t size )
{
    bcore_arr_uz_s* o = bcore_arr_uz_s_create();
    if( size == 0 ) return o;

    bcore_arr_uz_s_step_fill( o, 0, 1, size );
    uz_t idx = 0;

    for( uz_t i = 0; i < size; i++ )
    {
        idx = i + ( ( idx + ( rval = rg( rval ) ) ) % ( size - i ) );
        uz_t t = o->data[ i ];
        o->data[ i ] = o->data[ idx ];
        o->data[ idx ] = t;
    }

    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x20, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r15
movl $0x20, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $0x3cc9acead7f9ac2e, %rax # imm = 0x3CC9ACEAD7F9AC2E
movq %rax, (%r15)
testq %rbx, %rbx
je 0xb610e
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb5b92
xorl %eax, %eax
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0xb60bd
movq %rbx, 0x10(%r15)
xorl %r13d, %r13d
xorl %r12d, %r12d
movl %ebp, %edi
callq *%r14
movl %eax, %ebp
movl %eax, %eax
addq %r12, %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %r12
addq %r13, %r12
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rcx
movq (%rax,%r12,8), %rdx
movq %rdx, (%rax,%r13,8)
movq 0x8(%r15), %rax
movq %rcx, (%rax,%r12,8)
incq %r13
decq %rbx
jne 0xb60d7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq