LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_img.c
// Function: bcore_img_u2_s_pnm_to_file
const bcore_img_u2_s* bcore_img_u2_s_pnm_to_file( const bcore_img_u2_s* o, sc_t file )
{
    bcore_sink* snk = ( bcore_sink* )bcore_sink_open_file( file );
    bcore_img_u2_s_pnm_to_sink( o, snk );
    bcore_inst_a_discard( snk );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe12ed
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x129d19
testq %r14, %r14
je 0x129fa1
movq (%r14), %r15
leaq 0x7255b(%rip), %rax     # 0x19c468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x129f63
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x129f63
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x129f63
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x129f6c
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x129f93
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0x724e0(%rip), %rdi     # 0x19c468
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r12, %rdi
movq %r14, %rsi
callq *0xb8(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_img.c
// Function: bcore_img_u2_s_pnm_from_file
bcore_img_u2_s* bcore_img_u2_s_pnm_from_file( bcore_img_u2_s* o, sc_t file )
{
    bcore_source* src = ( bcore_source* )bcore_source_open_file( file );
    bcore_img_u2_s_pnm_from_source( o, src );
    bcore_inst_a_discard( src );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe7408
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x129fb0
testq %r14, %r14
je 0x12a441
movq (%r14), %r15
leaq 0x720bb(%rip), %rax     # 0x19c468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x12a403
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x12a403
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x12a403
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x12a40c
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x12a433
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0x72040(%rip), %rdi     # 0x19c468
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r12, %rdi
movq %r14, %rsi
callq *0xb8(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_sc
bcore_name_s bcore_name_sc( sc_t name )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_strcpy( NULL, name );
    o.name_space = 0;
    o.key = bcore_name_key( name );
    return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %esi
callq 0xbe802
xorl %edi, %edi
movq %r14, %rsi
callq 0xbe954
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
testq %r14, %r14
je 0x12b2db
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
movb (%r14), %cl
testb %cl, %cl
je 0x12b2e7
incq %r14
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
movzbl %cl, %esi
xorq %rdx, %rsi
imulq %rax, %rsi
movb (%r14), %cl
incq %r14
movq %rsi, %rdx
testb %cl, %cl
jne 0x12b2c2
jmp 0x12b2ea
movabsq $-0x509c42b379fe4821, %rsi # imm = 0xAF63BD4C8601B7DF
jmp 0x12b2ea
movq %rdx, %rsi
movq %rsi, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_ns_sc
bcore_name_s bcore_name_ns_sc( tp_t name_space, sc_t name )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_strcpy( NULL, name );
    o.name_space = name_space;
    o.key = bcore_name_key_ns( name_space, name );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x18, %esi
callq 0xbe802
xorl %edi, %edi
movq %r14, %rsi
callq 0xbe954
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
testq %r15, %r15
je 0x12b361
xorq $0x3a, %r15
testq %r14, %r14
je 0x12b39d
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
imulq %rcx, %r15
movb (%r14), %dl
testb %dl, %dl
je 0x12b3ab
incq %r14
movzbl %dl, %eax
xorq %r15, %rax
imulq %rcx, %rax
movb (%r14), %dl
incq %r14
movq %rax, %r15
testb %dl, %dl
jne 0x12b348
jmp 0x12b3bf
testq %r14, %r14
je 0x12b3b0
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
movb (%r14), %dl
testb %dl, %dl
je 0x12b3bc
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
incq %r14
movzbl %dl, %eax
xorq %rsi, %rax
imulq %rcx, %rax
movb (%r14), %dl
incq %r14
movq %rax, %rsi
testb %dl, %dl
jne 0x12b384
jmp 0x12b3bf
movabsq $0x366000002e329, %rax  # imm = 0x366000002E329
imulq %rax, %r15
movq %r15, %rax
jmp 0x12b3bf
movabsq $-0x509c42b379fe4821, %rax # imm = 0xAF63BD4C8601B7DF
jmp 0x12b3bf
movq %rsi, %rax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_sc_n
bcore_name_s bcore_name_sc_n( sc_t name, uz_t n )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_alloc( NULL, n + 1 );
    bcore_memcpy( o.name, name, n );
    o.name[ n ] = 0;
    o.name_space = 0;
    o.key = bcore_name_key_n( name, n );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movabsq $-0x340d631b7bdddcdb, %r12 # imm = 0xCBF29CE484222325
movl $0x18, %esi
callq 0xbe802
leaq 0x1(%r14), %rsi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xbe87d
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
movq $0x0, 0x8(%rbx)
testq %r14, %r14
je 0x12b448
xorl %eax, %eax
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
movzbl (%r15,%rax), %edx
xorq %r12, %rdx
imulq %rcx, %rdx
incq %rax
movq %rdx, %r12
cmpq %rax, %r14
jne 0x12b42f
jmp 0x12b44b
movq %r12, %rdx
movq %rdx, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_ns_sc_n
bcore_name_s bcore_name_ns_sc_n( tp_t name_space, sc_t name, uz_t n )
{
    bcore_name_s o;
    bcore_name_s_init( &o );
    o.name = bcore_alloc( NULL, n + 1 );
    bcore_memcpy( o.name, name, n );
    o.name[ n ] = 0;
    o.name_space = name_space;
    o.key = bcore_name_key_ns_n( name_space, name, n );
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x18, %esi
callq 0xbe802
leaq 0x1(%r14), %rsi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xbe87d
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
movq %r12, 0x8(%rbx)
testq %r12, %r12
je 0x12b4dc
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
xorq $0x3a, %r12
imulq %rcx, %r12
testq %r14, %r14
je 0x12b510
xorl %edx, %edx
movzbl (%r15,%rdx), %eax
xorq %r12, %rax
imulq %rcx, %rax
incq %rdx
movq %rax, %r12
cmpq %rdx, %r14
jne 0x12b4c3
jmp 0x12b518
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
testq %r14, %r14
je 0x12b515
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
xorl %edx, %edx
movzbl (%r15,%rdx), %eax
xorq %rsi, %rax
imulq %rcx, %rax
incq %rdx
movq %rax, %rsi
cmpq %rdx, %r14
jne 0x12b4f7
jmp 0x12b518
movq %r12, %rax
jmp 0x12b518
movq %rsi, %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_map_s_clear
void bcore_name_map_s_clear( bcore_name_map_s* o )
{
    if( o->data ) for( uz_t i = 0; i < o->size; i++ ) bcore_name_s_down( &o->data[ i ] );
    bcore_release( o->data );
    bcore_release( o->flags );
    o->data = 0;
    o->flags = 0;
    o->size = 0;
    o->depth_limit = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x12b5a0
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x12b5a2
movl $0x10, %r15d
xorl %r12d, %r12d
movq (%r14), %rcx
movq (%rcx,%r15), %rdi
testq %rdi, %rdi
je 0x12b58f
callq 0xbe7e9
movq 0x18(%rbx), %rax
incq %r12
addq $0x18, %r15
cmpq %rax, %r12
jb 0x12b57a
movq (%r14), %rdi
jmp 0x12b5a2
xorl %edi, %edi
callq 0xbe7e9
movq 0x10(%rbx), %rdi
callq 0xbe7e9
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_map_s_copy
void bcore_name_map_s_copy( bcore_name_map_s* o, const bcore_name_map_s* src )
{
    bcore_name_map_s_clear( o );
    o->data = bcore_alloc( NULL, sizeof( bcore_name_s ) * src->size );
    for( uz_t i = 0; i < src->size; i++ )
    {
        bcore_name_s_init( &o->data[ i ] );
        bcore_name_s_copy( &o->data[ i ], &src->data[ i ] );
    }
    o->size  = src->size;
    o->depth_limit = src->depth_limit;
    o->size_limit  = src->size_limit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x12b550
movq 0x18(%r14), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
xorl %r13d, %r13d
xorl %edi, %edi
callq 0xbe7b1
movq %rax, 0x8(%rbx)
cmpq $0x0, 0x18(%r14)
je 0x12b63c
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movl $0x18, %esi
callq 0xbe802
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq 0x8(%r14), %rsi
addq %r15, %rsi
callq 0x12b1bc
incq %r12
movq 0x18(%r14), %r13
addq $0x18, %r15
cmpq %r13, %r12
jb 0x12b608
movq %r13, 0x18(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: bcore_name_map_s_clone
BCORE_DEFINE_FUNCTION_CREATE( bcore_name_map_s )
BCORE_DEFINE_FUNCTION_CLONE( bcore_name_map_s )
BCORE_DEFINE_FUNCTION_DISCARD( bcore_name_map_s )

static uz_t find( const bcore_name_map_s* o, tp_t key ) // returns valid index or o->size
{
    if( o->size == 0 ) return o->size;
    uz_t mask = o->size - 1;
    uz_t idx = hash_tpu3_1( key ) & mask;
    if( o->data[ idx ].key == key ) return idx;
    idx = hash_tpu3_2( key ) & mask;
    if( o->data[ idx ].key == key ) return idx;
    return o->size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x12b6d6
movq %rdi, %rbx
movl $0x30, %esi
xorl %edi, %edi
callq 0xbe7b1
movq %rax, %r14
movl $0x30, %esi
movq %rax, %rdi
callq 0xbe802
movabsq $-0x5bf9bcfa7fba5085, %rax # imm = 0xA40643058045AF7B
movq %rax, (%r14)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12b5cd
jmp 0x12b6d9
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: set_rehash
uz_t set_rehash( bcore_name_map_s* o, bcore_name_s name )
{
    if( !name.key ) ERR( "key is zero" );

    // set
    {
        uz_t idx = find( o, name.key );
        if( idx < o->size )
        {
            bcore_name_s_down( &name );
            return idx;
        }
        idx = set( o, name, 1 );
        if( idx < o->size ) return idx;
    }

    // rehash
    {
        bcore_name_s* buf_data  = o->data;
        uz_t          buf_size  = o->size;
        o->flags = bcore_u_alloc( sizeof( bl_t ), o->flags, 0, NULL );
        o->depth_limit = ( o->size > 0 ) ? o->depth_limit + 1 : 4;
        o->size        = ( o->size > 0 ) ? o->size * 2        : 8;
        if( o->size > o->size_limit ) ERR( "size limit (%zu) exceeded", o->size_limit );
        o->data = bcore_u_memzero( sizeof( bcore_name_s ), NULL, o->size );
        for( uz_t i = 0; i < buf_size; i++ ) if( buf_data[ i ].key ) set_rehash( o, buf_data[ i ] );
        bcore_u_alloc( sizeof( tp_t ), buf_data, 0, NULL );
    }

    return set_rehash( o, name );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %rbp
movq (%rbp), %r14
testq %r14, %r14
jne 0x12b739
leaq 0x23926(%rip), %rdi     # 0x14f045
leaq 0x2392a(%rip), %rsi     # 0x14f050
movl $0x106, %edx            # imm = 0x106
leaq 0x19dee(%rip), %rcx     # 0x145520
xorl %eax, %eax
callq 0xbe592
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b870
cmpq 0x18(%rbx), %rax
jb 0x12b848
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movups (%rbp), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x12b95a
movq 0x18(%rbx), %r12
cmpq %r12, %rax
jb 0x12b85b
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rsi
movl $0x1, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xbe7d5
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x12b7a5
movq 0x20(%rbx), %rcx
incq %rcx
jmp 0x12b7aa
movl $0x4, %ecx
leaq (%rax,%rax), %rdx
testq %rax, %rax
movl $0x8, %eax
cmoveq %rax, %rdx
movq %rcx, 0x20(%rbx)
movq %rdx, 0x18(%rbx)
movq 0x28(%rbx), %r8
cmpq %r8, %rdx
jbe 0x12b7f0
leaq 0x23873(%rip), %rdi     # 0x14f045
leaq 0x23877(%rip), %rsi     # 0x14f050
movl $0x11b, %edx            # imm = 0x11B
leaq 0x23878(%rip), %rcx     # 0x14f05d
xorl %eax, %eax
callq 0xbe592
movq 0x18(%rbx), %rdx
movl $0x18, %edi
xorl %esi, %esi
callq 0xbe825
movq %rax, 0x8(%rbx)
movq %r15, %r13
testq %r12, %r12
je 0x12b832
cmpq $0x0, (%r13)
je 0x12b829
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x12b6f9
addq $0x18, %r13
decq %r12
jne 0x12b808
movl $0x8, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xbe7d5
jmp 0x12b713
movq %rax, %r13
movq 0x10(%rbp), %rdi
testq %rdi, %rdi
je 0x12b85e
callq 0xbe7e9
jmp 0x12b85e
movq %rax, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_s_create_self
static bcore_self_s* name_s_create_self( void )
{
    sc_t def = "\
        bcore_name_s = bcore_inst \
        { \
            tp_t key;\
            tp_t name_space;\
            private sd_t name;\
            shell st_s name_st;\
        }";
    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_name_s );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_s_init,    "bcore_fp_init",  "init"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_s_down,    "bcore_fp_down",  "down"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_s_copy,    "bcore_fp_copy",  "copy"     );
    bcore_self_s_push_ns_func( self, ( fp_t )name_s_get_name_st,   "bcore_fp_get",   "get_name_st" );
    bcore_self_s_push_ns_func( self, ( fp_t )name_s_set_name_st,   "bcore_fp_set",   "set_name_st" );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x23417(%rip), %rdi     # 0x14f077
movl $0x18, %esi
movl $0x8, %edx
callq 0xc447e
movq %rax, %rbx
leaq -0xaf5(%rip), %rsi      # 0x12b184
leaq 0x16db5(%rip), %rdx     # 0x142a35
leaq 0x16db7(%rip), %rcx     # 0x142a3e
movq %rax, %rdi
callq 0xc34ab
leaq -0xae8(%rip), %rsi      # 0x12b1ae
leaq 0x16da6(%rip), %rdx     # 0x142a43
leaq 0xb526(%rip), %rcx      # 0x1371ca
movq %rbx, %rdi
callq 0xc34ab
leaq -0xaf7(%rip), %rsi      # 0x12b1bc
leaq 0x16d97(%rip), %rdx     # 0x142a51
leaq 0x1269a(%rip), %rcx     # 0x13e35b
movq %rbx, %rdi
callq 0xc34ab
leaq 0xe8(%rip), %rsi        # 0x12bdb8
leaq 0x17ec0(%rip), %rdx     # 0x143b97
leaq 0x2343d(%rip), %rcx     # 0x14f11b
movq %rbx, %rdi
callq 0xc34ab
leaq 0xfd(%rip), %rsi        # 0x12bdea
leaq 0x17e96(%rip), %rdx     # 0x143b8a
leaq 0x2342c(%rip), %rcx     # 0x14f127
movq %rbx, %rdi
callq 0xc34ab
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_map_s_create_self
static bcore_self_s* name_map_s_create_self( void )
{
    sc_t def = "\
        bcore_name_map_s = bcore_inst \
            { \
                aware_t _; \
                private bcore_name_s* data; \
                private bl_t* flags; \
                private uz_t size; \
                private uz_t depth_limit; \
                private uz_t size_limit; \
                shell { bcore_name_s []; } data; } \
            }";
    bcore_self_s* self = BCORE_SELF_S_BUILD_PARSE_SC( def, bcore_name_map_s );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_map_s_init,    "bcore_fp_init",  "init"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_map_s_down,    "bcore_fp_down",  "down"     );
    bcore_self_s_push_ns_func( self, ( fp_t )bcore_name_map_s_copy,    "bcore_fp_copy",  "copy"     );
    bcore_self_s_push_ns_func( self, ( fp_t )name_map_s_get_data,      "bcore_fp_get",   "get_data" );
    bcore_self_s_push_ns_func( self, ( fp_t )name_map_s_set_data,      "bcore_fp_set",   "set_data" );
    return self;
}

// Assembly:
pushq %rbx
leaq 0x23423(%rip), %rdi     # 0x14f133
movl $0x30, %esi
movl $0x8, %edx
callq 0xc447e
movq %rax, %rbx
leaq -0x7ff(%rip), %rsi      # 0x12b52a
leaq 0x16d05(%rip), %rdx     # 0x142a35
leaq 0x16d07(%rip), %rcx     # 0x142a3e
movq %rax, %rdi
callq 0xc34ab
leaq -0x77e(%rip), %rsi      # 0x12b5c8
leaq 0x16cf6(%rip), %rdx     # 0x142a43
leaq 0xb476(%rip), %rcx      # 0x1371ca
movq %rbx, %rdi
callq 0xc34ab
leaq -0x796(%rip), %rsi      # 0x12b5cd
leaq 0x16ce7(%rip), %rdx     # 0x142a51
leaq 0x125ea(%rip), %rcx     # 0x13e35b
movq %rbx, %rdi
callq 0xc34ab
leaq 0x9a(%rip), %rsi        # 0x12be1a
leaq 0x17e10(%rip), %rdx     # 0x143b97
leaq 0xe008(%rip), %rcx      # 0x139d96
movq %rbx, %rdi
callq 0xc34ab
leaq 0x210(%rip), %rsi       # 0x12bfad
leaq 0x17de6(%rip), %rdx     # 0x143b8a
leaq 0x19bdc(%rip), %rcx     # 0x145987
movq %rbx, %rdi
callq 0xc34ab
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_s_set_name_st
static void name_s_set_name_st( bcore_name_s* o, sr_s sr )
{
    bcore_release( o->name );
    assert( sr_s_type( &sr ) == TYPEOF_st_s );
    o->name = bcore_strcpy( NULL, ( ( st_s* )sr.o )->sc );
    sr_down( sr );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xbe7e9
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edi, %edi
callq 0xbe954
movq %rax, 0x10(%rbx)
testb $0x2, 0x20(%rsp)
jne 0x12be14
popq %rbx
retq
popq %rbx
jmp 0x107590
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_map_s_get_data
static sr_s name_map_s_get_data( const bcore_name_map_s* o )
{
    tp_t t_data = bcore_flect_type_parse_sc( "{ bcore_name_s []; }" );
    tp_t t_node = typeof( "bcore_name_s" );
    sr_s data = sr_cp( sr_create( t_data ), TYPEOF_bcore_array_s );
    for( uz_t i = 0; i < o->size; i++ )
    {
        if( o->data[ i ].key ) bcore_array_r_push( &data, sr_twc( t_node, &o->data[ i ] ) );
    }
    return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x23455(%rip), %rdi     # 0x14f28a
callq 0xc5415
movq %rax, %r15
movq %rax, %rdi
callq 0x10743a
movq %rax, %r12
testq %r15, %r15
je 0x12be5a
movq %r15, %rdi
callq 0x1074f1
movq %rax, %rdi
jmp 0x12be5c
xorl %edi, %edi
movabsq $-0x5073d588c3beb52e, %rsi # imm = 0xAF8C2A773C414AD2
callq 0xeb464
movq %r12, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x12bf9b
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x8(%r14), %r12
cmpq $0x0, (%r12,%r15)
je 0x12bf8b
addq %r15, %r12
movabsq $-0x408553869e9adebe, %rdi # imm = 0xBF7AAC7961652142
callq 0x1074f1
movq %r12, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x8(%rbx), %r12
movq 0x8(%r12), %rbp
movabsq $-0x5073d588c3beb52e, %rax # imm = 0xAF8C2A773C414AD2
cmpq %rax, %rbp
je 0x12bf69
leaq 0x6ff3c(%rip), %rdx     # 0x19be20
movl (%rdx), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%rdx,%rax,8), %rcx
movq 0x18(%rdx,%rax,8), %rdx
andq %rbp, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
movl $0x8, %ecx
cmpq %rbp, %rdx
je 0x12bf39
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %rbp, %rdx
je 0x12bf39
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %rbp, %rdx
je 0x12bf39
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %rbp, %rdx
jne 0x12bf42
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x12bf69
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %rbp, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0x6fec2(%rip), %rdi     # 0x19be20
movq %rbp, %rsi
movq %rax, %rdx
callq 0x115fac
movq (%rbx), %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0xed355
movq 0x18(%r14), %rax
incq %r13
addq $0x18, %r15
cmpq %rax, %r13
jb 0x12be8d
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_name.c
// Function: name_map_s_set_data
static void name_map_s_set_data( bcore_name_map_s* o, sr_s data )
{
    bcore_name_map_s_clear( o );
    assert( sr_s_type( &data ) == bcore_flect_type_parse_sc( "{ bcore_name_s []; }" ) );
    data = sr_cp( data, TYPEOF_bcore_array_s );
    uz_t size = bcore_array_r_get_size( &data );
    bcore_name_s* src = bcore_array_r_get_d_data( &data );
    for( uz_t i = 0; i < size; i++ )
    {
        bcore_name_map_s_set( o, src[ i ] );
        src[ i ].name = NULL;
    }
    sr_down( data );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x70(%rsp), %rbx
movabsq $-0x5073d588c3beb52e, %r15 # imm = 0xAF8C2A773C414AD2
callq 0x12b550
movq (%rbx), %r12
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rbp
movq %r15, %rsi
callq 0xeb464
movq %rax, %r13
movq %r12, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq 0x8(%rax), %r12
cmpq %r15, %r12
je 0x12c086
leaq 0x6fe19(%rip), %rax     # 0x19be20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0x12c05d
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x12c05d
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x12c05d
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x12c066
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x12c086
movq %r15, %rdi
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0x6fda5(%rip), %rdi     # 0x19be20
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq (%rbx), %rsi
movq %r13, %rdi
callq 0xede4d
movq %rax, %r15
movq %rbx, %rdi
callq 0xf0922
testq %r15, %r15
je 0x12c0e8
movq %rax, %r12
addq $0x10, %r12
movq (%r12), %rax
movq %rax, 0x30(%rsp)
movups -0x10(%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x12b6f9
movq $0x0, (%r12)
addq $0x18, %r12
decq %r15
jne 0x12c0a8
testb $0x2, 0x10(%rbx)
je 0x12c103
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x107590
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_escaped
unsigned char *dre2_escaped( unsigned char *re, int skip_match )
{
  unsigned char *buffer, *escaped, *ptr;
  int length;

  length = strlen( re );
  if ( skip_match )
    length = length * 4 + 1;
  else
    length = length * 2 + 1;

  escaped = ( unsigned char * )calloc( length, sizeof( unsigned char ) );
  buffer = escaped;

  ptr = re;
  while ( *ptr )
  {
    switch ( *ptr )
    {
      case '^':
      case '$':
      case '(':
      case ')':
      case '\\':
      case '.':
      case '*':
      case '+':
      case '{':
      case '}':
      case '[':
      case ']':
      case '|':
        *buffer++ = '\\';
        *buffer++ = *ptr;
        break;
      case '?':
        *buffer++ = '.';
        break;
      default:
        *buffer++ = *ptr;
    }
    if ( skip_match )
    {
       *buffer++ = '.';
       *buffer++ = '?';
    }
    *ptr++;
  }
  *buffer = '\0';
  return escaped;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x2120
cmpl $0x1, %ebx
movb $0x2, %cl
sbbb $0x0, %cl
shll %cl, %eax
orl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2200
movabsq $0x70000000f, %rcx      # imm = 0x70000000F
movabsq $0x4f1000000000, %rsi   # imm = 0x4F1000000000
movq %rax, %rdx
movzbl (%r14), %edi
cmpq $0x3f, %rdi
ja 0x249b
btq %rdi, %rsi
jb 0x24ab
cmpq $0x3f, %rdi
jne 0x2496
movb $0x2e, (%rdx)
jmp 0x24ce
testq %rdi, %rdi
je 0x24d3
leal -0x5b(%rdi), %r8d
cmpl $0x22, %r8d
ja 0x24cb
btq %r8, %rcx
jae 0x24cb
movb $0x5c, (%rdx)
movb (%r14), %dil
movb %dil, 0x1(%rdx)
addq $0x2, %rdx
testl %ebx, %ebx
je 0x24c6
movw $0x3f2e, (%rdx)         # imm = 0x3F2E
addq $0x2, %rdx
incq %r14
jmp 0x247b
movb %dil, (%rdx)
incq %rdx
jmp 0x24b9
movb $0x0, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_binsearch
int dre2_binsearch( int *values, int min, int max, int key )
{
  int mid;

  if ( max < min )
    return false;
  mid = ( min + max ) / 2;
  if ( values[mid] > key )
    return dre2_binsearch( values, min, mid - 1, key );
  else if ( values[mid] < key )
    return dre2_binsearch( values, mid + 1, max, key );
  else
    return true;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, %edx
jge 0x24e5
retq
leal (%rdx,%rsi), %r9d
movl %r9d, %r8d
shrl $0x1f, %r8d
addl %r9d, %r8d
sarl %r8d
movslq %r8d, %r9
cmpl %ecx, (%rdi,%r9,4)
jle 0x250a
leal -0x1(%r8), %edx
cmpl %esi, %r8d
jg 0x24e5
jmp 0x24e4
jge 0x2517
leal 0x1(%r8), %esi
cmpl %r8d, %edx
jg 0x24e5
jmp 0x24e4
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_largest
int dre2_largest( int *values, int length )
{
  int i, largest, index;
  largest = -1;
  for ( i = 0; i < length; i++ )
  {
    if ( largest < values[i] )
    {
      largest = values[i];
      index = i;
    }
  }
  return index;
}

// Assembly:
testl %esi, %esi
jle 0x2541
movl %esi, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl (%rdi,%rsi,4), %r8d
cmpl %r8d, %edx
cmovlel %r8d, %edx
cmovll %esi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x252a
retq
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_contains_int
int dre2_contains_int( int *values, int length, int key )
{
  int i;
  for ( i = 0; i < length; i++ )
  {
    if ( values[i] == key )
      return i + 1;
  }
  return false;
}

// Assembly:
testl %esi, %esi
jle 0x2557
movl %esi, %ecx
xorl %eax, %eax
cmpl %edx, (%rdi,%rax,4)
je 0x255a
incq %rax
cmpq %rax, %rcx
jne 0x254a
xorl %eax, %eax
retq
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: string_to_int
int string_to_int( unsigned char *s )
{
  // Number of digits in the string.
  int d = strlen( s );

  // Multiplier.
  int m = 1;

  // Iterator.
  int i;

  // Check for null
  if ( !s || !*s ) {
    return 0;
  }

  // Check for infinite
  if ( s[0] == '+' )
  {
    return DRE2_INFINITE;
  }

  // Find out the max multiplier.
  for ( i = 0; i < d; i++ )
    m *= 10;
  m /= 10;

  // Convert it to an int.
  int ret = 0;
  for ( i = 0; i < d; i++ )
  {
    ret += ( s[i] - '0' ) * m;
    m /= 10;
  }
  return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2120
movq %rax, %rcx
xorl %eax, %eax
testq %rbx, %rbx
je 0x29ee
movzbl (%rbx), %edx
testl %edx, %edx
je 0x299a
cmpl $0x2b, %edx
jne 0x299e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x29ee
movl %edx, %eax
jmp 0x29ee
testl %ecx, %ecx
jle 0x29ee
movl $0x1, %edi
movl %ecx, %esi
movl %edi, %edx
leal (%rdx,%rdx), %edi
leal (%rdi,%rdi,4), %edi
decl %esi
jne 0x29a9
testl %ecx, %ecx
jle 0x29ee
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %esi, %esi
xorl %eax, %eax
movzbl (%rbx,%rsi), %edi
addl $-0x30, %edi
imull %edx, %edi
addl %edi, %eax
movslq %edx, %rdx
imulq $0x66666667, %rdx, %rdx # imm = 0x66666667
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x22, %rdx
addl %edi, %edx
incq %rsi
cmpq %rsi, %rcx
jne 0x29c3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: cleanup_nodes
void cleanup_nodes( struct dre2_node **v, int node_count )
{
  int i;
  if ( *v != NULL )
  {
    for ( i = 0; i < node_count; i++ )
    {
      if ( ( *v )[i].n != NULL )
      {
        free( ( *v )[i].n );
        ( *v )[i].n = NULL;
      }
      if ( ( *v )[i].p != NULL )
      {
        free( ( *v )[i].p );
        ( *v )[i].p = NULL;
      }
      if ( ( *v )[i].c == DRE2_CHAR_CLASS )
      {
        free( ( *v )[i].possible );
        ( *v )[i].possible = NULL;
      }
      if ( ( *v )[i].min_n != NULL )
      {
        free( ( *v )[i].min_n );
        ( *v )[i].min_n = NULL;
      }
    }
    free( *v );
    *v = NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2c72
testl %esi, %esi
jle 0x2c66
movl %esi, %r14d
shlq $0x6, %r14
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x2bfd
callq 0x2070
movq (%rbx), %rax
movq $0x0, 0x8(%rax,%r15)
movq (%rbx), %rax
movq 0x18(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x2c1b
callq 0x2070
movq (%rbx), %rax
movq $0x0, 0x18(%rax,%r15)
movq (%rbx), %rax
cmpl $-0x3, (%rax,%r15)
jne 0x2c3b
movq 0x28(%rax,%r15), %rdi
callq 0x2070
movq (%rbx), %rax
movq $0x0, 0x28(%rax,%r15)
movq (%rbx), %rax
movq 0x30(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x2c56
callq 0x2070
movq (%rbx), %rax
movq $0x0, 0x30(%rax,%r15)
addq $0x40, %r15
cmpq %r15, %r14
jne 0x2bdc
movq (%rbx), %rdi
callq 0x2070
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: cleanup_dre2
void cleanup_dre2( struct dre2 *graph )
{
  cleanup_nodes( &graph->v, graph->count );
  free( graph->v ); graph->v = NULL;
  if ( graph->starting_points != NULL ) { free( graph->starting_points ); graph->starting_points = NULL; }
  if ( graph->starting_chars != NULL ) { free( graph->starting_chars ); graph->starting_chars = NULL; }
  if ( graph->r_temp != NULL ) { free( graph->r_temp ); graph->r_temp = NULL; }
  if ( graph->reachable != NULL ) { free( graph->reachable ); graph->reachable = NULL; }
  if ( graph->state != NULL ) { free( graph->state ); graph->state = NULL; }
  if ( graph->original != NULL ) { cleanup_dre2( graph->original ); }
  free( graph );
  graph = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %esi
callq 0x2190
movq (%rbx), %rdi
callq 0x2070
movq $0x0, (%rbx)
movq 0x430(%rbx), %rdi
testq %rdi, %rdi
je 0x2caf
callq 0x2070
movq $0x0, 0x430(%rbx)
movq 0x418(%rbx), %rdi
testq %rdi, %rdi
je 0x2ccb
callq 0x2070
movq $0x0, 0x418(%rbx)
movq 0x440(%rbx), %rdi
testq %rdi, %rdi
je 0x2ce7
callq 0x2070
movq $0x0, 0x440(%rbx)
movq 0x448(%rbx), %rdi
testq %rdi, %rdi
je 0x2d03
callq 0x2070
movq $0x0, 0x448(%rbx)
movq 0x450(%rbx), %rdi
testq %rdi, %rdi
je 0x2d1f
callq 0x2070
movq $0x0, 0x450(%rbx)
movq 0x458(%rbx), %rdi
testq %rdi, %rdi
je 0x2d30
callq 0x22e0
movq %rbx, %rdi
popq %rbx
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_node_cost
int dre2_node_cost( struct dre2 *graph, int id )
{
  int i, j;
  int index;
  int cost;
  struct dre2_node *node;

  node = &graph->v[id];
  cost = 0;
  if ( node->c >= 0 )
  {
    return dre2_frequency[node->c];
  } else if ( node->c >= DRE2_8BIT && node->c <= DRE2_ALPHA )
  {
    index = node->c * -1 - 5;
    i = 0;
    while ( dre2_predefined_classes[index][i] != -1 )
    {
      cost += dre2_frequency[dre2_predefined_classes[index][i]];
      i++;
    }
    return cost;
  } else
  {
    if ( node->c == DRE2_DOT )
    {
      for ( i = 0; i < RANGE; i++ )
        cost += dre2_frequency[i];
      return cost;
    } else if ( node->c == DRE2_CHAR_CLASS )
    {
      for ( i = 0; i < RANGE; i++ )
      {
        if ( node->possible[i] )
          cost += dre2_frequency[i];
      }
      return cost;
    } else
    {
      return RANGE * RANGE;
    }
  }
}

// Assembly:
movq (%rdi), %rax
movslq %esi, %rdx
shlq $0x6, %rdx
movl (%rax,%rdx), %ecx
testl %ecx, %ecx
js 0x2f21
movq 0xb0cb(%rip), %rax      # 0xdfe8
movl (%rax,%rcx,4), %eax
retq
leal 0xf(%rcx), %esi
cmpl $0xa, %esi
ja 0x2f66
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
subq %rcx, %rax
shlq $0xa, %rax
movq 0xb09c(%rip), %rdx      # 0xdfd8
movl (%rdx,%rax), %ecx
cmpl $-0x1, %ecx
je 0x2faf
addq %rax, %rdx
addq $0x4, %rdx
xorl %eax, %eax
movq 0xb094(%rip), %rsi      # 0xdfe8
movslq %ecx, %rcx
addl (%rsi,%rcx,4), %eax
movl (%rdx), %ecx
addq $0x4, %rdx
cmpl $-0x1, %ecx
jne 0x2f54
retq
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
cmpq %rsi, %rcx
je 0x2fb2
movl $0x10000, %eax          # imm = 0x10000
cmpl $-0x10, %ecx
jne 0x2f65
pxor %xmm0, %xmm0
xorl %eax, %eax
movq 0xb061(%rip), %rcx      # 0xdfe8
paddd (%rcx,%rax,4), %xmm0
addq $0x4, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x2f87
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %eax
retq
xorl %eax, %eax
retq
addq %rdx, %rax
movq 0x28(%rax), %rax
pxor %xmm0, %xmm0
xorl %ecx, %ecx
movq 0xb022(%rip), %rdx      # 0xdfe8
pxor %xmm1, %xmm1
movdqu (%rax,%rcx,4), %xmm2
pcmpeqd %xmm0, %xmm2
pandn (%rdx,%rcx,4), %xmm2
paddd %xmm2, %xmm1
addq $0x4, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x2fca
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
paddd %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
paddd %xmm0, %xmm1
movd %xmm1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_best_choice
int dre2_best_choice( struct dre2 *graph, int *required, int count )
{
  int i, j;
  int temp;
  int *ids, *cost;
  int best;
  int literal;

  ids = ( int * )malloc( sizeof( int ) * count );
  cost = ( int * )malloc( sizeof( int ) * count );

  literal = false;
  for ( i = 0; i < count; i++ )
  {
    ids[i] = required[i];
    cost[i] = required[i] == 0 || required[i] == graph->count - 1 ? 100000 : dre2_node_cost( graph, required[i] );
    if ( graph->v[required[i]].c >= 0 )
      literal = true;
  }

  for ( i = 0; i < count - 1; i++ )
  {
    for ( j = i + 1; j < count; j++ )
    {
      if ( cost[i] > cost[j] || ( cost[i] == cost[j] && ids[i] < ids[j] ) )
      {
        temp = cost[i];
        cost[i] = cost[j];
        cost[j] = temp;
        temp = ids[i];
        ids[i] = ids[j];
        ids[j] = temp;
      }
    }
  }
  best = ids[0];

  if ( graph->options & DRE2_GREEDY && !literal && dre2_contains_int( required, count, graph->count - 2 ) )
    best = graph->count - 2;

  free( cost );
  free( ids );
  cost = NULL;
  ids = NULL;

  return best;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
movslq %edx, %r15
leaq (,%r15,4), %r14
movq %r14, %rdi
callq 0x22a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x22a0
movq %rax, %r14
xorl %r12d, %r12d
testl %r15d, %r15d
jle 0x3126
movq %r13, 0x10(%rsp)
movl %r13d, %r15d
movl $0x1, %edi
xorl %r13d, %r13d
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movslq (%rsi,%r13,4), %rbp
movl %ebp, (%rbx,%r13,4)
movl $0x186a0, %eax          # imm = 0x186A0
testq %rbp, %rbp
je 0x3094
movl 0x8(%rdx), %ecx
decl %ecx
cmpl %ecx, %ebp
je 0x3094
movq (%rsp), %rdi
movl %ebp, %esi
callq 0x2030
movl $0x1, %edi
movq (%rsp), %rdx
movq 0x8(%rsp), %rsi
movl %eax, (%r14,%r13,4)
movq (%rdx), %rax
shlq $0x6, %rbp
cmpl $0x0, (%rax,%rbp)
cmovnsl %edi, %r12d
incq %r13
cmpq %r13, %r15
jne 0x3060
testl %r12d, %r12d
setne %r12b
movq 0x10(%rsp), %r13
cmpl $0x1, %r13d
je 0x312f
leal -0x1(%r13), %eax
xorl %esi, %esi
movq %r14, %rcx
movq %rbx, %rdx
movq %rsi, %rdi
incq %rsi
movl $0x1, %r8d
movl (%r14,%rdi,4), %r9d
movl (%rcx,%r8,4), %r10d
cmpl %r10d, %r9d
jle 0x30ff
movl (%rbx,%rdi,4), %r11d
movl (%rdx,%r8,4), %ebp
movl %r10d, (%r14,%rdi,4)
movl %r9d, (%rcx,%r8,4)
movl %ebp, (%rbx,%rdi,4)
movl %r11d, (%rdx,%r8,4)
jmp 0x310e
jne 0x310e
movl (%rbx,%rdi,4), %r11d
movl (%rdx,%r8,4), %ebp
cmpl %ebp, %r11d
jl 0x30ee
incq %r8
cmpq %r8, %r15
jne 0x30d9
addq $0x4, %rdx
addq $0x4, %rcx
decq %r15
cmpq %rax, %rsi
jne 0x30cd
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl (%rbx), %ebp
testb $0x1, 0x43c(%rdx)
je 0x3160
testb %r12b, %r12b
jne 0x3160
testl %r13d, %r13d
jle 0x3160
movl 0x8(%rdx), %eax
addl $-0x2, %eax
movl %r13d, %ecx
xorl %edx, %edx
cmpl %eax, (%rsi,%rdx,4)
je 0x315e
incq %rdx
cmpq %rdx, %rcx
jne 0x314f
jmp 0x3160
movl %eax, %ebp
movq %r14, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2070
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_first_or_last
int dre2_first_or_last( struct dre2 *graph, struct dre2_fl_cost *cost )
{
  int i, j;
  double first, last, diff;

  first = ( double )cost->f_frequency;
  last = ( double )cost->l_frequency;
  diff = first / last;

  if ( cost->l_n_count == 1 && graph->v[graph->v[graph->count - 1].p[0]].c == DRE2_EOF )
  {
    return 0;
  } else {
    if ( cost->l_n_count * cost->l_c_count < cost->f_n_count * cost->f_c_count ||
       ( cost->l_n_count * cost->l_c_count == cost->f_n_count * cost->f_c_count && cost->l_frequency < cost->f_frequency ) ||
       ( cost->l_n_count * cost->l_c_count == cost->f_n_count * cost->f_c_count && diff >= 0.9 ) )
       return graph->count - 1;
  }
  return 0;
}

// Assembly:
movl 0x8(%rsi), %ecx
movl 0xc(%rsi), %r8d
movl 0x14(%rsi), %edx
cmpl $0x1, %r8d
jne 0x3b37
movq (%rdi), %r9
movslq 0x8(%rdi), %rax
shlq $0x6, %rax
movq -0x28(%r9,%rax), %rax
movslq (%rax), %r10
shlq $0x6, %r10
xorl %eax, %eax
cmpl $-0x4, (%r9,%r10)
je 0x3b70
imull 0x10(%rsi), %r8d
movl 0x4(%rsi), %r9d
imull (%rsi), %r9d
cmpl %r9d, %r8d
jge 0x3b4f
movl 0x8(%rdi), %eax
decl %eax
retq
xorl %eax, %eax
cmpl %r9d, %r8d
jne 0x3b70
cmpl %ecx, %edx
jl 0x3b49
cvtsi2sd %ecx, %xmm0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
ucomisd 0x75e2(%rip), %xmm0     # 0xb150
jae 0x3b49
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_min_reachable
void dre2_min_reachable( struct dre2 *graph, int **reachable, int **visited, int id )
{
  if ( ( *visited )[id] == true )
    return;
  ( *visited )[id] = true;

  int i;
  for ( i = 0; i < graph->v[id].n_count; i++ )
  {
    if ( id < graph->v[id].n[i] )
    {
      struct dre2_node *neighbor = &graph->v[graph->v[id].n[i]];
      if ( neighbor->c == DRE2_GROUP_OPEN || neighbor->c == DRE2_GROUP_CLOSE )
      {
        if ( graph->v[id].n[i] == graph->count - 1 )
          ( *reachable )[graph->v[id].n[i]] = true;
        dre2_min_reachable( graph, reachable, visited, graph->v[id].n[i] );
      } else
      {
        ( *reachable )[graph->v[id].n[i]] = true;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
movslq %ecx, %r13
cmpl $0x1, (%rax,%r13,4)
je 0x3d93
movq %rdi, %r12
movl $0x1, (%rax,%r13,4)
movq (%rdi), %rax
shlq $0x6, %r13
cmpl $0x0, 0x10(%rax,%r13)
jle 0x3d93
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
movq 0x8(%rax,%r13), %rdx
movl (%rdx,%rbp,4), %ecx
cmpl %ebx, %ecx
jle 0x3d86
movslq %ecx, %rsi
movq %rsi, %rdi
shlq $0x6, %rdi
cmpl $-0x2, (%rax,%rdi)
jb 0x3d7c
movl 0x8(%r12), %eax
decl %eax
cmpl %eax, %ecx
jne 0x3d68
movq (%r15), %rax
movl $0x1, (%rax,%rsi,4)
movl (%rdx,%rbp,4), %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2060
movq (%r12), %rax
jmp 0x3d86
movq (%r15), %rcx
movl $0x1, (%rcx,%rsi,4)
incq %rbp
movslq 0x10(%rax,%r13), %rcx
cmpq %rcx, %rbp
jl 0x3d34
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_reachable
void dre2_reachable( struct dre2 *graph, int **reachable, int **visited, int id )
{
  if ( ( *visited )[id] == true )
    return;
  ( *visited )[id] = true;

  int i;
  for ( i = 0; i < graph->v[id].n_count; i++ )
  {
    struct dre2_node *neighbor = &graph->v[graph->v[id].n[i]];

    // If it's a group node, check neighbors.
    if ( neighbor->c == DRE2_GROUP_OPEN || neighbor->c == DRE2_GROUP_CLOSE )
    {
      if ( graph->v[id].n[i] == graph->count - 1 )
        ( *reachable )[graph->v[id].n[i]] = true;
      dre2_reachable( graph, reachable, visited, graph->v[id].n[i] );
    } else
    {
      ( *reachable )[graph->v[id].n[i]] = true;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdx), %rax
movslq %ecx, %r12
cmpl $0x1, (%rax,%r12,4)
je 0x3e36
movq %rdi, %r15
movl $0x1, (%rax,%r12,4)
movq (%rdi), %rax
shlq $0x6, %r12
cmpl $0x0, 0x10(%rax,%r12)
jle 0x3e36
movq %rdx, %rbx
movq %rsi, %r14
xorl %r13d, %r13d
movq 0x8(%rax,%r12), %rdx
movl (%rdx,%r13,4), %ecx
movslq %ecx, %rsi
movq %rsi, %rdi
shlq $0x6, %rdi
cmpl $-0x2, (%rax,%rdi)
jb 0x3e1f
movl 0x8(%r15), %eax
decl %eax
cmpl %eax, %ecx
jne 0x3e0c
movq (%r14), %rax
movl $0x1, (%rax,%rsi,4)
movl (%rdx,%r13,4), %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21c0
movq (%r15), %rax
jmp 0x3e29
movq (%r14), %rcx
movl $0x1, (%rcx,%rsi,4)
incq %r13
movslq 0x10(%rax,%r12), %rcx
cmpq %rcx, %r13
jl 0x3ddb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_add_node
void dre2_add_node( struct dre2_node **v, int *node_count, int c, int **minimal, int no_realloc )
{
  // Initialize the node count and vertex array if necessary.
  if ( ! *node_count )
  {
    *node_count = 1;
    if ( !no_realloc )
      *v = ( struct dre2_node * )malloc( sizeof( struct dre2_node ) );
  } else
  {
    // Increment node count and allocate additional memory.
    *node_count = *node_count + 1;
    if ( !no_realloc )
      *v = ( struct dre2_node * )realloc( *v, sizeof( struct dre2_node ) * *node_count );
  }

  // Set this node's data.
  ( *v )[*node_count - 1].c = c;

  // Initialize neighbor array and count.
  ( *v )[*node_count - 1].n = ( int * )malloc( sizeof( int ) );
  ( *v )[*node_count - 1].n_count = 0;

  // Initalize the parent array and count.
  ( *v )[*node_count - 1].p = ( int * )malloc( sizeof( int ) );
  ( *v )[*node_count - 1].p_count = 0;

  // Allocate some memory for character class possible lookup list.
  if ( c == DRE2_CHAR_CLASS )
    ( *v )[*node_count - 1].possible = ( int * )calloc( RANGE, sizeof( int ) );

  // Initialize min_n to NULL.
  ( *v )[*node_count - 1].min_n = NULL;

  dre2_add_minimal( minimal, node_count );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rsi
testq %rsi, %rsi
je 0x428d
incq %rsi
movl %esi, (%r14)
movq (%r15), %r12
testl %r8d, %r8d
jne 0x42b3
shlq $0x6, %rsi
movq %r12, %rdi
callq 0x22d0
movq %rax, %r12
movq %rax, (%r15)
movl (%r14), %esi
jmp 0x42b3
movl $0x1, (%r14)
testl %r8d, %r8d
je 0x429e
movq (%r15), %r12
jmp 0x42ae
movl $0x40, %edi
callq 0x22a0
movq %rax, %r12
movq %rax, (%r15)
movl $0x1, %esi
movslq %esi, %rax
shlq $0x6, %rax
movl %ebp, -0x40(%r12,%rax)
movl $0x4, %edi
callq 0x22a0
movslq (%r14), %rcx
shlq $0x6, %rcx
movq %rax, -0x38(%r12,%rcx)
movq (%r15), %r12
xorl %ebx, %ebx
movl %ebx, -0x30(%r12,%rcx)
movl $0x4, %edi
callq 0x22a0
movslq (%r14), %rcx
shlq $0x6, %rcx
movq %rax, -0x28(%r12,%rcx)
movq (%r15), %r13
movl %ebx, -0x20(%r13,%rcx)
movslq (%r14), %r12
cmpl $-0x3, %ebp
jne 0x4323
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x2200
movq %r12, %rcx
shlq $0x6, %rcx
movq %rax, -0x18(%r13,%rcx)
movq (%r15), %r13
movq %r12, %rax
shlq $0x6, %rax
movq $0x0, -0x10(%r13,%rax)
movq (%rsp), %rbx
movq (%rbx), %rdi
shlq $0x2, %r12
movq %r12, %rsi
callq 0x22d0
movq %rax, (%rbx)
movslq (%r14), %rcx
movl $0x1, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_single_cost
struct dre2_cost dre2_single_cost( struct dre2 *graph, int id )
{
  int i, j;
  int c_count, frequency;
  unsigned char *temp;
  int *tp, *original;
  struct dre2_cost cost;

  temp = ( unsigned char * )calloc( RANGE, sizeof( unsigned char ) );
  tp = ( int * )calloc( RANGE, sizeof( int ) );

  original = graph->starting_chars;
  graph->starting_chars = tp;

  for ( i = 0; i < RANGE; i++ )
    tp[i] = false;
  graph->starting_chars = tp;

  dre2_set_chars( graph, id );

  c_count = 0;
  frequency = 0;
  for ( j = 1; j < RANGE; j++ )
  {
    if ( graph->starting_chars[j] && !dre2_contains_char( temp, j ) )
    {
      c_count++;
      temp[c_count - 1] = j;
      frequency += dre2_frequency[j];
    }
  }
  free( temp ); temp = NULL;
  free( tp ); tp = NULL;
  graph->starting_chars = original;
  cost.c_count = c_count;
  cost.frequency = frequency;
  return cost;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %r12d
movl $0x100, %edi            # imm = 0x100
movl $0x1, %esi
callq 0x2200
movq %rax, %r14
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x2200
movq %rax, %rcx
movq 0x418(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rcx, 0x418(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2260
movq %rbx, 0x10(%rsp)
movq 0x418(%rbx), %r15
xorl %ebp, %ebp
movq 0x9bbf(%rip), %rbx      # 0xdfe8
xorl %r13d, %r13d
cmpl $0x0, (%r15,%r12,4)
je 0x4451
movzbl %r12b, %esi
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
jne 0x4451
movslq %r13d, %rax
incl %r13d
movb %r12b, (%r14,%rax)
addl (%rbx,%r12,4), %ebp
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x442c
movq %r14, %rdi
callq 0x2070
movq (%rsp), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x418(%rax)
shlq $0x20, %rbp
movl %r13d, %eax
orq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_add_parents
void dre2_add_parents( struct dre2 *graph )
{
  int i, j;
  for ( i = 0; i < graph->count; i++ )
  {
    struct dre2_node *node = &graph->v[i];
    for ( j = 0; j < graph->v[i].n_count; j++ )
    {
      struct dre2_node *neighbor = &graph->v[graph->v[i].n[j]];
      neighbor->p_count++;
      neighbor->p = ( int * )realloc( neighbor->p, sizeof( int ) * neighbor->p_count );
      neighbor->p[neighbor->p_count - 1] = i;
    }
  }
}

// Assembly:
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x456e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
xorl %r14d, %r14d
movq %r14, %r12
shlq $0x6, %r12
cmpl $0x0, 0x10(%r15,%r12)
jle 0x4555
xorl %r13d, %r13d
movq 0x8(%r15,%r12), %rax
movslq (%rax,%r13,4), %rbp
shlq $0x6, %rbp
movslq 0x20(%r15,%rbp), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x20(%r15,%rbp)
movq 0x18(%r15,%rbp), %rdi
leaq 0x4(,%rax,4), %rsi
callq 0x22d0
movq %rax, 0x18(%r15,%rbp)
movslq 0x20(%r15,%rbp), %rcx
movl %r14d, -0x4(%rax,%rcx,4)
incq %r13
movq (%rbx), %r15
movslq 0x10(%r15,%r12), %rax
cmpq %rax, %r13
jl 0x4506
movl 0x8(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x44f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq