LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_quicktypes.c
// Function: get_def_quicktype
static st_s* get_def_quicktype( hf hash, sr_s string, uz_t align )
{
    sc_t name = ( ( st_s* )string.o )->sc;
    st_s* s = st_s_createf( "#define TYPEOF_%s", name );
    uz_t pad = s->size < align ? align - s->size : 1;
    st_s_push_char_n( s, ' ', pad );
    st_s_pushf( s, "0x%016"PRIXtp_t"ull", hash( name ) );
    st_s_push_char( s, '\n' );
    sr_down( string );
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rsp), %rax
movq 0x8(%rax), %r12
leaq 0x51bde(%rip), %rdi     # 0xc4e26
movq %r12, %rsi
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %rbx
subq 0x10(%rax), %r14
pushq $0x1
popq %rdx
cmovaq %r14, %rdx
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x8f175
movq %r12, %rdi
callq *%r15
leaq 0x51bc0(%rip), %rsi     # 0xc4e38
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8f42b
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x8f0ee
testb $0x2, 0x50(%rsp)
je 0x732b1
leaq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x8cdc1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_quicktypes.c
// Function: max_len
static uz_t max_len( const sr_s* list )
{
    uz_t len = 0;
    for( uz_t i = 0; i < bcore_array_r_get_size( list ); i++ )
    {
        uz_t size = ( ( st_s* )bcore_array_r_get( list, i ).o )->size;
        len = size > len ? size : len;
    }
    return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rsp, %r15
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x731f8
cmpq %rax, %r14
jae 0x7334a
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x732c0
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq %r12, %rax
cmovaq %rax, %r12
incq %r14
jmp 0x7331b
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_quicktypes.c
// Function: bcore_type_is_leaf
bl_t bcore_type_is_leaf( tp_t type )
{
    switch( type )
    {
        case TYPEOF_s3_t:
        case TYPEOF_s2_t:
        case TYPEOF_s1_t:
        case TYPEOF_s0_t:
        case TYPEOF_u3_t:
        case TYPEOF_u2_t:
        case TYPEOF_u1_t:
        case TYPEOF_u0_t:
        case TYPEOF_f3_t:
        case TYPEOF_f2_t:
        case TYPEOF_sz_t:
        case TYPEOF_uz_t:
        case TYPEOF_sd_t:
        case TYPEOF_sc_t:
        case TYPEOF_vd_t:
        case TYPEOF_vc_t:
        case TYPEOF_fp_t:
        case TYPEOF_tp_t:
        case TYPEOF_bl_t:
        case TYPEOF_aware_t:
            return true;
        default:
            return false;
    }
}

// Assembly:
movb $0x1, %al
movabsq $-0x73f6ae1ad309fd45, %rcx # imm = 0x8C0951E52CF602BB
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x6bce971ace902370, %rcx # imm = 0x943168E5316FDC90
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x6119581ac7eacd63, %rcx # imm = 0x9EE6A7E53815329D
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x5fc2af85f419929b, %rcx # imm = 0xA03D507A0BE66D65
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x5aa4411ac4e2880e, %rcx # imm = 0xA55BBEE53B1D77F2
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x58737885f0577326, %rcx # imm = 0xA78C877A0FA88CDA
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x4882601bdca6aefb, %rcx # imm = 0xB77D9FE423595105
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x3f1363e6d8155aed, %rcx # imm = 0xC0EC9C1927EAA513
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x3ac242643d9c35a8, %rcx # imm = 0xC53DBD9BC263CA58
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x388c46b188de83fe, %rcx # imm = 0xC773B94E77217C02
cmpq %rcx, %rdi
je 0x734b5
movabsq $-0x84b14e74a9e1ff0, %rcx # imm = 0xF7B4EB18B561E010
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x230abe18cdeefc99, %rcx # imm = 0x230ABE18CDEEFC99
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x510c2417c67dabeb, %rcx # imm = 0x510C2417C67DABEB
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x54de8100f7c1cbe5, %rcx # imm = 0x54DE8100F7C1CBE5
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x585a3b17ca3de200, %rcx # imm = 0x585A3B17CA3DE200
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x62367a17d02b474d, %rcx # imm = 0x62367A17D02B474D
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x69849117d3eb7d62, %rcx # imm = 0x69849117D3EB7D62
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x6d07f9ef5b68e8a2, %rcx # imm = 0x6D07F9EF5B68E8A2
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x6db6f178cd6db4b8, %rcx # imm = 0x6DB6F178CD6DB4B8
cmpq %rcx, %rdi
je 0x734b5
movabsq $0x6f0b060106a30da4, %rcx # imm = 0x6F0B060106A30DA4
cmpq %rcx, %rdi
je 0x734b5
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_scan_type
s2_t sc_t_scan_type( sc_t format, tp_t* p_type, bl_t* p_is_ptr )
{
    sc_t fp = format;
    if( fp[ 0 ] == 0 ) return -1;
    tp_t type = 0;
    if( fp[ 0 ] == '<' )
    {
        fp++;
        sc_t fp0 = fp;
        while( *fp != 0 && *fp != '>' ) fp++;
        if( *fp != '>' ) return -1;
        sc_t fp1 = fp++;
        if( fp1[ -1 ] == '*' )
        {
            fp1--;
            if( p_is_ptr ) *p_is_ptr = true;
        }
        else
        {
            if( p_is_ptr ) *p_is_ptr = false;
        }
        type = btypeof_n( fp0, fp1 - fp0 );
    }
    else if( fp[ 1 ] != 0 && fp[ 2 ] == '_' && fp[ 3 ] == 't' ) // all types of format xy_t
    {
        type = btypeof_n( fp, 4 );
        fp += 4;
    }
    else
    {
        return -1;
    }
    if( p_type ) *p_type = type;
    return fp - format;
}

// Assembly:
movzbl (%rdi), %ecx
pushq $-0x1
popq %rax
testl %ecx, %ecx
je 0x73664
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3c, %ecx
jne 0x7360b
leaq 0x1(%rbx), %rdi
movq %rdi, %r15
movzbl (%r15), %ecx
testl %ecx, %ecx
je 0x7365f
cmpl $0x3e, %ecx
je 0x7362e
incq %r15
jmp 0x735f9
cmpb $0x0, 0x1(%rbx)
je 0x7365f
cmpb $0x5f, 0x2(%rbx)
jne 0x7365f
cmpb $0x74, 0x3(%rbx)
jne 0x7365f
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x73665
leaq 0x4(%rbx), %r15
jmp 0x73651
leaq -0x1(%r15), %rsi
movb -0x1(%r15), %al
cmpb $0x2a, %al
cmovneq %r15, %rsi
testq %rdx, %rdx
je 0x73646
cmpb $0x2a, %al
sete (%rdx)
incq %r15
subq %rdi, %rsi
callq 0x73665
testq %r14, %r14
je 0x73659
movq %rax, (%r14)
subl %ebx, %r15d
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_cpy
sd_t sc_t_cpy( sd_t dst, sc_t src )
{
    if( !dst && !src ) return NULL;
    uz_t len = src ? strlen( src ) : 0;
    dst = bcore_alloc( dst, len + 1 );
    bcore_memcpy( dst, src, len );
    dst[ len ] = 0;
    return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x74ee5
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x74eea
movq %rbx, %rdi
callq 0xd230
movq %rax, %r15
jmp 0x74eed
xorl %r14d, %r14d
jmp 0x74f0f
xorl %r15d, %r15d
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x6023e
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x60300
movb $0x0, (%r14,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_cmp
s2_t sc_t_cmp( sc_t str1, sc_t str2 )
{
    if( str1 == NULL ) return ( str2 == NULL ) ? 0 :  1;
    if( str2 == NULL ) return -1;
    while( ( *str1 != 0 ) && ( *str2 != 0 ) )
    {
        if( *str1 != *str2 ) return ( *str1 < *str2 ) ? 2 : -2;
        str1++;
        str2++;
    }
    return ( *str1 == 0 ) ? ( ( *str2 == 0 ) ? 0 : +1 ) : -1;
}

// Assembly:
testq %rdi, %rdi
je 0x74f41
pushq $-0x1
popq %rax
testq %rsi, %rsi
je 0x74f4f
xorl %ecx, %ecx
movb (%rdi,%rcx), %r8b
movb (%rsi,%rcx), %dl
testb %r8b, %r8b
je 0x74f48
testb %dl, %dl
je 0x74f4f
cmpb %dl, %r8b
jne 0x74f50
incq %rcx
jmp 0x74f27
xorl %eax, %eax
testq %rsi, %rsi
jmp 0x74f4c
xorl %eax, %eax
testb %dl, %dl
setne %al
retq
setl %al
movzbl %al, %eax
leal -0x2(,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sc.c
// Function: sc_t_cmp_n
s2_t sc_t_cmp_n( sc_t str1, uz_t n1, sc_t str2, uz_t n2 )
{
    if( str1 == NULL ) return ( str2 == NULL ) ? 0 :  1;
    if( str2 == NULL ) return -1;
    if( n1 == 0 ) return ( n2 == 0 ) ? 0 :  1;
    if( n2 == 0 ) return -1;
    uz_t i1 = 0;
    uz_t i2 = 0;
    while( ( i1 < n1 ) && ( i2 < n2 ) )
    {
        if( str1[ i1 ] != str2[ i2 ] ) return ( str1[ i1 ] < str2[ i2 ] ) ? 2 : -2;
        i1++;
        i2++;
    }
    return ( i1 == n1 ) ? ( ( i2 == n2 ) ? 0 : +1 ) : -1;
}

// Assembly:
testq %rdi, %rdi
je 0x74fa6
pushq $-0x1
popq %rax
testq %rdx, %rdx
je 0x74fc4
testq %rsi, %rsi
je 0x74fad
testq %rcx, %rcx
je 0x74fc4
cmpq %rsi, %rcx
movq %rsi, %rax
cmovbq %rcx, %rax
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x74fb6
movb (%rdx,%r8), %r9b
leaq 0x1(%r8), %r10
cmpb %r9b, (%rdi,%r8)
movq %r10, %r8
je 0x74f82
setl %al
movzbl %al, %eax
leal -0x2(,%rax,4), %eax
retq
xorl %eax, %eax
testq %rdx, %rdx
jmp 0x74fb2
xorl %eax, %eax
testq %rcx, %rcx
setne %al
retq
xorl %edx, %edx
cmpq %rsi, %rcx
seta %dl
pushq $-0x1
popq %rax
cmovael %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_signal.c
// Function: bcore_signal_s_broadcast
vd_t bcore_signal_s_broadcast( const bcore_signal_s* o, bcore_fp_signal_handler* arr, uz_t size )
{
    vd_t ret = NULL;

    if( o->type == TYPEOF_down0 || o->type == TYPEOF_down1 )
    {
        for( uz_t i = size; i > 0; i-- ) if( ( ret = arr[ i - 1 ]( o ) ) ) return ret;
    }
    else
    {
        for( uz_t i = 0; i < size; i++ ) if( ( ret = arr[ i     ]( o ) ) ) return ret;
    }

    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movabsq $-0x69a05654ee793a14, %rcx # imm = 0x965FA9AB1186C5EC
cmpq %rcx, %rax
je 0x751ab
movabsq $-0x69a05554ee793861, %rcx # imm = 0x965FAAAB1186C79F
cmpq %rcx, %rax
jne 0x751c2
xorl %r12d, %r12d
subq $0x1, %rbx
jb 0x751df
movq %r15, %rdi
callq *(%r14,%rbx,8)
testq %rax, %rax
je 0x751ae
jmp 0x751dc
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x751df
movq %r15, %rdi
callq *(%r14,%r13,8)
incq %r13
testq %rax, %rax
je 0x751c8
movq %rax, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_buffer_s_flush
bcore_sink_buffer_s* bcore_sink_buffer_s_flush( bcore_sink_buffer_s* o )
{
    if( o->consumer && o->size > 0 )
    {
        uz_t pushed_size = bcore_sink_a_push_data( o->consumer, o->data, o->size );
        if( pushed_size != o->size ) ERR( "Consumer accepted %zu of %zu bytes.", pushed_size, o->size );
        o->size = 0;
    }
    return o;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x7558b
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x7558b
movq 0x8(%rbx), %rsi
callq 0x75590
movq 0x10(%rbx), %r9
cmpq %r9, %rax
je 0x75586
leaq 0x4fe80(%rip), %rdi     # 0xc53e9
leaq 0x4fe93(%rip), %rsi     # 0xc5403
leaq 0x4fe9a(%rip), %rcx     # 0xc5411
movl $0xe5, %edx
movq %rax, %r8
xorl %eax, %eax
callq 0x60031
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: buffer_flow_snk
static uz_t buffer_flow_snk( bcore_sink_buffer_s* o, vc_t data, uz_t size )
{
    uz_t new_size = o->size + size;
    if( new_size > o->space )
    {
        uz_t new_space = ( o->space * 2 > new_size ) ? o->space * 2 : new_size;
        o->data = bcore_bn_alloc( o->data, o->space, new_space, &o->space );
    }
    bcore_memcpy( o->data + o->size, data, size );
    o->size += size;
    if( o->consumer && o->size >= o->entrepot_size ) bcore_sink_buffer_s_flush( o );
    return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
addq %rdi, %rdx
movq 0x18(%r14), %rsi
cmpq %rsi, %rdx
jbe 0x75622
leaq 0x18(%r14), %rcx
leaq (%rsi,%rsi), %rdi
cmpq %rdx, %rdi
cmovaq %rdi, %rdx
movq %rax, %rdi
callq 0x60259
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rdi
addq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x60300
movq 0x10(%r14), %rax
addq %rbx, %rax
movq %rax, 0x10(%r14)
cmpq $0x0, 0x20(%r14)
je 0x75650
cmpq 0x28(%r14), %rax
jb 0x75650
movq %r14, %rdi
callq 0x7553a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_file_s_open
void bcore_sink_file_s_open( bcore_sink_file_s* o )
{
    if( !o->name ) ERR( "No file name specified." );
    if( o->handle ) bcore_sink_file_s_close( o );
    o->handle = fopen( o->name->sc, "wb" );
    if( !o->handle )
    {
        st_s* msg = st_s_createf( "Error opening file %s:\n", o->name->sc );
        perror( msg->sc );
        st_s_discard( msg );
        bcore_abort();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x75772
leaq 0x4fd0c(%rip), %rdi     # 0xc5464
leaq 0x4fca4(%rip), %rsi     # 0xc5403
leaq 0x4fd15(%rip), %rcx     # 0xc547b
movl $0x19b, %edx            # imm = 0x19B
xorl %eax, %eax
callq 0x60031
cmpq $0x0, 0x10(%rbx)
je 0x75781
movq %rbx, %rdi
callq 0x757d2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x4badd(%rip), %rsi     # 0xc126d
callq 0xd170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x757a0
popq %rbx
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x4fce4(%rip), %rdi     # 0xc5493
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xd420
movq %rbx, %rdi
callq 0x8edd4
xorl %eax, %eax
popq %rbx
jmp 0x5f9af
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_file_s_close
void bcore_sink_file_s_close( bcore_sink_file_s* o )
{
    if( !o->handle ) return;
    if( fclose( o->handle ) != 0 )
    {
        st_s* msg = st_s_createf( "Error closing file %s:\n", o->name->sc );
        perror( msg->sc );
        st_s_discard( msg );
        bcore_abort();
    }
    o->handle = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x757f0
callq 0xd390
testl %eax, %eax
jne 0x757f8
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x4fca4(%rip), %rdi     # 0xc54ab
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xd420
movq %r14, %rdi
callq 0x8edd4
xorl %eax, %eax
callq 0x5f9af
jmp 0x757eb
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_file_s_try_open
bl_t bcore_sink_file_s_try_open( bcore_sink_file_s* o )
{
    if( !o->name ) return false;
    if( o->handle ) bcore_sink_file_s_close( o );
    o->handle = fopen( o->name->sc, "wb" );
    if( !o->handle ) return false;
    return true;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x75867
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x7584b
movq %rbx, %rdi
callq 0x757d2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x4ba17(%rip), %rsi     # 0xc126d
callq 0xd170
movq %rax, 0x10(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_file_s_flush
bcore_sink_file_s* bcore_sink_file_s_flush( bcore_sink_file_s* o )
{
    if( !o->handle ) return o;
    if( fflush( o->handle ) != 0 )
    {
        st_s* msg = st_s_createf( "Error flushing file %s:\n", o->name->sc );
        perror( msg->sc );
        st_s_discard( msg );
        bcore_abort();
    }
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x75883
callq 0xd4f0
testl %eax, %eax
jne 0x7588e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x4fc26(%rip), %rdi     # 0xc54c3
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xd420
movq %r14, %rdi
callq 0x8edd4
xorl %eax, %eax
callq 0x5f9af
jmp 0x75883
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: file_flow_snk
static uz_t file_flow_snk( bcore_sink_file_s* o, vc_t data, uz_t size )
{
    if( !o->handle ) bcore_sink_file_s_open( o );
    uz_t wsize = fwrite( data, 1, size, o->handle );
    if( wsize != size )
    {
        if( ferror( o->handle ) )
        {
            st_s* msg = st_s_createf( "Error writing to file %s:\n", o->name->sc );
            perror( msg->sc );
            st_s_discard( msg );
        }
    }
    return wsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
jne 0x758e6
movq %rbx, %rdi
callq 0x75746
movq 0x10(%rbx), %rcx
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xd3d0
movq %rax, %r14
cmpq %r15, %rax
je 0x75909
movq 0x10(%rbx), %rdi
callq 0xd240
testl %eax, %eax
jne 0x75912
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x4fcf6(%rip), %rdi     # 0xc5617
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xd420
movq %rbx, %rdi
callq 0x8edd4
jmp 0x75909
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_open_file
bcore_sink_chain_s* bcore_sink_open_file( sc_t file_name )
{
    bcore_sink_chain_s* chain = bcore_sink_chain_s_create();
    bcore_sink_chain_s_push_d( chain, bcore_sink_file_s_create_name( file_name ) );
    bcore_sink_chain_s_push_d( chain, bcore_inst_t_create( typeof( "bcore_sink_buffer_s" ) ) );
    return chain;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x752d1
movq %rax, %r14
movq %rbx, %rdi
callq 0x75705
movq %r14, %rdi
movq %rax, %rsi
callq 0x75327
leaq 0x4f638(%rip), %rdi     # 0xc4f9f
callq 0x7598a
movq %rax, %rdi
callq 0x752dd
movq %r14, %rdi
movq %rax, %rsi
callq 0x75327
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_try_open_file
bcore_sink_chain_s* bcore_sink_try_open_file( sc_t file_name )
{
    bcore_sink_file_s* sink_file = bcore_sink_file_s_create_name( file_name );
    if( bcore_sink_file_s_try_open( sink_file ) )
    {
        bcore_sink_chain_s* chain = bcore_sink_chain_s_create();
        bcore_sink_chain_s_push_d( chain, sink_file );
        bcore_sink_chain_s_push_d( chain, bcore_inst_t_create( typeof( "bcore_sink_buffer_s" ) ) );
        return chain;
    }
    else
    {
        bcore_sink_file_s_discard( sink_file );
        return NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x75705
movq %rax, %r14
movq %rax, %rdi
callq 0x7582b
testb %al, %al
je 0x75a0e
callq 0x752d1
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x75327
leaq 0x4f5ab(%rip), %rdi     # 0xc4f9f
callq 0x7598a
movq %rax, %rdi
callq 0x752dd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x75327
jmp 0x75a18
movq %r14, %rdi
callq 0x756e4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_stdout_s_flush
bcore_sink_stdout_s* bcore_sink_stdout_s_flush( bcore_sink_stdout_s* o )
{
    if( fflush( stdout ) != 0 )
    {
        st_s* msg = st_s_createf( "Error flushing stdout\n" );
        perror( msg->sc );
        st_s_discard( msg );
        bcore_abort();
    }
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x94500(%rip), %rax     # 0x109ff0
movq (%rax), %rdi
callq 0xd4f0
testl %eax, %eax
jne 0x75b07
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4f9e2(%rip), %rdi     # 0xc54f0
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xd420
movq %r14, %rdi
callq 0x8edd4
xorl %eax, %eax
callq 0x5f9af
jmp 0x75afc
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_stdout_s_push_data
uz_t bcore_sink_stdout_s_push_data( bcore_sink_stdout_s* o, vc_t data, uz_t size )
{
    st_s* msg = st_s_create_sc_n( data, size );
    fprintf( stdout, "%s", msg->sc );
    st_s_discard( msg );
    return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8ed05
movq %rax, %r14
movq 0x944a2(%rip), %rax     # 0x109ff0
movq (%rax), %rsi
movq 0x8(%r14), %rdi
callq 0xd2b0
movq %r14, %rdi
callq 0x8edd4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_stderr_s_flush
bcore_sink_stderr_s* bcore_sink_stderr_s_flush( bcore_sink_stderr_s* o )
{
    if( fflush( stderr ) != 0 )
    {
        st_s* msg = st_s_createf( "Error flushing stderr\n" );
        perror( msg->sc );
        st_s_discard( msg );
        bcore_abort();
    }
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x943a6(%rip), %rax     # 0x109fe0
movq (%rax), %rdi
callq 0xd4f0
testl %eax, %eax
jne 0x75c51
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4f8c3(%rip), %rdi     # 0xc551b
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xd420
movq %r14, %rdi
callq 0x8edd4
xorl %eax, %eax
callq 0x5f9af
jmp 0x75c46
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_stderr_s_push_data
uz_t bcore_sink_stderr_s_push_data( bcore_sink_stderr_s* o, vc_t data, uz_t size )
{
    st_s* msg = st_s_create_sc_n( data, size );
    fprintf( stderr, "%s", msg->sc );
    st_s_discard( msg );
    return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8ed05
movq %rax, %r14
movq 0x94348(%rip), %rax     # 0x109fe0
movq (%rax), %rsi
movq 0x8(%r14), %rdi
callq 0xd2b0
movq %r14, %rdi
callq 0x8edd4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: buffer_s_create_self
static bcore_self_s* buffer_s_create_self( void )
{
    sc_t def =
    "bcore_sink_buffer_s = bcore_sink"
    "{ "
      "aware_t _; "
      "u0_t [] data; "
      "private vd_t consumer; "
      "uz_t entrepot_size; "
    "}";
    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_sink_buffer_s );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_sink_buffer_s_init,         "bcore_fp_init",              "init"  );
    bcore_self_s_push_ns_func( self, ( fp_t )buffer_flow_snk,                  "bcore_fp_flow_snk",          "flow_snk"  );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_sink_buffer_s_set_consumer, "bcore_sink_fp_set_consumer", "set_consumer" );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_sink_buffer_s_flush,        "bcore_sink_fp_flush",        "flush" );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x4f5e2(%rip), %rdi     # 0xc5632
pushq $0x30
popq %rsi
pushq $0x8
popq %rdx
callq 0x64356
movq %rax, %rbx
leaq -0xba8(%rip), %rsi      # 0x754bd
leaq 0x4a74f(%rip), %rdx     # 0xc07bb
leaq 0x4a751(%rip), %rcx     # 0xc07c4
movq %rax, %rdi
callq 0x63a2b
leaq -0xaa1(%rip), %rsi      # 0x755e1
leaq 0x4f4e4(%rip), %rdx     # 0xc556d
leaq 0x4f4e6(%rip), %rcx     # 0xc5576
movq %rbx, %rdi
callq 0x63a2b
leaq -0x9fe(%rip), %rsi      # 0x756a1
leaq 0x4f5f4(%rip), %rdx     # 0xc569a
leaq 0x4f5fb(%rip), %rcx     # 0xc56a8
movq %rbx, %rdi
callq 0x63a2b
leaq -0xb82(%rip), %rsi      # 0x7553a
leaq 0x4f4d6(%rip), %rdx     # 0xc5599
leaq 0x41521(%rip), %rcx     # 0xb75eb
movq %rbx, %rdi
callq 0x63a2b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: file_s_create_self
static bcore_self_s* file_s_create_self( void )
{
    sc_t def =
    "bcore_sink_file_s = bcore_sink"
    "{ "
      "aware_t _; "
      "st_s => name; "
      "private vd_t handle; "
    "}";

    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_sink_file_s );
    bcore_self_s_push_ns_amoeba( self, file_init_a, "init" );
    bcore_self_s_push_ns_amoeba( self, file_down_a, "down" );
    bcore_self_s_push_ns_amoeba( self, file_copy_a, "copy" );
    bcore_self_s_push_ns_func( self, ( fp_t )file_interpret_body_a,   "ap_t", "interpret_body"        );
    bcore_self_s_push_ns_func( self, ( fp_t )file_flow_snk,           "bcore_fp_flow_snk", "flow_snk" );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_sink_file_s_flush, "bcore_sink_fp_flush", "flush"  );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x4f5d6(%rip), %rdi     # 0xc56b5
pushq $0x18
popq %rsi
pushq $0x8
popq %rdx
callq 0x64356
movq %rax, %rbx
leaq 0x296(%rip), %rsi       # 0x7638a
leaq 0x4a6c9(%rip), %rdx     # 0xc07c4
movq %rax, %rdi
callq 0x63a95
leaq 0x296(%rip), %rsi       # 0x763a0
leaq 0x3e4d7(%rip), %rdx     # 0xb45e8
movq %rbx, %rdi
callq 0x63a95
leaq 0x293(%rip), %rsi       # 0x763b3
leaq 0x45c2d(%rip), %rdx     # 0xbbd54
movq %rbx, %rdi
callq 0x63a95
leaq 0x290(%rip), %rsi       # 0x763c6
leaq 0x4b7d8(%rip), %rdx     # 0xc1915
leaq 0x4f5c1(%rip), %rcx     # 0xc5705
movq %rbx, %rdi
callq 0x63a2b
leaq -0x890(%rip), %rsi      # 0x758c3
leaq 0x4f413(%rip), %rdx     # 0xc556d
leaq 0x4f415(%rip), %rcx     # 0xc5576
movq %rbx, %rdi
callq 0x63a2b
leaq -0x906(%rip), %rsi      # 0x7586a
leaq 0x4f422(%rip), %rdx     # 0xc5599
leaq 0x4146d(%rip), %rcx     # 0xb75eb
movq %rbx, %rdi
callq 0x63a2b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: chain_s_create_self
static bcore_self_s* chain_s_create_self( void )
{
    sc_t def =
    "bcore_sink_chain_s = bcore_sink"
    "{ "
      "aware_t _; "
      "aware => [] data; "
    "}";

    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_sink_chain_s );
    bcore_self_s_push_ns_amoeba( self, chain_init_a, "init" );
    bcore_self_s_push_ns_amoeba( self, chain_down_a, "down" );
    bcore_self_s_push_ns_amoeba( self, chain_copy_a, "copy" );
    bcore_self_s_push_ns_func( self, ( fp_t )chain_interpret_body_a,   "ap_t", "interpret_body" );
    bcore_self_s_push_ns_func( self, ( fp_t )chain_flow_snk,           "bcore_fp_flow_snk",   "flow_snk" );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_sink_chain_s_set_consumer, "bcore_sink_fp_set_consumer", "set_consumer" );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_sink_chain_s_flush, "bcore_sink_fp_flush", "flush"    );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x4f581(%rip), %rdi     # 0xc5714
pushq $0x20
popq %rsi
pushq $0x8
popq %rdx
callq 0x64356
movq %rax, %rbx
leaq 0x231(%rip), %rsi       # 0x763d9
leaq 0x4a615(%rip), %rdx     # 0xc07c4
movq %rax, %rdi
callq 0x63a95
leaq 0x234(%rip), %rsi       # 0x763f2
leaq 0x3e423(%rip), %rdx     # 0xb45e8
movq %rbx, %rdi
callq 0x63a95
leaq 0x231(%rip), %rsi       # 0x76405
leaq 0x45b79(%rip), %rdx     # 0xbbd54
movq %rbx, %rdi
callq 0x63a95
leaq 0x251(%rip), %rsi       # 0x7643b
leaq 0x4b724(%rip), %rdx     # 0xc1915
leaq 0x4f50d(%rip), %rcx     # 0xc5705
movq %rbx, %rdi
callq 0x63a2b
leaq -0xd64(%rip), %rsi      # 0x754a3
leaq 0x4f35f(%rip), %rdx     # 0xc556d
leaq 0x4f361(%rip), %rcx     # 0xc5576
movq %rbx, %rdi
callq 0x63a2b
leaq -0xbcb(%rip), %rsi      # 0x75659
leaq 0x4f46f(%rip), %rdx     # 0xc569a
leaq 0x4f476(%rip), %rcx     # 0xc56a8
movq %rbx, %rdi
callq 0x63a2b
leaq -0xdfd(%rip), %rsi      # 0x75444
leaq 0x4f351(%rip), %rdx     # 0xc5599
leaq 0x4139c(%rip), %rcx     # 0xb75eb
movq %rbx, %rdi
callq 0x63a2b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_chain_s_set_supplier
void bcore_source_chain_s_set_supplier( bcore_source_chain_s* o, vd_t supplier )
{
    if( o->size == 0 ) ERR( "chain is empty" );
    bcore_source_a_set_supplier( o->data[ 0 ], supplier );
    for( uz_t i = 1; i < o->size; i++ )
    {
        // resetting the supplier also resets of the internal state of each element
        bcore_source_a_set_supplier( o->data[ i ], o->data[ i - 1 ] );
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x76767
leaq 0x4f1f6(%rip), %rdi     # 0xc5943
leaq 0x4f211(%rip), %rsi     # 0xc5965
leaq 0x4ecfa(%rip), %rcx     # 0xc5455
movl $0x99, %edx
xorl %eax, %eax
callq 0x60031
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x766c2
pushq $0x1
popq %r14
cmpq 0x10(%rbx), %r14
jae 0x76797
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r14,8), %rsi
movq (%rax,%r14,8), %rdi
callq 0x766c2
incq %r14
jmp 0x7677a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_chain_s_get_index
s3_t bcore_source_chain_s_get_index( const bcore_source_chain_s* o )
{
    s3_t index = 0;
    for( uz_t i = 0; i < o->size; i++ )
    {
        index += bcore_source_a_get_index( o->data[ i ] );
    }
    return index;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpq 0x10(%r14), %r15
jae 0x76848
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x76851
addq %rax, %rbx
incq %r15
jmp 0x7682d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_chain_s_set_index
void bcore_source_chain_s_set_index( bcore_source_chain_s* o, s3_t index )
{
    if( o->size == 0 ) ERR( "Chain is empty." );
    s3_t cur_index = bcore_source_chain_s_get_index( o );
    if( index == cur_index ) return;
    bcore_source_a_set_index( o->data[ 0 ], index );
    for( uz_t i = 1; i < o->size; i++ )
    {
        // resetting the supplier also resets of the internal state of each element
        bcore_source_a_set_supplier( o->data[ i ], o->data[ i - 1 ] );
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x7689b
leaq 0x4f0f4(%rip), %rdi     # 0xc5975
leaq 0x4f0dd(%rip), %rsi     # 0xc5965
leaq 0x4f105(%rip), %rcx     # 0xc5994
movl $0xc2, %edx
xorl %eax, %eax
callq 0x60031
movq %rbx, %rdi
callq 0x76820
cmpq %r14, %rax
jne 0x768b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x768e0
pushq $0x1
popq %r14
cmpq 0x10(%rbx), %r14
jae 0x768a8
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r14,8), %rsi
movq (%rax,%r14,8), %rdi
callq 0x766c2
incq %r14
jmp 0x768c3
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_buffer_s_setup_from_data
bcore_source_buffer_s* bcore_source_buffer_s_setup_from_data( bcore_source_buffer_s* o, vc_t data, uz_t size )
{
    o->data = bcore_b_alloc( o->data, size, &o->space );
    bcore_memcpy( o->data, data, size );
    o->size = size;
    o->index = 0;
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
leaq 0x18(%r15), %rdx
movq %rbx, %rsi
callq 0x60254
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x60300
movq %rbx, 0x10(%r15)
andq $0x0, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: buffer_flow_src
static uz_t buffer_flow_src( bcore_source_buffer_s* o, vd_t data, uz_t size )
{
    if( size < o->size - o->index )
    {
        bcore_memcpy( data, o->data + o->index, size );
        o->index += size;
        return size;
    }

    uz_t size1 = o->size - o->index;
    bcore_memcpy( data, o->data + o->index, size1 );
    o->index += size1;
    data = ( u0_t* )data + size1;
    size -= size1;
    o->size = o->index = 0;
    if( !o->ext_supplier ) return size1;

    // the code below handles the case with supplier

    if( size > o->prefetch_size ) return bcore_source_a_get_data( o->ext_supplier, data, size ) + size1;

    if( o->space < o->prefetch_size )
    {
        o->data = bcore_bn_alloc( o->data, o->space,                0, &o->space );
        o->data = bcore_bn_alloc( o->data, o->space, o->prefetch_size, &o->space );
    }
    o->size = bcore_source_a_get_data( o->ext_supplier, o->data, o->prefetch_size );

    if( o->size < o->prefetch_size )
    {
        if( bcore_source_a_eos( o->ext_supplier ) ) o->ext_supplier = NULL;
    }

    if( size < o->size )
    {
        bcore_memcpy( data, o->data, size );
        o->index += size;
        return size1 + size;
    }
    else
    {
        bcore_memcpy( data, o->data, o->size );
        o->size = o->index = 0;
        return size1 + o->size;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq 0x20(%rdi), %rsi
subq %rsi, %r15
addq 0x8(%rdi), %rsi
movq %rdx, %r13
subq %r15, %r13
jae 0x76a3b
movq %r12, %rdi
movq %rbx, %rdx
callq 0x60300
addq %rbx, 0x20(%r14)
jmp 0x76b17
movq %r12, %rdi
movq %r15, %rdx
callq 0x60300
andq $0x0, 0x20(%r14)
andq $0x0, 0x10(%r14)
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x76b14
addq %r15, %r12
movq 0x30(%r14), %rdx
cmpq %rdx, %r13
jbe 0x76a7f
movq %r12, %rsi
movq %r13, %rdx
callq 0x7909c
movq %rax, %rbx
addq %r15, %rbx
jmp 0x76b17
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rax
cmpq %rdx, %rax
jae 0x76ac6
leaq 0x18(%r14), %rbp
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbp, %rcx
callq 0x60259
movq %rax, 0x8(%r14)
movq 0x18(%r14), %rsi
movq 0x30(%r14), %rdx
movq %rax, %rdi
movq %rbp, %rcx
callq 0x60259
movq %rax, %rsi
movq %rax, 0x8(%r14)
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rdx
callq 0x7909c
movq %rax, 0x10(%r14)
cmpq 0x30(%r14), %rax
jae 0x76ae7
movq 0x28(%r14), %rdi
callq 0x767b6
testb %al, %al
je 0x76ae7
andq $0x0, 0x28(%r14)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r12, %rdi
cmpq %rdx, %r13
jae 0x76b05
movq %r13, %rdx
callq 0x60300
addq %r13, 0x20(%r14)
jmp 0x76b17
callq 0x60300
andq $0x0, 0x20(%r14)
andq $0x0, 0x10(%r14)
movq %r15, %rbx
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_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_string_s_init
void bcore_source_string_s_init( bcore_source_string_s* o )
{
    bcore_memzero( o, sizeof( *o ) );
    o->_ = TYPEOF_bcore_source_string_s;
    o->prefetch_size = 16384;
    o->refill_limit  = 4096;

    //o->refill_limit  = 8000;

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x38
popq %rsi
callq 0x6028b
movabsq $-0x7a841657f0cf5c40, %rax # imm = 0x857BE9A80F30A3C0
movq %rax, (%rbx)
movq $0x4000, 0x28(%rbx)     # imm = 0x4000
movq $0x1000, 0x20(%rbx)     # imm = 0x1000
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: string_flow_src
static uz_t string_flow_src( bcore_source_string_s* o, vd_t data, uz_t size )
{
    if( !o->string ) o->string = st_s_create();
    if( size > o->string->size - o->index )
    {
        // first send rest of buffer
        uz_t size1 = o->string->size - o->index;
        bcore_memcpy( data, o->string->data + o->index, size1 );
        o->index += size1;
        data = (u0_t*)data + size1;
        size -= size1;

        // refill to remaining size (if possible)
        if( o->ext_supplier ) string_refill( o, size );

        // send rest of data (if any)
        uz_t size2 = size < o->string->size - o->index ? size : o->string->size - o->index;
        bcore_memcpy( data, o->string->data + o->index, size2 );
        o->index += size2;

        return size1 + size2;
    }
    else
    {
        bcore_memcpy( data, o->string->data + o->index, size );
        o->index += size;
        return size;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x76f0a
xorl %eax, %eax
callq 0x8eb65
movq %rax, 0x8(%rbx)
movq 0x10(%rax), %r12
movq 0x10(%rbx), %rsi
subq %rsi, %r12
addq 0x8(%rax), %rsi
movq %r15, %r13
subq %r12, %r13
jbe 0x76f7a
movq %r14, %rdi
movq %r12, %rdx
callq 0x60300
movq 0x10(%rbx), %rsi
addq %r12, %rsi
movq %rsi, 0x10(%rbx)
addq %r12, %r14
cmpq $0x0, 0x18(%rbx)
je 0x76f50
movq %rbx, %rdi
movq %r13, %rsi
callq 0x790eb
movq 0x10(%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r15
subq %rsi, %r15
cmpq %r15, %r13
cmovbq %r13, %r15
addq 0x8(%rax), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x60300
addq %r15, 0x10(%rbx)
addq %r12, %r15
jmp 0x76f89
movq %r14, %rdi
movq %r15, %rdx
callq 0x60300
addq %r15, 0x10(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_string_s_eos
bl_t bcore_source_string_s_eos( const bcore_source_string_s* o )
{
    if( !o->string )
    {
        if( o->ext_supplier ) return bcore_source_a_eos( o->ext_supplier );
        return true;
    }

    if( o->index < o->string->size ) return false;
    if( o->ext_supplier ) return bcore_source_a_eos( o->ext_supplier );

    return true;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x76fba
movq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
jae 0x76fac
xorl %eax, %eax
retq
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x76fc7
jmp 0x767b6
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x767b6
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_file_s_open
void bcore_source_file_s_open( bcore_source_file_s* o )
{
    if( !o->name ) ERR( "No file name specified." );
    if( o->handle ) bcore_source_file_s_close( o );
    o->handle = fopen( o->name->sc, "rb" );
    if( !o->handle )
    {
        st_s* msg = st_s_createf( "Error opening file %s:\n", o->name->sc );
        perror( msg->sc );
        st_s_discard( msg );
        bcore_abort();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x77185
leaq 0x4e8ee(%rip), %rdi     # 0xc5a59
leaq 0x4e7f3(%rip), %rsi     # 0xc5965
leaq 0x4e302(%rip), %rcx     # 0xc547b
movl $0x445, %edx            # imm = 0x445
xorl %eax, %eax
callq 0x60031
cmpq $0x0, 0x10(%rbx)
je 0x77194
movq %rbx, %rdi
callq 0x771e5
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x4e8cf(%rip), %rsi     # 0xc5a72
callq 0xd170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x771b3
popq %rbx
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x4e2d1(%rip), %rdi     # 0xc5493
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xd420
movq %rbx, %rdi
callq 0x8edd4
xorl %eax, %eax
popq %rbx
jmp 0x5f9af
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: file_flow_src
static uz_t file_flow_src( bcore_source_file_s* o, vd_t data, uz_t size )
{
    if( !o->handle ) bcore_source_file_s_open( o );
    uz_t rsize = fread( data, 1, size, o->handle );
    if( rsize != size )
    {
        if( ferror( o->handle ) )
        {
            st_s* msg = st_s_createf( "Error reading file %s:\n", o->name->sc );
            perror( msg->sc );
            st_s_discard( msg );
        }
    }
    return rsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
jne 0x77263
movq %rbx, %rdi
callq 0x77159
movq 0x10(%rbx), %rcx
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xd310
movq %rax, %r14
cmpq %r15, %rax
je 0x77286
movq 0x10(%rbx), %rdi
callq 0xd240
testl %eax, %eax
jne 0x7728f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x4ea4a(%rip), %rdi     # 0xc5ce8
xorl %eax, %eax
callq 0x8ebc4
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xd420
movq %rbx, %rdi
callq 0x8edd4
jmp 0x77286
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_stdin_s_get_data
uz_t bcore_source_stdin_s_get_data( bcore_source_stdin_s* o, vd_t data, uz_t size )
{
    for( uz_t i = 0; i < size; i++ )
    {
        if( o->buf_index < o->buf.size )
        {
            ( ( u0_t* )data )[ i ] = o->buf.data[ o->buf_index++ ];
        }
        else
        {
            s2_t c = fgetc( stdin );
            if( feof( stdin ) ) return i;
            ( ( u0_t* )data )[ i ] = c;
            bcore_source_stdin_s_push_char( o, c );
            o->buf_index = o->buf.size;
        }
    }

    return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq 0x92a12(%rip), %r13     # 0x109fd8
cmpq %r12, %rbx
je 0x77622
movq 0x10(%r15), %rax
cmpq 0x30(%r15), %rax
jae 0x775ea
movq 0x28(%r15), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x10(%r15)
movb (%rcx,%rax), %al
movb %al, (%r14,%r12)
jmp 0x7761a
movq (%r13), %rdi
callq 0xd290
movl %eax, %ebp
movq (%r13), %rdi
callq 0xd380
testl %eax, %eax
jne 0x7761f
movb %bpl, (%r14,%r12)
movsbl %bpl, %esi
movq %r15, %rdi
callq 0x77634
movq 0x30(%r15), %rax
movq %rax, 0x10(%r15)
incq %r12
jmp 0x775c6
movq %r12, %rbx
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_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_stdin_s_push_char
static void bcore_source_stdin_s_push_char( bcore_source_stdin_s* o, char c )
{
    st_s_push_char( &o->buf, c );

    if( o->buf.size >= o->buf_limit )
    {
        sz_t block_size = o->buf_limit >> 1;
        if( o->buf_index >= o->buf.size - block_size )
        {
            for( sz_t i = 0; i < block_size; i++ ) o->buf.data[ i ] = o->buf.data[ o->buf.size - block_size + i ];
            for( sz_t i = block_size; i < o->buf.size; i++ ) o->buf.data[ i ] = 0;
            o->base_index += o->buf.size - block_size;
            o->buf_index  -= o->buf.size - block_size;
            o->buf.size = block_size;
        }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x8f0ee
movq 0x18(%rbx), %rax
movq 0x30(%rbx), %rcx
cmpq %rax, %rcx
jb 0x776bc
sarq %rax
subq %rax, %rcx
cmpq %rcx, 0x10(%rbx)
jb 0x776bc
xorl %ecx, %ecx
testq %rax, %rax
movl $0x0, %edx
cmovgq %rax, %rdx
movq %rax, %rsi
negq %rsi
cmpq %rcx, %rdx
je 0x7768e
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %r8
addq %rdi, %r8
addq %rsi, %r8
movb (%rcx,%r8), %r8b
movb %r8b, (%rdi,%rcx)
incq %rcx
jmp 0x7766e
movq %rax, %rcx
movq 0x30(%rbx), %rdx
cmpq %rdx, %rcx
jae 0x776a7
movq 0x28(%rbx), %rdx
movb $0x0, (%rdx,%rcx)
incq %rcx
jmp 0x77691
movq %rax, %rcx
subq %rdx, %rcx
subq %rax, %rdx
addq %rdx, 0x8(%rbx)
addq %rcx, 0x10(%rbx)
movq %rax, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_stdin_s_push_until_newline_or_eos
void bcore_source_stdin_s_push_until_newline_or_eos( bcore_source_stdin_s* o )
{
    for(;;)
    {
        s2_t c = fgetc( stdin );
        if( feof( stdin ) ) break;
        bcore_source_stdin_s_push_char( o, c );
        if( c == '\n' ) break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x9290c(%rip), %r14     # 0x109fd8
movq (%r14), %rdi
callq 0xd290
movl %eax, %ebp
movq (%r14), %rdi
callq 0xd380
testl %eax, %eax
jne 0x776f3
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x77634
cmpl $0xa, %ebp
jne 0x776cc
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_stdin_s_consume_whitechars_excluding_newline
void bcore_source_stdin_s_consume_whitechars_excluding_newline( bcore_source_stdin_s* o )
{
    for(;;)
    {
        if( o->buf_index < o->buf.size )
        {
            char c = o->buf.data[ o->buf_index ];
            if( c == ' ' || c == '\t' || c == '\r' )
            {
                o->buf_index++;
            }
            else
            {
                break;
            }
        }
        else
        {
            if( feof( stdin ) ) break;
            bcore_source_stdin_s_push_until_newline_or_eos( o );
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x100002200, %r14      # imm = 0x100002200
movq 0x928c7(%rip), %r15     # 0x109fd8
movq 0x10(%rbx), %rax
cmpq 0x30(%rbx), %rax
jae 0x77738
movq 0x28(%rbx), %rcx
movzbl (%rcx,%rax), %ecx
cmpq $0x20, %rcx
ja 0x7774e
btq %rcx, %r14
jae 0x7774e
incq %rax
movq %rax, 0x10(%rbx)
jmp 0x77711
movq (%r15), %rdi
callq 0xd380
testl %eax, %eax
jne 0x7774e
movq %rbx, %rdi
callq 0x776be
jmp 0x77711
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_stdin_s_parse_em_fv
er_t bcore_source_stdin_s_parse_em_fv( bcore_source_stdin_s* o, sc_t format, va_list args )
{
    if( !format ) return 0;
    if( format[ 0 ] == 0 ) return 0;
    if( format[ 0 ] == ' ' ) bcore_source_stdin_s_consume_whitechars_excluding_newline( o );
    if( o->buf_index == o->buf.size ) bcore_source_stdin_s_push_until_newline_or_eos( o );

    struct { er_t er; st_s* msg; } er_arg;
    er_arg.er = 0;
    er_arg.msg = NULL;
    sz_t index = st_s_parse_efv( &o->buf, o->buf_index, o->buf.size, stdin_s_parse_em_err, &er_arg, format, args );

    if( er_arg.er )
    {
        BLM_INIT();
        st_s* msg_main    = BLM_CREATE( st_s );
        st_s* msg_context = BLM_CREATE( st_s );
        if( er_arg.msg ) BLM_A_PUSH( er_arg.msg );

        msg_context = BLM_A_PUSH( st_s_show_line_context( &o->buf, o->buf_index ) );

        st_s_push_fa( msg_main, "error: #<sc_t>\n", er_arg.msg ? er_arg.msg->sc : "" );
        st_s_push_fa( msg_main, "#<sc_t>\n", msg_context->sc );

        bcore_error_push_sc( er_arg.er, msg_main->sc );
        BLM_DOWN();
    }
    o->buf_index = index;
    return er_arg.er;
}

// Assembly:
testq %rsi, %rsi
je 0x77874
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movzbl (%rsi), %eax
testl %eax, %eax
je 0x778ca
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x20, %eax
jne 0x7778c
movq %rbx, %rdi
callq 0x776f8
movq 0x10(%rbx), %rsi
movq 0x30(%rbx), %rdx
leaq 0x20(%rbx), %r15
cmpq %rdx, %rsi
jne 0x777ad
movq %rbx, %rdi
callq 0x776be
movq 0x10(%rbx), %rsi
movq 0x30(%rbx), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, (%r13)
movq %r12, (%rsp)
leaq 0x114(%rip), %rcx       # 0x778d9
movq %r15, %rdi
movq %r13, %r8
movq %r14, %r9
callq 0x9039a
movq %rax, %r14
cmpq $0x0, (%r13)
je 0x77877
leaq 0xa05e8(%rip), %rax     # 0x117dd0
movq (%rax), %rsi
leaq 0x28(%rsp), %r13
movq %r13, 0x20(%rsp)
movq %r13, %rdi
callq 0x717f5
xorl %eax, %eax
callq 0x8eb65
movabsq $-0x503db0e6e1c2e704, %rbp # imm = 0xAFC24F191E3D18FC
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x71917
movq %rax, %r12
xorl %eax, %eax
callq 0x8eb65
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x71917
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x77848
leaq 0x28(%rsp), %rdi
callq 0x71a4d
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x9022f
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x71a4d
movq %rax, %r15
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x7787b
movq 0x8(%rax), %rdx
jmp 0x77882
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x778c6
leaq 0x4ed4a(%rip), %rdx     # 0xc65cc
leaq 0x4e268(%rip), %rsi     # 0xc5af1
movq %r12, %rdi
xorl %eax, %eax
callq 0x8f4ef
movq 0x8(%r15), %rdx
leaq 0x5480a(%rip), %rsi     # 0xcc0a8
movq %r12, %rdi
xorl %eax, %eax
callq 0x8f4ef
movq 0x10(%rsp), %rdi
movq 0x8(%r12), %rsi
callq 0x60533
leaq 0x20(%rsp), %rdi
callq 0x71b48
movq 0x10(%rsp), %rax
movq %r14, 0x10(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/johsteffens[P]beth/lib/bcore/bcore_sources.c
// Function: bcore_source_stdin_s_parse_fv
void bcore_source_stdin_s_parse_fv( bcore_source_stdin_s* o, sc_t format, va_list args )
{
    er_t er = bcore_source_stdin_s_parse_em_fv( o, format, args );
    if( er )
    {
        bcore_error_pop_to_stderr();
        bcore_down_exit( -1, er );
    }
}

// Assembly:
pushq %rbx
callq 0x77754
testq %rax, %rax
je 0x77930
movq %rax, %rbx
callq 0x6097c
pushq $-0x1
popq %rdi
movl %ebx, %esi
popq %rbx
jmp 0x2dc10
popq %rbx
retq