LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_shell_op_parse_match
bl_t bcore_shell_op_parse_match( bcore_shell_op* o, x_source* source )
{
    // bcore_shell.h:112:5
    BLM_INIT_LEVEL(0);
    st_s key;BLM_T_INIT_SPUSH(st_s, &key);;
    BLM_TRY_EXIT(x_source_parse_fa(source,"#=name", (&(key)) ))
    if( key.size == 0 ) BLM_RETURNV(bl_t, false)
    if( !bcore_shell_op_key_match(o,key.sc ) ) BLM_RETURNV(bl_t, false)
    BLM_TRY_EXIT(x_source_parse_fa(source,"#-name" ))
    BLM_RETURNV(bl_t, true)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x13fac7(%rip), %rax    # 0x1a8dd0
movq (%rax), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xe0431
movq $0x0, 0x10(%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x113f7c
movabsq $-0x503db0e6e1c2e704, %rsi # imm = 0xAFC24F191E3D18FC
movq %r15, %rdi
movq %r12, %rdx
callq 0xe06ab
leaq 0xd94ae(%rip), %rsi     # 0x1427f8
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x5cde9
testq %rax, %rax
je 0x69371
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0xe0b30
movl %r15d, %edi
callq 0x59990
cmpq $0x0, 0x18(%rsp)
je 0x693b9
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6ab88
testb %al, %al
je 0x693b9
leaq 0xd946e(%rip), %rsi     # 0x1427ff
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5cde9
movb $0x1, %bl
testq %rax, %rax
je 0x693bb
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xe0b30
movl %r14d, %edi
callq 0x59990
jmp 0x693bb
xorl %ebx, %ebx
leaq 0x28(%rsp), %rdi
callq 0xe0b30
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_shell_op_default_get_s_run
BCORE_DEFINE_OBJECT_INST_P_NASC_END( bcore_shell_op_default_get_s )

void bcore_shell_op_default_get_s_run( bcore_shell_op_default_get_s* o, bcore_shell* obj, const bcore_main_frame_s* main_frame, x_source* source, bcore_sink* sink, bcore_shell_control_s* control )
{
    // bcore_shell.h:580:9
    BLM_INIT_LEVEL(0);
    sr_s sr = x_stamp_path_s_get_sr_in(x_stamp_path_s_parse(((x_stamp_path_s*)BLM_LEVEL_T_PUSH(0,x_stamp_path_s,x_stamp_path_s_create())),((x_source*)BLM_LEVEL_A_PUSH(0,x_source_create_from_st(&(o->path )))) ),((const x_inst*)(obj )));
    if( sr.o )
    {
        x_btml_t_to_sink(((const x_btml*)( sr.o)),sr_s_type(&( sr )),((x_sink*)( sink )));
    }
    else
    {
        bcore_sink_a_push_fa(sink,"Path '#<sc_t>' not found.\n", o->path.sc );
    }
    BLM_DOWN();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x13b530(%rip), %rax    # 0x1a8dd0
movq (%rax), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xe0431
movq (%rsp), %r12
movq $0x0, 0x10(%r12)
callq 0x5c50a
movabsq $-0x74dceedd59a2bd6f, %rdx # imm = 0x8B231122A65D4291
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0xe0676
movq %rax, %r13
leaq 0x8(%r14), %rdi
callq 0xee7cd
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0xe0900
movq %r13, %rdi
movq %rax, %rsi
callq 0x5c826
movq (%r15), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x5cf36
movq (%r12), %rdi
testq %rdi, %rdi
je 0x6d92d
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x6d944
movq 0x8(%rax), %rsi
jmp 0x6d946
movq 0x10(%r14), %rdx
leaq 0xd5046(%rip), %rsi     # 0x14297e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x109273
jmp 0x6d958
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x767fb
movq %rsp, %rdi
callq 0xe0b11
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_shell_op_default_alias_s_copy
BCORE_DEFINE_OBJECT_INST_P_NASC_END( bcore_shell_op_default_alias_s )

void bcore_shell_op_default_alias_s_run( bcore_shell_op_default_alias_s* o, bcore_shell* obj, const bcore_main_frame_s* main_frame, x_source* source, bcore_sink* sink, bcore_shell_control_s* control )
{
    // bcore_shell.h:635:9
    
    if( o->key.size == 0 )
    {
        bcore_sink_a_push_fa(sink,"No key defined.\n" );
        return ;
    }
    tp_t tp_key = bcore_hmap_name_s_set_st_c(&(control->hmap_name),&(o->key ));
    if( o->expression.size > 0 )
    {
        x_hmap_tp_set_c(((x_hmap_tp*)(&(control->hmap_alias))),tp_key,((const x_inst*)(&( o->expression ))));
    }
    else
    {
        x_hmap_tp_remove(((x_hmap_tp*)(&(control->hmap_alias))),tp_key );
    }
}

// Assembly:
cmpq %rsi, %rdi
je 0x6e423
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x69a57bffeeef3dcc, %r15 # imm = 0x69A57BFFEEEF3DCC
leaq 0x13b0e9(%rip), %rax    # 0x1a9468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x6e3d5
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x6e3d5
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x6e3d5
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x6e424
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x6e405
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x13b06e(%rip), %rdi    # 0x1a9468
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
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
xorl %r12d, %r12d
jmp 0x6e3d9
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_codec_s_copy
BCORE_DEFINE_OBJECT_INST_P_NASC_END( bcore_huffman_codec_s )

bcore_huffman_codec_s* bcore_huffman_codec_s_clear( bcore_huffman_codec_s* o )
{
    // bcore_huffman.x:47:1
    
    bcore_huffman_hist_s_attach( &(o->hist ),  NULL);
    bcore_huffman_tree_s_attach( &(o->tree ),  NULL);
    bcore_huffman_count_map_s_attach( &(o->count_map ),  NULL);
    bcore_huffman_index_s_attach( &(o->leaf_index ),  NULL);
    return  o;
}

// Assembly:
cmpq %rsi, %rdi
je 0x6f260
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x7dbd1c5e923a8433, %r15 # imm = 0x7DBD1C5E923A8433
leaq 0x13a2ac(%rip), %rax    # 0x1a9468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x6f212
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x6f212
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x6f212
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x6f261
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x6f242
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x13a231(%rip), %rdi    # 0x1a9468
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
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
xorl %r12d, %r12d
jmp 0x6f216
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_codec_s_scan_start
bcore_huffman_codec_s* bcore_huffman_codec_s_scan_start( bcore_huffman_codec_s* o )
{
    // bcore_huffman.x:58:1
    
    bcore_huffman_codec_s_clear(o);
    bcore_huffman_hist_s_clear(BCORE_PASS_CREATE(bcore_huffman_hist_s,o->hist));
    return  o;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x6f49b
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x6f502
callq 0x71d8e
movq %rax, %rdi
movq %rax, 0x8(%rbx)
addq $0x8, %rdi
callq 0xd2d69
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_codec_s_scan_u2
bcore_huffman_codec_s* bcore_huffman_codec_s_scan_u2( bcore_huffman_codec_s* o, u2_t val )
{
    // bcore_huffman.x:67:1
    
    if( !o->hist ) ERR_fa( "Enclose scanning with 'scan_start()' ... 'scan_end()'." );
    bcore_huffman_hist_s_count(o->hist,val );
    return  o;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x6f540
leaq 0xd34e9(%rip), %rdi     # 0x142a0f
leaq 0xd2f89(%rip), %rsi     # 0x1424b6
leaq 0xd34f9(%rip), %rcx     # 0x142a2d
movl $0xa18, %edx            # imm = 0xA18
xorl %eax, %eax
callq 0xc825d
movq 0x8(%rbx), %rdi
addq $0x8, %rdi
movl %ebp, %esi
incq %rsi
xorl %edx, %edx
callq 0xd2b7c
incq (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_codec_s_scan_end
bcore_huffman_codec_s* bcore_huffman_codec_s_scan_end( bcore_huffman_codec_s* o )
{
    // bcore_huffman.x:88:1
    
    if( !o->hist ) ERR_fa( "No histogram. scan_end() called before scan_start()?." );
    bcore_huffman_count_map_s_attach( &(o->count_map ),  ((bcore_huffman_count_map_s*)(x_array_sort(((x_array*)(bcore_huffman_count_map_s_from_hist(bcore_huffman_count_map_s_create(),o->hist ))),1 ))));
    bcore_huffman_hist_s_attach( &(o->hist ),  NULL);
    bcore_huffman_tree_s_build(BCORE_PASS_CREATE(bcore_huffman_tree_s,o->tree),o->count_map, BCORE_PASS_CREATE(bcore_huffman_index_s,o->leaf_index) );
    return  o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x6f5b8
leaq 0xd34c6(%rip), %rdi     # 0x142a64
leaq 0xd2f11(%rip), %rsi     # 0x1424b6
leaq 0xd34d7(%rip), %rcx     # 0x142a83
movl $0xa28, %edx            # imm = 0xA28
xorl %eax, %eax
callq 0xc825d
callq 0x72f6a
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x6f7ae
movq (%r14), %r15
leaq 0x13984a(%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 0x6f630
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x6f630
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x6f630
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x6f6e0
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x6f660
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x1397cb(%rip), %rdi    # 0x1a8e20
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq $-0x1, %rcx
movl $0x1, %r8d
callq 0xf914f
movq 0x10(%rbx), %rdi
callq 0x73019
movq %r14, 0x10(%rbx)
movq 0x8(%rbx), %rdi
callq 0x71e3d
movq $0x0, 0x8(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
jne 0x6f6ad
callq 0x73486
movq %rax, %r14
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %r15
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
jne 0x6f6c6
callq 0x72205
movq %rax, %rdx
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f8c8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x6f634
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_count_map_s_from_hist
BCORE_DEFINE_OBJECT_INST_P_NASC_END( bcore_huffman_count_map_s )

bcore_huffman_count_map_s* bcore_huffman_count_map_s_from_hist( bcore_huffman_count_map_s* o, const bcore_huffman_hist_s* hist )
{
    // bcore_huffman.x:426:5
    
    x_array_clear(((x_array*)(o)));
    for(sz_t i = 0; i < hist->hmap_tpuz.size; i++ )
    {
        tp_t key = bcore_hmap_tpuz_s_idx_key(&(hist->hmap_tpuz),i );
        if( key > 0 )
        {
            bcore_huffman_count_node_s* node = ((bcore_huffman_count_node_s*)(x_array_push(((x_array*)(o)))));
            node->c = bcore_hmap_tpuz_s_idx_val(&(hist->hmap_tpuz),i );
            node->v = bcore_huffman_hist_s_val(hist,key );
        }
    }
    return  o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x139657(%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 0x6f823
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x6f823
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x6f823
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x6f8c0
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x6f853
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x1395d8(%rip), %rdi    # 0x1a8e20
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf6359
cmpq $0x0, 0x20(%r14)
je 0x6f8ae
leaq 0x8(%r14), %r15
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0xd2dbe
testq %rax, %rax
je 0x6f8a5
movq %rax, %r13
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x5b7f0
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0xd2dcb
movq %rax, (%rbp)
decl %r13d
movl %r13d, 0x8(%rbp)
incq %r12
cmpq 0x20(%r14), %r12
jb 0x6f86e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x6f827
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_codec_s_encode_u2
const bcore_huffman_codec_s* bcore_huffman_codec_s_encode_u2( const bcore_huffman_codec_s* o, u2_t val, bcore_huffman_bit_buffer_s* bit_buffer )
{
    // bcore_huffman.x:99:1
    
    if( !o->tree ) ERR_fa( "No tree! Load a codec or run scanning first." );
    sz_t idx = bcore_huffman_index_s_get(o->leaf_index,val );
    if( idx == 0 ) ERR_fa( "An encoding for value #<u2_t> does not exist.", val );
    
    const bcore_huffman_node_s* node =&( o->tree->data[ idx ]);
    
    u3_t stack = 0;
    sz_t bits = 0;
    
    while( node->p )
    {
        bl_t bit = ( o->tree->data[ node->p ].b1 == idx );
        idx = node->p;
        node = (&(o->tree->data[ idx ]));
    
        stack = ( stack << 1 ) | ( ( bit ) ? 1 : 0 );
        bits++;
    }
    
    if( bits > 64 )  ERR_fa( "Encoding of value #<u2_t> consumes more than 64 bits.", val );
    
    for(sz_t i = 0; i < bits; i++ )
    {
        bcore_huffman_bit_buffer_s_push_bl(bit_buffer,( stack & 1 ) );
        stack = stack >> 1;
    }
    
    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
cmpq $0x0, 0x18(%rdi)
jne 0x6fb38
leaq 0xd2f9b(%rip), %rdi     # 0x142ab9
leaq 0xd2991(%rip), %rsi     # 0x1424b6
leaq 0xd2fad(%rip), %rcx     # 0x142ad9
movl $0xa33, %edx            # imm = 0xA33
xorl %eax, %eax
callq 0xc825d
movq 0x20(%r14), %rdi
addq $0x8, %rdi
movl %ebp, %esi
incq %rsi
callq 0xd2a60
testq %rax, %rax
je 0x6fb54
movq (%rax), %r13
jmp 0x6fb57
xorl %r13d, %r13d
testq %r13, %r13
jne 0x6fb80
leaq 0xd2f56(%rip), %rdi     # 0x142ab9
leaq 0xd294c(%rip), %rsi     # 0x1424b6
leaq 0xd2f95(%rip), %rcx     # 0x142b06
movl $0xa35, %edx            # imm = 0xA35
movl %ebp, %r8d
xorl %eax, %eax
callq 0xc825d
movq 0x18(%r14), %rax
movq 0x8(%rax), %rax
leaq (,%r13,4), %rcx
addq %r13, %rcx
movq 0x8(%rax,%rcx,8), %rcx
testq %rcx, %rcx
je 0x6fbc8
xorl %r15d, %r15d
xorl %r12d, %r12d
leaq (%rcx,%rcx,4), %rdx
xorl %esi, %esi
cmpq %r13, 0x18(%rax,%rdx,8)
movq %rcx, %r13
movq 0x8(%rax,%rdx,8), %rcx
sete %sil
leaq (%rsi,%r12,2), %r12
incq %r15
testq %rcx, %rcx
jne 0x6fba3
jmp 0x6fbce
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq $0x41, %r15
jb 0x6fbf8
leaq 0xd2ede(%rip), %rdi     # 0x142ab9
leaq 0xd28d4(%rip), %rsi     # 0x1424b6
leaq 0xd2f4b(%rip), %rcx     # 0x142b34
movl $0xa46, %edx            # imm = 0xA46
movl %ebp, %r8d
xorl %eax, %eax
callq 0xc825d
testq %r15, %r15
je 0x6fc13
movl %r12d, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x6fc25
shrq %r12
decq %r15
jne 0x6fbfd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_s_push_bl
bcore_huffman_bit_buffer_s* bcore_huffman_bit_buffer_s_push_bl( bcore_huffman_bit_buffer_s* o, bl_t bit )
{
    // bcore_huffman.x:209:1
    
    if( o->bits == o->size * 8 ) (*(((u0_t*)(x_array_push(((x_array*)(o))))))) = 0;
    sz_t idx = o->bits / 8;
    if( bit )
    {
        u0_t m = 1 << ( o->bits - ( idx * 8 ) );
        o->data[ idx ] |= m;
    }
    o->bits++;
    return  o;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
shlq $0x3, %rax
cmpq %rax, 0x8(%rdi)
jne 0x6fc49
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x5b7f0
movb $0x0, (%rax)
testb %bpl, %bpl
je 0x6fc6a
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
movq %rcx, %rdx
andb $0x7, %cl
movb $0x1, %sil
shlb %cl, %sil
shrq $0x3, %rdx
orb %sil, (%rax,%rdx)
incq 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_codec_s_decode_u2
u2_t bcore_huffman_codec_s_decode_u2( const bcore_huffman_codec_s* o, bcore_huffman_bit_buffer_iterator_s* iterator )
{
    // bcore_huffman.x:133:1
    
    if( !o->tree ) ERR_fa( "No tree! Load a codec or run scanning first." );
    const bcore_huffman_node_s* node =&( o->tree->data[ bcore_huffman_tree_s_root_index(o->tree) ]);
    
    while( !bcore_huffman_bit_buffer_iterator_s_eos(iterator) && !bcore_huffman_node_s_is_leaf(node) )
    {
        bl_t bit = bcore_huffman_bit_buffer_iterator_s_read_bl(iterator);
        uz_t idx = ( bit ) ? node->b1 : node->b0;
        node = (&(o->tree->data[ idx ]));
    }
    
    if( !bcore_huffman_node_s_is_leaf(node) )
    {
        ERR_fa( "Decoding error. Bit buffer appears corrupted." );
    }
    
    return  node->v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
jne 0x6fcab
leaq 0xd2ed9(%rip), %rdi     # 0x142b6a
leaq 0xd281e(%rip), %rsi     # 0x1424b6
leaq 0xd2e3a(%rip), %rcx     # 0x142ad9
movl $0xa55, %edx            # imm = 0xA55
xorl %eax, %eax
callq 0xc825d
movq 0x18(%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %r15
addq $-0x28, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq 0x8(%rax), %rcx
jae 0x6fcfa
cmpq $0x0, 0x10(%r15)
je 0x6fcfa
movq %rbx, %rdi
callq 0x6fd2c
movzbl %al, %eax
movq 0x10(%r15,%rax,8), %rax
movq 0x18(%r14), %rcx
leaq (%rax,%rax,4), %r15
shlq $0x3, %r15
addq 0x8(%rcx), %r15
jmp 0x6fcc3
cmpq $0x0, 0x10(%r15)
je 0x6fd22
leaq 0xd2e62(%rip), %rdi     # 0x142b6a
leaq 0xd27a7(%rip), %rsi     # 0x1424b6
leaq 0xd2e74(%rip), %rcx     # 0x142b8a
movl $0xa61, %edx            # imm = 0xA61
xorl %eax, %eax
callq 0xc825d
movl 0x20(%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_iterator_s_copy
BCORE_DEFINE_OBJECT_INST_P_NASC_END( bcore_huffman_bit_buffer_iterator_s )

bl_t bcore_huffman_bit_buffer_iterator_s_read_bl( bcore_huffman_bit_buffer_iterator_s* o )
{
    // bcore_huffman.x:317:1
    
    if( !o->bit_buffer ) ERR_fa( "No buffer assigned. Call setup first." );
    if( o->bit_index >= o->bit_buffer->bits ) ERR_fa( "Reading past end of buffer" );
    sz_t idx = o->bit_index / 8;
    u0_t m = 1 << ( o->bit_index - ( idx * 8 ) );
    o->bit_index++;
    return  ( o->bit_buffer->data[ idx ] & m ) ? true : false;
}

// Assembly:
cmpq %rsi, %rdi
je 0x7170a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x93943e0ef30024c, %r15 # imm = 0x93943E0EF30024C
leaq 0x137e02(%rip), %rax    # 0x1a9468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x716bc
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x716bc
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x716bc
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x7170b
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x716ec
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x137d87(%rip), %rdi    # 0x1a9468
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
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
xorl %r12d, %r12d
jmp 0x716c0
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_codec_s_decode
bcore_huffman_codec_s* bcore_huffman_codec_s_decode( bcore_huffman_codec_s* o, bcore_huffman_bit_buffer_iterator_s* iterator )
{
    // bcore_huffman.x:185:1
    
    bcore_huffman_codec_s_clear(o);
    bcore_huffman_count_map_s_decode(BCORE_PASS_CREATE(bcore_huffman_count_map_s,o->count_map),iterator );
    bcore_huffman_tree_s_build(BCORE_PASS_CREATE(bcore_huffman_tree_s,o->tree),o->count_map, BCORE_PASS_CREATE(bcore_huffman_index_s,o->leaf_index) );
    return  o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6f49b
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0x700d2
callq 0x72f6a
movq %rax, %rdi
movq %rax, 0x10(%rbx)
movq %r14, %rsi
callq 0x7011c
movq 0x18(%rbx), %r14
testq %r14, %r14
jne 0x700ef
callq 0x73486
movq %rax, %r14
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %r15
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
jne 0x70108
callq 0x72205
movq %rax, %rdx
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f8c8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_s_clear
BCORE_DEFINE_OBJECT_INST_P_NASC_END( bcore_huffman_bit_buffer_s )

bcore_huffman_bit_buffer_s* bcore_huffman_bit_buffer_s_clear( bcore_huffman_bit_buffer_s* o )
{
    // bcore_huffman.x:200:1
    
    x_array_clear(((x_array*)(o)));
    o->bits = 0;
    return  o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x13852d(%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 0x70949
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r14, %rdx
je 0x70949
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r14, %rdx
je 0x70949
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r14, %rdx
jne 0x70997
movq (%rax,%rcx), %r15
testq %r15, %r15
jne 0x70979
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %r14, %rsi
callq 0xf3f85
movq %rax, %r15
leaq 0x1384b2(%rip), %rdi    # 0x1a8e20
movq %r14, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf6359
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x7094d
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_s_push_f3
bcore_huffman_bit_buffer_s* bcore_huffman_bit_buffer_s_push_f3( bcore_huffman_bit_buffer_s* o, f3_t v, sz_t bits )
{
    // bcore_huffman.x:256:1
    
    ASSERT( bits <= 31 );
    int int_exp = 0;
    s3_t man = llrint( frexp( v, (&(int_exp)) ) * ( ( 1 << bits ) - 1 ) );
    s3_t exp = ((s3_t)(int_exp));
    bcore_huffman_bit_buffer_s_push_s3(o,man, bits );
    bcore_huffman_bit_buffer_s_push_packed_s3(o,exp );
    return  o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x20, %rsi
jl 0x70b59
leaq 0xc7b1a(%rip), %rdi     # 0x138647
leaq 0xd2084(%rip), %rsi     # 0x142bb8
leaq 0xd2088(%rip), %rdx     # 0x142bc3
leaq 0xd1974(%rip), %rcx     # 0x1424b6
movl $0xad1, %r8d            # imm = 0xAD1
xorl %eax, %eax
movsd %xmm0, (%rsp)
callq 0xc8053
movsd (%rsp), %xmm0
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
movq %r12, %rdi
callq 0xd070
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %r14d, %ecx
shll %cl, %eax
notl %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
callq 0xd320
movl (%r12), %ebp
testq %r14, %r14
jle 0x70bb0
movq %rax, %r15
xorl %r12d, %r12d
xorl %esi, %esi
btq %r12, %r15
setb %sil
movq %rbx, %rdi
callq 0x6fc25
incq %r12
cmpq %r12, %r14
jne 0x70b96
movl %ebp, %esi
notl %esi
shrl $0x1f, %esi
movq %rbx, %rdi
callq 0x6fc25
movl %ebp, %esi
negl %esi
cmovsl %ebp, %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x709e6
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_s_push_bit_buffer
bcore_huffman_bit_buffer_s* bcore_huffman_bit_buffer_s_push_bit_buffer( bcore_huffman_bit_buffer_s* o, const bcore_huffman_bit_buffer_s* src )
{
    // bcore_huffman.x:269:1
    
    u3_t bits = src->bits;
    for(sz_t i = 0; ( i < src->size ) && ( bits > 0 ); i++ )
    {
        bcore_huffman_bit_buffer_s_push_u3(o,src->data[ i ], u3_min( 8, bits ) );
        bits -= u3_min( 8, bits );
    }
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpq $0x0, 0x18(%rsi)
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x70c57
xorl %r13d, %r13d
movq %rsi, (%rsp)
movq 0x10(%rsi), %rax
movzbl (%rax,%r13), %r14d
cmpq $0x8, %r12
movl $0x8, %ebp
cmovbq %r12, %rbp
xorl %r15d, %r15d
movl $0x1, %eax
movl %r15d, %ecx
shlq %cl, %rax
xorl %esi, %esi
testl %r14d, %eax
setne %sil
movq %rbx, %rdi
callq 0x6fc25
incq %r15
cmpq %r15, %rbp
jne 0x70c21
incq %r13
movq (%rsp), %rsi
cmpq 0x18(%rsi), %r13
jae 0x70c57
subq %rbp, %r12
jne 0x70c08
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_s_get_hash
tp_t bcore_huffman_bit_buffer_s_get_hash( const bcore_huffman_bit_buffer_s* o )
{
    // bcore_huffman.x:281:1
    
    tp_t hash = bcore_tp_init();
    hash = bcore_tp_fold_u3( hash, o->bits );
    {const bcore_huffman_bit_buffer_s* __a=o ;if(__a)for(sz_t __i=0;__i<__a->size;__i++){u0_t e=__a->data[__i]; hash = bcore_tp_fold_u0( hash, e );}}
    return  hash;
}

// Assembly:
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
movq 0x8(%rdi), %rdx
movl $0xff, %eax
movq %rdx, %rsi
andq %rax, %rsi
movabsq $-0x340d631b7bdddcdb, %r8 # imm = 0xCBF29CE484222325
xorq %rsi, %r8
imulq %rcx, %r8
movl %edx, %esi
shrl $0x8, %esi
movl $0xff, %r9d
andl %r9d, %esi
xorq %r8, %rsi
imulq %rcx, %rsi
movl %edx, %r8d
shrl $0x10, %r8d
andl %r9d, %r8d
xorq %rsi, %r8
imulq %rcx, %r8
movl %edx, %esi
shrl $0x18, %esi
xorq %r8, %rsi
imulq %rcx, %rsi
movq %rdx, %r8
shrq $0x20, %r8
andq %rax, %r8
xorq %rsi, %r8
imulq %rcx, %r8
movq %rdx, %rsi
shrq $0x28, %rsi
andq %rax, %rsi
xorq %r8, %rsi
imulq %rcx, %rsi
movq %rdx, %r8
shrq $0x30, %r8
andq %rax, %r8
xorq %rsi, %r8
imulq %rcx, %r8
shrq $0x38, %rdx
xorq %r8, %rdx
imulq %rcx, %rdx
testq %rdi, %rdi
je 0x70d30
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x70d30
movq 0x10(%rdi), %rdi
xorl %r8d, %r8d
movzbl (%rdi,%r8), %eax
xorq %rdx, %rax
imulq %rcx, %rax
incq %r8
movq %rax, %rdx
cmpq %r8, %rsi
jne 0x70d18
retq
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_s_bcml_body_to_sink
void bcore_huffman_bit_buffer_s_bcml_body_to_sink( const bcore_huffman_bit_buffer_s* o, x_sink* sink )
{
    // bcore_huffman.x:291:1
    
    u3_t bits = o->bits;
    x_sink_push_u3(sink,bits );
    sz_t size = ( bits / 8 ) + ( ( bits % 8 ) ? 1 : 0 );
    x_sink_push_data(sink,((const x_inst*)(o->data)), size * sizeof( u0_t ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %r13
movq %r13, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq (%rsi), %r15
leaq 0x138d53(%rip), %rbp    # 0x1a9ab0
movl (%rbp), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%rbp,%rax,8), %rcx
movq 0x18(%rbp,%rax,8), %rdx
andq %r15, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x70db7
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x70db7
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x70db7
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x70ee8
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x70de7
movabsq $0x5ea8cabb93ff3b7e, %rdi # imm = 0x5EA8CABB93FF3B7E
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x138cd4(%rip), %rdi    # 0x1a9ab0
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
cmpq $0x0, 0x10(%r12)
jne 0x70dfe
leaq 0xd44c8(%rip), %rsi     # 0x1452be
movq %r12, %rdi
callq 0xf592c
leaq 0x10(%rsp), %rsi
movl $0x8, %ebx
movl $0x8, %edx
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x10(%r12)
movq 0x10(%r14), %r14
movq (%r15), %r15
movl (%rbp), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%rbp,%rax,8), %rcx
movq 0x18(%rbp,%rax,8), %rdx
andq %r15, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rcx
cmpq %r15, %rcx
je 0x70e72
movq 0x10(%rax), %rcx
movl $0x18, %ebx
cmpq %r15, %rcx
je 0x70e72
movq 0x20(%rax), %rcx
movl $0x28, %ebx
cmpq %r15, %rcx
je 0x70e72
movq 0x30(%rax), %rcx
movl $0x38, %ebx
cmpq %r15, %rcx
jne 0x70ef0
movq (%rax,%rbx), %r12
testq %r12, %r12
jne 0x70ea2
movabsq $0x5ea8cabb93ff3b7e, %rdi # imm = 0x5EA8CABB93FF3B7E
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x138c19(%rip), %rdi    # 0x1a9ab0
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
cmpq $0x0, 0x10(%r12)
jne 0x70eb9
leaq 0xd440d(%rip), %rsi     # 0x1452be
movq %r12, %rdi
callq 0xf592c
movq %r13, %rdx
shrq $0x3, %rdx
andl $0x7, %r13d
cmpq $0x1, %r13
sbbq $-0x1, %rdx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x10(%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x70dbb
xorl %r12d, %r12d
jmp 0x70e76
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_bit_buffer_iterator_s_read_s3
s3_t bcore_huffman_bit_buffer_iterator_s_read_s3( bcore_huffman_bit_buffer_iterator_s* o, sz_t bits )
{
    // bcore_huffman.x:345:1
    
    u3_t u3 = bcore_huffman_bit_buffer_iterator_s_read_u3(o,bits );
    if( bits > 0 )
    {
        if( ( bits > 0 ) && ( u3 >> ( bits - 1 ) ) ) u3 = ( 0xFFFFFFFFFFFFFFFFull << bits ) | u3;
    }
    return  u3;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rsi, %rsi
jle 0x71a3a
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x6fd2c
movzbl %al, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %rbx
incq %r12
cmpq %r12, %r14
jne 0x71a1c
jmp 0x71a3c
xorl %ebx, %ebx
testq %r14, %r14
jle 0x71a60
leal -0x1(%r14), %ecx
movq %rbx, %rax
shrq %cl, %rax
testq %rax, %rax
je 0x71a60
movq $-0x1, %rax
movl %r14d, %ecx
shlq %cl, %rax
orq %rax, %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.xo.c
// Function: bcore_huffman_bit_buffer_iterator_s_read_f3
f3_t bcore_huffman_bit_buffer_iterator_s_read_f3( bcore_huffman_bit_buffer_iterator_s* o, sz_t bits )
{
    // bcore_huffman.x:366:1
    
    ASSERT( bits <= 31 );
    s3_t man = bcore_huffman_bit_buffer_iterator_s_read_s3(o,bits );
    s3_t exp = bcore_huffman_bit_buffer_iterator_s_read_packed_s3(o);
    return  ( 1.0 / ( ( 1ull << bits ) - 1 ) ) * man * pow( 2.0, exp );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x20, %rsi
jl 0x71ad4
leaq 0xc6b95(%rip), %rdi     # 0x138647
leaq 0xd10ff(%rip), %rsi     # 0x142bb8
leaq 0xd1193(%rip), %rdx     # 0x142c53
leaq 0xd09ef(%rip), %rcx     # 0x1424b6
movl $0xb44, %r8d            # imm = 0xB44
xorl %eax, %eax
callq 0xc8053
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71a04
movq %rax, %r15
movq %r14, %rdi
callq 0x6fd2c
movl %eax, %ebp
movq %r14, %rdi
callq 0x7198e
movq %rax, %rdx
negq %rdx
testb %bpl, %bpl
cmovneq %rax, %rdx
movq $-0x1, %rax
movl %ebx, %ecx
shlq %cl, %rax
notq %rax
cvtsi2sd %rax, %xmm0
movsd 0xd07ab(%rip), %xmm1    # 0x1422c8
cvtsi2sd %r15, %xmm2
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rdx, %xmm0
callq 0xd2d0
mulsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_huffman_count_map_s_is_equal
bl_t bcore_huffman_count_map_s_is_equal( const bcore_huffman_count_map_s* o, const bcore_huffman_count_map_s* b )
{
    // bcore_huffman.x:448:5
    
    if( o->size != b->size ) return  false;
    for(sz_t i = 1; i < o->size; i++ ) if( !bcore_huffman_count_node_s_is_equal(&(o->data[ i ]),&(b->data[ i ] )) ) return  false;
    return  true;
}

// Assembly:
movq 0x10(%rdi), %rcx
cmpq 0x10(%rsi), %rcx
jne 0x7323f
cmpq $0x2, %rcx
setb %al
jb 0x73241
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
movq 0x10(%rdx), %rdi
cmpq 0x10(%rsi), %rdi
jne 0x73241
movl $0x20, %r8d
movl $0x2, %edi
movl -0x8(%rdx,%r8), %r9d
cmpl -0x8(%rsi,%r8), %r9d
jne 0x73241
cmpq %rcx, %rdi
setae %al
je 0x73241
movq (%rdx,%r8), %r9
leaq 0x10(%r8), %r10
incq %rdi
cmpq (%rsi,%r8), %r9
movq %r10, %r8
je 0x73215
jmp 0x73241
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: bcore_indexer_s_get_io
bl_t bcore_indexer_s_get_io( const bcore_indexer_s* o, s3_t index, bcore_indexer_io_s* io )
{
    // bcore_indexer.h:97:5
    
    if( index < 0 || index >= o->size ) return  false;
    (*(io)) = o->io_arr.data[ index >> o->mask_bits ];
    io->o += index & ( ( 1 << o->mask_bits ) - 1 );
    while( io->o >= o->cs_arr.data[ io->i ].s )
    {
        io->o -= o->cs_arr.data[ io->i ].s;
        io->i++;
    }
    return  true;
}

// Assembly:
testq %rsi, %rsi
js 0x75566
cmpq %rsi, 0x50(%rdi)
jle 0x75566
movq 0x10(%rdi), %rax
movb 0x48(%rdi), %cl
movq %rsi, %r8
shrq %cl, %r8
shlq $0x4, %r8
movups (%rax,%r8), %xmm0
movups %xmm0, (%rdx)
movb 0x48(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl %eax, %esi
addq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rdx)
movq 0x30(%rdi), %rax
movq (%rdx), %rcx
movq %rcx, %r8
shlq $0x4, %r8
movq 0x8(%rax,%r8), %r9
movb $0x1, %al
cmpq %r9, %rsi
jl 0x75565
addq $0x18, %r8
incq %rcx
subq %r9, %rsi
movq %rsi, 0x8(%rdx)
movq %rcx, (%rdx)
movq 0x30(%rdi), %r9
movq (%r9,%r8), %r9
addq $0x10, %r8
incq %rcx
cmpq %r9, %rsi
jge 0x75547
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btml_t_from_source
er_t x_btml_t_from_source( x_btml* o, tp_t t, x_source* source )
{
    // bcore_x_btml.h:110:1
    
    sr_s sr = sr_null();
    BLM_TRY(x_btml_parse_create_object(source, NULL, 0, (&(sr)) ))
    BLM_TRY(x_inst_t_copy_typed(((x_inst*)( o)),t, sr_s_o_type( (&(sr)) ), sr.o ))
    sr_s_down(&( sr ));
    return  0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq %rdx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x75a12
movq %rax, %rbx
testq %rax, %rax
je 0x758f7
leaq 0x1334e6(%rip), %rax    # 0x1a8dd0
movq (%rax), %rdi
callq 0xe0b30
jmp 0x759f9
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x75907
movq 0x8(%rax), %r12
jmp 0x7590a
xorl %r12d, %r12d
movq (%rsp), %r13
leaq 0x133b53(%rip), %rax    # 0x1a9468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x7596f
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x7596f
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x7596f
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x75a0b
movq (%rax,%rcx), %rbp
testq %rbp, %rbp
jne 0x7599f
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xf3f85
movq %rax, %rbp
leaq 0x133ad4(%rip), %rdi    # 0x1a9468
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
cmpq %r14, %r13
je 0x759b9
cmpq %r12, 0x8(%rbp)
jne 0x759be
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *0x90(%rbp)
xorl %r14d, %r14d
jmp 0x759d3
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq *0x98(%rbp)
movq %rax, %r14
testq %r14, %r14
je 0x759ea
leaq 0x1333f1(%rip), %rax    # 0x1a8dd0
movq (%rax), %rdi
callq 0xe0b30
movq %r14, %rbx
testq %r14, %r14
jne 0x759f9
movq %rsp, %rdi
callq 0x112baf
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x75973
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btml_create_from_source_t
x_btml* x_btml_create_from_source_t( x_source* source, tp_t* type )
{
    // bcore_x_btml.h:121:1
    
    if( !source )
    {
        (*(type)) = 0;
        return  NULL;
    }
    sr_s sr = sr_null();
    if( x_btml_parse_create_object(source, NULL, 0, (&(sr)) ) ) return  NULL;
    if( sr.o && type ) (*(type)) = sr_s_o_type(&( sr ));
    return  ((x_btml*)(sr.o)); // sr.o is NULL in case of error
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
testq %rdi, %rdi
je 0x766de
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x75a12
testq %rax, %rax
jne 0x766ee
movq (%rsp), %rbx
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x766ee
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x766e9
movq 0x8(%rax), %rax
jmp 0x766eb
movq $0x0, (%r14)
xorl %ebx, %ebx
jmp 0x766ee
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btml_create_from_source
x_btml* x_btml_create_from_source( x_source* source )
{
    // bcore_x_btml.h:136:1
    
    tp_t t = 0;
    x_btml* o = x_btml_create_from_source_t(source, (&(t)) );
    if( t )
    {
        ASSERT( x_stamp_t_is_aware(t ) );
    }
    return  o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %r14, %rsi
callq 0x7668a
movq %rax, %rbx
movq (%r14), %r14
testq %r14, %r14
je 0x767e9
leaq 0x1339cc(%rip), %rax    # 0x1aa0f8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r14, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r14, %rdx
je 0x76782
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r14, %rdx
je 0x76782
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r14, %rdx
je 0x76782
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r14, %rdx
jne 0x767f6
movq (%rax,%rcx), %r15
testq %r15, %r15
jne 0x767b2
movabsq $0x541d0401d4dcff33, %rdi # imm = 0x541D0401D4DCFF33
movq %r14, %rsi
callq 0xf3f85
movq %rax, %r15
leaq 0x133951(%rip), %rdi    # 0x1aa0f8
movq %r14, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r15, %rdi
xorl %esi, %esi
callq 0x10decf
testb %al, %al
jne 0x767e9
leaq 0xc1e80(%rip), %rdi     # 0x138647
leaq 0xcc637(%rip), %rsi     # 0x142e05
leaq 0xcc647(%rip), %rdx     # 0x142e1c
leaq 0xcbcda(%rip), %rcx     # 0x1424b6
movl $0xd11, %r8d            # imm = 0xD11
xorl %eax, %eax
callq 0xc8053
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x76786
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btml_parse_name
st_s* x_btml_parse_name( x_source* source )
{
    // bcore_x_btml.h:165:1
    BLM_INIT_LEVEL(0);
    st_s* st_name = ((st_s*)BLM_LEVEL_T_PUSH(0,st_s,st_s_create()));
    BLM_TRY_EXIT(x_source_parse_fa(source," #name", st_name ))
    BLM_RETURNV(st_s*, ((st_s*)bcore_fork(st_name)))
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x131935(%rip), %rax    # 0x1a8dd0
movq (%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xe0431
movq $0x0, 0x10(%rbx)
xorl %eax, %eax
callq 0x114bbb
movabsq $-0x503db0e6e1c2e704, %rdx # imm = 0xAFC24F191E3D18FC
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0xe0676
movq %rax, %rbx
leaq 0xd7da7(%rip), %rsi     # 0x14f282
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5cde9
testq %rax, %rax
je 0x77502
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xe0b30
movl %r14d, %edi
callq 0x59990
movq %rbx, %rdi
callq 0xc8348
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe0b30
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btml_name_of
sc_t x_btml_name_of( tp_t type, st_s* buf )
{
    // bcore_x_btml.h:174:1
    
    sc_t n = bcore_name_try_name(type );
    if( n ) return  n;
    BLM_TRY_EXIT(st_s_copy_typed(buf,((tp_t)(TYPEOF_tp_t)), (&(type)) ))
    return  buf->sc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
callq 0xe0cbc
testq %rax, %rax
jne 0x7756f
movabsq $0x6d07f9ef5b68e8a2, %rsi # imm = 0x6D07F9EF5B68E8A2
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1147c5
testq %rax, %rax
je 0x7756b
movq %rax, %r14
leaq 0x131875(%rip), %rax    # 0x1a8dd0
movq (%rax), %rdi
callq 0xe0b30
movl %r14d, %edi
callq 0x59990
movq 0x8(%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_btml_type_of
tp_t x_btml_type_of( const st_s* name )
{
    // bcore_x_btml.h:184:1
    
    tp_t tp = 0;
    if( name->size == 0 )
    {
        return  0;
    }
    else if( name->data[ 0 ] >= '0' && name->data[ 0 ] <= '9' )
    {
        st_s_parse_fa(name,0, -1, "#tp_t", &tp );
    }
    else
    {
        tp = btypeof( name->sc );
    }
    return  tp;
}

// Assembly:
pushq %rax
movq $0x0, (%rsp)
cmpq $0x0, 0x10(%rdi)
je 0x775b1
movq 0x8(%rdi), %rax
movb (%rax), %cl
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x775b5
leaq 0xcb89a(%rip), %rcx     # 0x142e36
movq %rsp, %r8
xorl %esi, %esi
movq $-0x1, %rdx
xorl %eax, %eax
callq 0x11886c
jmp 0x775ef
xorl %eax, %eax
jmp 0x775f3
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
testb %cl, %cl
je 0x775e8
incq %rax
movabsq $0x100000001b3, %rdx    # imm = 0x100000001B3
movzbl %cl, %edi
xorq %rsi, %rdi
imulq %rdx, %rdi
movb (%rax), %cl
incq %rax
movq %rdi, %rsi
testb %cl, %cl
jne 0x775d0
jmp 0x775eb
movq %rsi, %rdi
movq %rdi, (%rsp)
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/./bcore_spect_inst.h
// Function: bcore_inst_s_get_typed
BCORE_DECLARE_SPECT( bcore_inst )
{
    bcore_spect_header_s header;

    bcore_inst_body_s* body;

    uz_t size;   // sizeof(type);
    uz_t align;  // alignof(type)
    bl_t aware;  // object is self-aware, meaning it defines its type (aware_t) as first element

    bl_t init_flat; // flat initialization possible
    bl_t down_flat; // flat shut down possible
    bl_t copy_flat; // flat copying possible
    bl_t move_flat; // init_flat && copy_flat && down_flat

    /// these functions are only defined if they are part of object's reflection
    fp_t init_o; // bcore_fp_init or ap_t
    fp_t down_o; // bcore_fp_down or ap_t
    fp_t copy_o; // bcore_fp_copy or ap_t
    bcore_fp_copy_typed   copy_typed_o;
    bcore_fp_move         move_o;
    bcore_fp_create       create_o;
    bcore_fp_create_typed create_typed_o;
    bcore_fp_discard      discard_o;
    bcore_fp_clone        clone_o;

    /// callback perspective
    const bcore_inst_call_spect_s* inst_call_p;

    /// these functions are always defined and represent the service this perspective offers
    void ( *init         )( const bcore_inst_s* p, vd_t o );
    void ( *down         )( const bcore_inst_s* p, vd_t o );
    void ( *copy         )( const bcore_inst_s* p, vd_t o,         vc_t src );
    er_t ( *copy_typed   )( const bcore_inst_s* p, vd_t o, tp_t t, vc_t src );
    void ( *move         )( const bcore_inst_s* p, vd_t o,         vd_t src );
    vd_t ( *create       )( const bcore_inst_s* p );
    vd_t ( *create_typed )( const bcore_inst_s* p, tp_t t, vc_t src );
    void ( *discard      )( const bcore_inst_s* p, vd_t o );
    vd_t ( *clone        )( const bcore_inst_s* p, vc_t o );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13185a(%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 %rdi, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %rdi, %rdx
je 0x77c64
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %rbx, %rdx
je 0x77c64
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %rbx, %rdx
je 0x77c64
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %rbx, %rdx
jne 0x77c9f
movq (%rax,%rcx), %r14
testq %r14, %r14
jne 0x77c94
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %rbx, %rsi
callq 0xf3f85
movq %rax, %r14
leaq 0x1317df(%rip), %rdi    # 0x1a9468
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
jmp 0x77c68
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore.xo.c
// Function: x_btml_selftest
void x_btml_selftest( void )
{
    // bcore_x_btml.h:716:1
    BLM_INIT_LEVEL(0);
    sr_s zoo;BLM_T_INIT_SPUSH(sr_s, &zoo);; zoo = bcore_spect_via_create_zoo( 1000 );
    
    clock_t time = clock();
    sz_t size = x_btml_t_test_transfer(((const x_btml*)(zoo.o)),sr_s_o_type(&( zoo )) );
    time = clock() - time;
    
    bcore_msg_fa( "x_btml transfer #<f3_t>s; size: #<sz_t> bytes\n", ( f3_t )time/CLOCKS_PER_SEC, size );
    BLM_DOWN();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x12e0eb(%rip), %rax    # 0x1a8dd0
movq (%rax), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0431
movq 0x8(%rsp), %rbx
movq $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x112ba5
movabsq $0x79b76918ff0af12a, %rsi # imm = 0x79B76918FF0AF12A
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe06ab
leaq 0x30(%rsp), %rbx
movl $0x3e8, %esi            # imm = 0x3E8
movq %rbx, %rdi
callq 0x10e315
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movups (%rbx), %xmm0
movaps %xmm0, (%r14)
callq 0xd340
movq %rax, %rbx
movq (%r14), %rdi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7ad61
movq 0x8(%rax), %rsi
jmp 0x7ad63
xorl %esi, %esi
callq 0x7a9df
movq %rax, %r14
callq 0xd340
subq %rbx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0xbd2ed(%rip), %xmm0    # 0x138070
leaq 0xc8265(%rip), %rdi     # 0x142fef
movq %r14, %rsi
movb $0x1, %al
callq 0xc7ec8
leaq 0x8(%rsp), %rdi
callq 0xe0b11
addq $0x78, %rsp
popq %rbx
popq %r14
retq