LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1013b5(%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 %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0xa7ac5
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0xa7ac5
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0xa7ac5
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0xa7b61
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0xa7af5
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x101336(%rip), %rdi    # 0x1a8e20
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf69d8
addq $0x8, %r14
movq %r14, %rdi
callq 0xd69ef
testq %rax, %rax
jle 0xa7b52
movq %rax, %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xd69f4
testq %rax, %rax
je 0xa7b4a
movq %r14, %rdi
movq %r12, %rsi
callq 0xd6a01
movq %rax, %rdi
callq 0xc8348
movq (%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x5b3a7
incq %r12
cmpq %r12, %r15
jne 0xa7b19
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0xa7ac9
// File: /workspace/github_c_makefile_star2_O1/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 0x10129b(%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 %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0xa7bdf
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0xa7bdf
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0xa7bdf
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0xa7d36
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0xa7c0f
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x10121c(%rip), %rdi    # 0x1a8e20
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xf69d8
addq $0x8, %r14
movq %r14, %rdi
callq 0xd69ef
testq %rax, %rax
jle 0xa7d23
movq %rax, %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xd69f4
testq %rax, %rax
je 0xa7d11
movq %r14, %rdi
movq %r12, %rsi
callq 0xd6a01
testq %rax, %rax
je 0xa7d03
movq %rax, %rbp
movq (%rax), %r13
leaq 0x1017fb(%rip), %rdx    # 0x1a9468
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 0xa7cc2
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0xa7cc2
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0xa7cc2
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0xa7d1f
movq (%rax,%rcx), %rbx
testq %rbx, %rbx
jne 0xa7cf2
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r13, %rsi
callq 0xf3f85
movq %rax, %rbx
leaq 0x101781(%rip), %rdi    # 0x1a9468
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq %rbx, %rdi
movq %rbp, %rsi
callq *0xc0(%rbx)
movq %rax, %rdx
jmp 0xa7d05
xorl %edx, %edx
movq (%rsp), %rdi
movq (%rdi), %rsi
callq 0x5b3a7
incq %r12
cmpq %r12, %r15
jne 0xa7c38
jmp 0xa7d23
xorl %ebx, %ebx
jmp 0xa7cc6
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0xa7be3
// File: /workspace/github_c_makefile_star2_O1/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 0x114bbb
movq %rax, %rbx
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69cb
leaq 0x9c70b(%rip), %rsi     # 0x1448e9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1157cb
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69ef
leaq 0x9c700(%rip), %rsi     # 0x144903
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1157cb
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69ef
testq %rax, %rax
jle 0xa8269
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69cb
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69ef
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xa826d
xorpd %xmm0, %xmm0
leaq 0x9c6a9(%rip), %rsi     # 0x14491d
movq %rbx, %rdi
movb $0x1, %al
callq 0x1157cb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5e069
testb $0x2, 0x10(%r14)
je 0xa82da
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x112485
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movabsq $0x1ba738e6b01c5241, %r15 # imm = 0x1BA738E6B01C5241
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0xa82f3
cmpq %r15, (%r14)
je 0xa832d
movq (%rbx), %rdi
callq 0xe0cbc
movq %rax, %rbx
movq %r15, %rdi
callq 0xe0cbc
leaq 0x9c62a(%rip), %rdi     # 0x144937
leaq 0x9a1a2(%rip), %rsi     # 0x1424b6
leaq 0x9c62d(%rip), %rcx     # 0x144948
movl $0x239f, %edx           # imm = 0x239F
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xc825d
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5e069
movq 0x10(%r14), %rax
testb $0x2, %al
jne 0xa83c8
orq $0x1, %rax
movq %rax, 0x30(%rsp)
testb $0x2, 0x30(%rsp)
je 0xa83f8
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x112485
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movabsq $0x1ba738e6b01c5241, %r15 # imm = 0x1BA738E6B01C5241
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0xa8411
cmpq %r15, (%r14)
je 0xa844b
movq (%rbx), %rdi
callq 0xe0cbc
movq %rax, %rbx
movq %r15, %rdi
callq 0xe0cbc
leaq 0x9c552(%rip), %rdi     # 0x14497d
leaq 0x9a084(%rip), %rsi     # 0x1424b6
leaq 0x9c50f(%rip), %rcx     # 0x144948
movl $0x23a9, %edx           # imm = 0x23A9
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xc825d
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa8289
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0xd63b5
testq %rax, %rax
je 0xa84f0
movq (%rax), %r15
jmp 0xa84f3
xorl %r15d, %r15d
testq %r15, %r15
jne 0xa85cd
movq %rbx, %rdi
callq 0xa8289
movq %rax, %r15
movq (%rbx), %r12
leaq 0x10023f(%rip), %rax    # 0x1a8750
movl 0x100239(%rip), %ecx    # 0x1a8750
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 0xa856f
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xa856f
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xa856f
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xa860b
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xa859f
movabsq $0x3683902fe0ac12b7, %rdi # imm = 0x3683902FE0AC12B7
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0x1001bc(%rip), %rdi    # 0x1a8750
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq %rbx, %rdi
callq *0x10(%r13)
movq %rax, %rdi
callq 0x59a4c
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd64d1
testq %rax, %rax
je 0xa85ca
movq (%rax), %r15
jmp 0xa85cd
xorl %r15d, %r15d
testq %r15, %r15
jne 0xa85fe
movq (%rbx), %rdi
callq 0xe0cbc
leaq 0x9c3ad(%rip), %rdi     # 0x14498e
leaq 0x99ece(%rip), %rsi     # 0x1424b6
leaq 0x9c3b0(%rip), %rcx     # 0x14499f
movl $0x23b3, %edx           # imm = 0x23B3
movq %rax, %r8
xorl %eax, %eax
callq 0xc825d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0xa8573
// File: /workspace/github_c_makefile_star2_O1/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 0x114bbb
movq %rax, %rbx
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69cb
leaq 0x9b0d1(%rip), %rsi     # 0x1448e9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1157cb
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69ef
leaq 0x9b0c6(%rip), %rsi     # 0x144903
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1157cb
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69ef
testq %rax, %rax
jle 0xa98a3
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69cb
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xa8396
leaq 0x8(%rax), %rdi
callq 0xd69ef
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xa98a7
xorpd %xmm0, %xmm0
leaq 0x9b06f(%rip), %rsi     # 0x14491d
movq %rbx, %rdi
movb $0x1, %al
callq 0x1157cb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xab0e2
leaq 0x8d587(%rip), %rdi     # 0x138647
leaq 0x99baa(%rip), %rsi     # 0x144c71
leaq 0x99bb4(%rip), %rdx     # 0x144c82
leaq 0x973e1(%rip), %rcx     # 0x1424b6
movl $0x2498, %r8d           # imm = 0x2498
xorl %eax, %eax
callq 0xc8053
movq 0x8(%rbx), %r15
leaq 0xfdd33(%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 %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0xab143
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0xab143
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0xab143
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0xab192
movq (%rax,%rcx), %r13
leaq 0x8(%rbx), %r12
testq %r13, %r13
jne 0xab177
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0xfdcb4(%rip), %rdi     # 0x1a8e20
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xf6359
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0xab147
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x8(%rdi), %r14
leaq 0xfdc73(%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 %r14, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r14, %rdx
je 0xab203
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r14, %rdx
je 0xab203
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r14, %rdx
je 0xab203
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r14, %rdx
jne 0xab25a
movq (%rax,%rcx), %r12
leaq 0x8(%rbx), %r15
testq %r12, %r12
jne 0xab237
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r14, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0xfdbf4(%rip), %rdi     # 0x1a8e20
movq %r14, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xf6359
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0xab207
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x8(%rdi), %r15
movq 0x18(%rdi), %rax
addq %rax, %rax
cmpq $0x2, %rax
movl $0x1, %r14d
cmovgeq %rax, %r14
leaq 0xfdb95(%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 %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0xab2e5
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0xab2e5
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0xab2e5
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0xab36b
movq (%rax,%rcx), %r13
leaq 0x8(%rbx), %r12
testq %r13, %r13
jne 0xab319
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0xfdb12(%rip), %rdi     # 0x1a8e20
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xf69d8
movq 0x30(%rbx), %rax
testq %rax, %rax
jle 0xab35e
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 0xab33a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0xab2e9
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0xab396
movq %r14, %rdi
callq 0xab25f
movq 0x10(%r14), %r15
movq 0x28(%r14), %rax
addq 0x30(%r14), %rax
xorl %edx, %edx
divq 0x18(%r14)
movq %rdx, %r13
testq %rbx, %rbx
je 0xab3c2
movq (%rbx), %rsi
movabsq $-0x3b1008a961ddaa8, %rdi # imm = 0xFC4EFF7569E22558
callq 0x1222bd
testq %r15, %r15
je 0xab481
movq (%r15,%r13,8), %r12
testq %r12, %r12
je 0xab47d
movq %r13, (%rsp)
movq (%r12), %r13
leaq 0xfe081(%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 %r13, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r13, %rdx
je 0xab43d
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r13, %rdx
je 0xab43d
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r13, %rdx
je 0xab43d
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r13, %rdx
jne 0xab497
movq (%rax,%rcx), %rbp
testq %rbp, %rbp
jne 0xab46d
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r13, %rsi
callq 0xf3f85
movq %rax, %rbp
leaq 0xfe006(%rip), %rdi     # 0x1a9468
movq %r13, %rsi
movq %rax, %rdx
callq 0x12128c
movq %rbp, %rdi
movq %r12, %rsi
callq *0xb8(%rbp)
movq (%rsp), %r13
movq %rbx, (%r15,%r13,8)
incq 0x28(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xab441
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0xab4be
movq %r14, %rdi
callq 0xab25f
movq 0x30(%r14), %rbp
testq %rbp, %rbp
jne 0xab4cb
movq 0x18(%r14), %rbp
leaq -0x1(%rbp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%r14), %r15
testq %rbx, %rbx
je 0xab4ee
movq (%rbx), %rsi
movabsq $-0x3b1008a961ddaa8, %rdi # imm = 0xFC4EFF7569E22558
callq 0x1222bd
testq %r15, %r15
je 0xab5ac
movq -0x8(%r15,%rbp,8), %rsi
testq %rsi, %rsi
je 0xab5a7
movq (%rsi), %r12
leaq 0xfdf59(%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 %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xab565
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xab565
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xab565
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xab5c2
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xab59d
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %rsi, (%rsp)
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0xfdeda(%rip), %rdi     # 0x1a9468
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq (%rsp), %rsi
movq %r13, %rdi
callq *0xb8(%r13)
movq %rbx, -0x8(%r15,%rbp,8)
incq 0x28(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
jmp 0xab569
// File: /workspace/github_c_makefile_star2_O1/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 0xab5f5
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_O1/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 0xab62b
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 0xab62d
xorl %ecx, %ecx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5e069
testb $0x2, 0x10(%r14)
je 0xab8a8
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x112485
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movabsq $-0x13dd24988bd0f869, %r15 # imm = 0xEC22DB67742F0797
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0xab8c1
cmpq %r15, (%r14)
je 0xab8fb
movq (%rbx), %rdi
callq 0xe0cbc
movq %rax, %rbx
movq %r15, %rdi
callq 0xe0cbc
leaq 0x993c0(%rip), %rdi     # 0x144c9b
leaq 0x96bd4(%rip), %rsi     # 0x1424b6
leaq 0x9905f(%rip), %rcx     # 0x144948
movl $0x24fc, %edx           # imm = 0x24FC
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xc825d
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5e069
movq 0x10(%r14), %rax
testb $0x2, %al
jne 0xab93a
orq $0x1, %rax
movq %rax, 0x30(%rsp)
testb $0x2, 0x30(%rsp)
je 0xab96a
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x112485
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movabsq $-0x13dd24988bd0f869, %r15 # imm = 0xEC22DB67742F0797
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0xab983
cmpq %r15, (%r14)
je 0xab9bd
movq (%rbx), %rdi
callq 0xe0cbc
movq %rax, %rbx
movq %r15, %rdi
callq 0xe0cbc
leaq 0x9930e(%rip), %rdi     # 0x144cab
leaq 0x96b12(%rip), %rsi     # 0x1424b6
leaq 0x98f9d(%rip), %rcx     # 0x144948
movl $0x2506, %edx           # imm = 0x2506
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xc825d
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xab857
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0xbf1ed
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 0xbf1ef
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xab857
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0xbf22d
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 0xbf22f
xorl %esi, %esi
movq %rsi, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq 0x10(%rsi), %rdx
jae 0xbf50e
leaq 0x18(%rbx), %r15
testq %rdx, %rdx
je 0xbf4f3
movq 0x8(%rbx), %rsi
movl $0x8, %edi
xorl %ecx, %ecx
movq %r15, %r8
callq 0xc833e
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rdx
movq 0x10(%r14), %rcx
movl $0x8, %edi
xorl %esi, %esi
movq %r15, %r8
callq 0xc833e
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movl $0x8, %edi
callq 0xc842f
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc8315
movq %rax, %rbx
movl $0x20, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $0x3cc9acead7f9ac2e, %rax # imm = 0x3CC9ACEAD7F9AC2E
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbf60c
movq 0x8(%rbx), %rsi
movl $0x8, %edi
movq %r14, %rcx
callq 0xc833e
jmp 0xbf61e
movl $0x8, %edi
xorl %esi, %esi
movq %r14, %rdx
movq %r8, %rcx
callq 0xc8339
movq %rax, 0x8(%rbx)
cmpq %r14, 0x10(%rbx)
jbe 0xbf62c
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbf5e2
testq %r14, %r14
je 0xbf661
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq %r15, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xbf651
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbf5e2
movq 0x10(%rbx), %rax
cmpq %r14, %rax
jae 0xbf69a
movq 0x8(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xbf686
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbf5e2
testq %rbx, %rbx
je 0xbf6df
xorl %eax, %eax
movq 0x8(%r14), %rcx
movq %r12, (%rcx,%rax,8)
addq %r15, %r12
incq %rax
cmpq %rax, %rbx
jne 0xbf6cc
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_O1/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 0xbf736
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
movq 0x8(%rdi), %r14
movl $0x8, %edi
xorl %esi, %esi
callq 0xc8339
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 0xc842f
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
cmpq 0x18(%rdi), %rax
jbe 0xbf753
movq %r14, %rdi
callq 0xbf6f2
movq 0x18(%r14), %rdx
cmpq %rdx, 0x10(%r14)
jne 0xbf783
leaq 0x18(%r14), %r8
movq 0x8(%r14), %rsi
leaq (%rdx,%rdx), %rax
testq %rdx, %rdx
movl $0x1, %ecx
cmovneq %rax, %rcx
movl $0x8, %edi
callq 0xc833e
movq %rax, 0x8(%r14)
movq 0x8(%r14), %rax
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_O1/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 0xbf737
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
testq %rcx, %rcx
jle 0xbf7d4
movq 0x8(%rbx), %rcx
movq -0x10(%rcx,%rax,8), %rdx
movq %rdx, -0x8(%rcx,%rax,8)
decq %rax
cmpq $0x1, %rax
jg 0xbf7bd
movq 0x8(%rbx), %rax
movq %r14, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x10(%rsi)
je 0xbf869
movq %rsi, %r14
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jbe 0xbf809
movq %rbx, %rdi
callq 0xbf6f2
movq 0x10(%r14), %rcx
addq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
cmpq %rdx, %rcx
jb 0xbf83b
leaq 0x18(%rbx), %r8
leaq (%rdx,%rdx), %rax
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq 0x8(%rbx), %rsi
movl $0x8, %edi
callq 0xc833e
movq %rax, 0x8(%rbx)
cmpq $0x0, 0x10(%r14)
je 0xbf869
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 0xbf844
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbf8f9
testq %rcx, %rcx
je 0xbf902
cmpq %rcx, %rdx
movq %rcx, %rax
cmovbq %rdx, %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %r8
movq (%rdi), %r9
movq (%r8), %r10
movb $0x1, %sil
cmpq %r10, %r9
jne 0xbf8e8
leaq -0x1(%rax), %r11
xorl %esi, %esi
cmpq %rsi, %r11
je 0xbf908
movq 0x8(%rdi,%rsi,8), %r9
movq 0x8(%r8,%rsi,8), %r10
incq %rsi
cmpq %r10, %r9
je 0xbf8ca
cmpq %rax, %rsi
setb %sil
xorl %eax, %eax
cmpq %r10, %r9
setb %al
leal -0x2(,%rax,4), %eax
jmp 0xbf90a
xorl %eax, %eax
testq %rcx, %rcx
setne %al
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %esi, %esi
testb %sil, %sil
je 0xbf910
retq
xorl %esi, %esi
cmpq %rcx, %rdx
movl $0x0, %eax
adcl $-0x1, %eax
orl $0x1, %eax
cmpq %rcx, %rdx
cmovel %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
jae 0xbf942
movq %rbx, %rdi
callq 0xbf6f2
movq 0x10(%rbx), %rdx
shrq %rdx
movl $0x8, %edi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xc8339
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0xbf97c
movq %r14, %rdi
callq 0xc8307
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbfa32
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 0xbf97c
leaq (%r15,%r12,8), %rdi
movq %r14, %rsi
subq %r12, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xbf97c
movl $0x8, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xc842f
xorl %eax, %eax
movq %r15, %rcx
movq %r12, %rdx
testl %ebp, %ebp
jle 0xbfa03
cmpq %r14, %rdx
je 0xbf9ee
movq (%r15,%rdx,8), %rsi
cmpq %rsi, (%rbx,%rax,8)
jbe 0xbf9ee
incq %rdx
jmp 0xbf9f5
movq (%rbx,%rax,8), %rsi
incq %rax
movq %rsi, (%rcx)
addq $0x8, %rcx
cmpq %r12, %rax
jb 0xbf9da
jmp 0xbfa2a
cmpq %r14, %rdx
je 0xbfa17
movq (%r15,%rdx,8), %rsi
cmpq %rsi, (%rbx,%rax,8)
jae 0xbfa17
incq %rdx
jmp 0xbfa1e
movq (%rbx,%rax,8), %rsi
incq %rax
movq %rsi, (%rcx)
addq $0x8, %rcx
cmpq %r12, %rax
jb 0xbfa03
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbfa53
movq %rbx, %rdi
callq 0xbf6f2
leaq 0x18(%rbx), %r15
movq %rsp, %rcx
movq $0x0, (%rcx)
movq 0x10(%r14), %rdx
movl $0x8, %edi
xorl %esi, %esi
callq 0xc8339
movq %rax, %r12
cmpq $0x0, 0x10(%r14)
je 0xbfa9a
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 0xbfa7d
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl $0x8, %edi
xorl %ecx, %ecx
movq %r15, %r8
callq 0xc833e
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_O1/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 0xc8315
movq %rax, %r15
movl $0x20, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $0x3cc9acead7f9ac2e, %rax # imm = 0x3CC9ACEAD7F9AC2E
movq %rax, (%r15)
testq %rbx, %rbx
je 0xbfb73
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbf5e2
xorl %eax, %eax
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0xbfb22
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 0xbfb3c
movq %r15, %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_arr.c
// Function: bcore_arr_uz_s_find
uz_t bcore_arr_uz_s_find( const bcore_arr_uz_s* o, uz_t start, uz_t end, uz_t v )
{
    if( end >= start )
    {
        uz_t end_l = end < o->size ? end : o->size;
        for( uz_t j = start; j < end_l; j++ ) if( o->data[ j ] == v ) return j;
        return end_l;
    }
    else
    {
        uz_t start_l = start < o->size ? start : o->size;
        for( uz_t j = start_l - 1;  j < start_l && j >= end; j-- ) if( o->data[ j ] == v ) return j;
        return start_l;
    }
}

// Assembly:
cmpq %rsi, %rdx
jae 0xbfbb0
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
cmovbq %rax, %rsi
movq %rsi, %rax
decq %rax
cmpq %rsi, %rax
jae 0xbfbe0
cmpq %rdx, %rax
jb 0xbfbe0
movq 0x8(%rdi), %r8
cmpq %rcx, (%r8,%rax,8)
jne 0xbfb98
retq
movq 0x10(%rdi), %rax
cmpq %rdx, %rax
cmovbq %rax, %rdx
cmpq %rsi, %rdx
jbe 0xbfbd5
movq 0x8(%rdi), %rax
cmpq %rcx, (%rax,%rsi,8)
je 0xbfbd5
incq %rsi
cmpq %rsi, %rdx
jne 0xbfbc4
movq %rdx, %rsi
cmpq %rdx, %rsi
cmovbq %rsi, %rdx
movq %rdx, %rax
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_max
uz_t bcore_arr_uz_s_max( const bcore_arr_uz_s* o )
{
    if( o->size == 0 ) return 0;
    uz_t max = o->data[ 0 ];
    for( uz_t i = 1; i < o->size; i++ ) max = o->data[ i ] > max ? o->data[ i ] : max;
    return max;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xbfc13
movq 0x8(%rdi), %rdx
movq (%rdx), %rax
cmpq $0x1, %rcx
je 0xbfc12
movl $0x1, %esi
movq (%rdx,%rsi,8), %rdi
cmpq %rax, %rdi
cmovaq %rdi, %rax
incq %rsi
cmpq %rsi, %rcx
jne 0xbfbff
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_min
uz_t bcore_arr_uz_s_min( const bcore_arr_uz_s* o )
{
    if( o->size == 0 ) return 0;
    uz_t min = o->data[ 0 ];
    for( uz_t i = 1; i < o->size; i++ ) min = o->data[ i ] < min ? o->data[ i ] : min;
    return min;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xbfc45
movq 0x8(%rdi), %rdx
movq (%rdx), %rax
cmpq $0x1, %rcx
je 0xbfc44
movl $0x1, %esi
movq (%rdx,%rsi,8), %rdi
cmpq %rax, %rdi
cmovbq %rdi, %rax
incq %rsi
cmpq %rsi, %rcx
jne 0xbfc31
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_idx_max
uz_t bcore_arr_uz_s_idx_max( const bcore_arr_uz_s* o )
{
    if( o->size == 0 ) return 0;
    uz_t max = o->data[ 0 ];
    uz_t idx = 0;
    for( uz_t i = 1; i < o->size; i++ )
    {
        if( o->data[ i ] > max )
        {
            max = o->data[ i ];
            idx = i;
        }
    }
    return idx;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xbfc57
cmpq $0x1, %rcx
jne 0xbfc5a
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdx
movq (%rdx), %rsi
movl $0x1, %edi
xorl %eax, %eax
movq (%rdx,%rdi,8), %r8
cmpq %rsi, %r8
cmovaq %r8, %rsi
cmovaq %rdi, %rax
incq %rdi
cmpq %rdi, %rcx
jne 0xbfc68
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_uz_s_idx_min
uz_t bcore_arr_uz_s_idx_min( const bcore_arr_uz_s* o )
{
    if( o->size == 0 ) return 0;
    uz_t min = o->data[ 0 ];
    uz_t idx = 0;
    for( uz_t i = 1; i < o->size; i++ )
    {
        if( o->data[ i ] < min )
        {
            min = o->data[ i ];
            idx = i;
        }
    }
    return idx;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xbfc8f
cmpq $0x1, %rcx
jne 0xbfc92
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdx
movq (%rdx), %rsi
movl $0x1, %edi
xorl %eax, %eax
movq (%rdx,%rdi,8), %r8
cmpq %rsi, %r8
cmovbq %r8, %rsi
cmovbq %rdi, %rax
incq %rdi
cmpq %rdi, %rcx
jne 0xbfca0
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_arr.c
// Function: bcore_arr_sz_s_copy
void bcore_arr_sz_s_copy( bcore_arr_sz_s* o, const bcore_arr_sz_s* src )
{
    if( o->space < src->size )
    {
        if( o->space > 0 ) o->data = bcore_un_alloc( sizeof( sz_t ), o->data, o->space, 0, &o->space );
        o->data = bcore_un_alloc( sizeof( sz_t ), NULL, o->space, src->size, &o->space );
    }
    bcore_u_memcpy( sizeof( sz_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
cmpq 0x10(%rsi), %rdx
jae 0xbfd6d
leaq 0x18(%rbx), %r15
testq %rdx, %rdx
je 0xbfd52
movq 0x8(%rbx), %rsi
movl $0x8, %edi
xorl %ecx, %ecx
movq %r15, %r8
callq 0xc833e
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rdx
movq 0x10(%r14), %rcx
movl $0x8, %edi
xorl %esi, %esi
movq %r15, %r8
callq 0xc833e
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movl $0x8, %edi
callq 0xc842f
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq