LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xf1717
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1354e8
testq %r14, %r14
je 0x13598b
movq (%r14), %r15
leaq 0x73b71(%rip), %rax     # 0x1a9468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x13594d
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x13594d
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x13594d
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x13599a
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x13597d
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x73af6(%rip), %rdi     # 0x1a9468
movq %r15, %rsi
movq %rax, %rdx
callq 0x12128c
movq %r12, %rdi
movq %r14, %rsi
callq *0xb8(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0x135951
// File: /workspace/github_c_makefile_star2_O1/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 0xc8366
xorl %edi, %edi
movq %r14, %rsi
callq 0xc84c8
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
testq %r14, %r14
je 0x136833
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
movb (%r14), %cl
testb %cl, %cl
je 0x13683f
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 0x13681a
jmp 0x136842
movabsq $-0x509c42b379fe4821, %rsi # imm = 0xAF63BD4C8601B7DF
jmp 0x136842
movq %rdx, %rsi
movq %rsi, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0xc8366
xorl %edi, %edi
movq %r14, %rsi
callq 0xc84c8
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
testq %r15, %r15
je 0x1368b9
xorq $0x3a, %r15
testq %r14, %r14
je 0x1368f5
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
imulq %rcx, %r15
movb (%r14), %dl
testb %dl, %dl
je 0x136903
incq %r14
movzbl %dl, %eax
xorq %r15, %rax
imulq %rcx, %rax
movb (%r14), %dl
incq %r14
movq %rax, %r15
testb %dl, %dl
jne 0x1368a0
jmp 0x136917
testq %r14, %r14
je 0x136908
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
movb (%r14), %dl
testb %dl, %dl
je 0x136914
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 0x1368dc
jmp 0x136917
movabsq $0x366000002e329, %rax  # imm = 0x366000002E329
imulq %rax, %r15
movq %r15, %rax
jmp 0x136917
movabsq $-0x509c42b379fe4821, %rax # imm = 0xAF63BD4C8601B7DF
jmp 0x136917
movq %rsi, %rax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc8366
leaq 0x1(%r14), %rsi
xorl %edi, %edi
callq 0xc8315
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc83f1
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
movq $0x0, 0x8(%rbx)
testq %r14, %r14
je 0x1369a0
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 0x136987
jmp 0x1369a3
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_O1/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 0xc8366
leaq 0x1(%r14), %rsi
xorl %edi, %edi
callq 0xc8315
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc83f1
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
movq %r12, 0x8(%rbx)
testq %r12, %r12
je 0x136a34
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
xorq $0x3a, %r12
imulq %rcx, %r12
testq %r14, %r14
je 0x136a68
xorl %edx, %edx
movzbl (%r15,%rdx), %eax
xorq %r12, %rax
imulq %rcx, %rax
incq %rdx
movq %rax, %r12
cmpq %rdx, %r14
jne 0x136a1b
jmp 0x136a70
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
testq %r14, %r14
je 0x136a6d
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 0x136a4f
jmp 0x136a70
movq %r12, %rax
jmp 0x136a70
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_O1/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
cmpq $0x0, 0x8(%rdi)
je 0x136aec
cmpq $0x0, 0x18(%rbx)
je 0x136aec
movl $0x10, %r15d
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0x136adf
callq 0xc834d
incq %r12
addq $0x18, %r15
cmpq 0x18(%rbx), %r12
jb 0x136ace
movq 0x8(%rbx), %rdi
callq 0xc834d
movq 0x10(%rbx), %rdi
callq 0xc834d
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_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x136aa8
movq 0x18(%r14), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
xorl %edi, %edi
callq 0xc8315
movq %rax, 0x8(%rbx)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x136b88
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movl $0x18, %esi
callq 0xc8366
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq 0x8(%r14), %rsi
addq %r15, %rsi
callq 0x136714
incq %r12
movq 0x18(%r14), %rax
addq $0x18, %r15
cmpq %rax, %r12
jb 0x136b54
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0x136c2b
movq %rdi, %rbx
movl $0x30, %esi
xorl %edi, %edi
callq 0xc8315
movq %rax, %r14
movl $0x30, %esi
movq %rax, %rdi
callq 0xc8366
movabsq $-0x5bf9bcfa7fba5085, %rax # imm = 0xA40643058045AF7B
movq %rax, (%r14)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x136b1b
jmp 0x136c2e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x38, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r12
movl $0x8, %r13d
movq (%r12), %rbp
testq %rbp, %rbp
jne 0x136c94
leaq 0x2336b(%rip), %rdi     # 0x159fe5
leaq 0x2336f(%rip), %rsi     # 0x159ff0
movl $0x106, %edx            # imm = 0x106
leaq 0x1986d(%rip), %rcx     # 0x1504fa
xorl %eax, %eax
callq 0xc80f6
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x136de0
cmpq 0x18(%rbx), %rax
jae 0x136cbb
movq %rax, %rbp
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x136cb7
callq 0xc834d
xorl %eax, %eax
jmp 0x136ce5
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x136eca
movq %rax, %rbp
cmpq 0x18(%rbx), %rax
setae %al
testb %al, %al
je 0x136dce
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %r14
movl $0x1, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc8339
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x136d1d
movq 0x20(%rbx), %rcx
incq %rcx
jmp 0x136d22
movl $0x4, %ecx
leaq (%rax,%rax), %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rcx, 0x20(%rbx)
movq %rdx, 0x18(%rbx)
movq 0x28(%rbx), %r8
cmpq %r8, %rdx
jbe 0x136d5f
leaq 0x232a0(%rip), %rdi     # 0x159fe5
leaq 0x232a4(%rip), %rsi     # 0x159ff0
movl $0x11b, %edx            # imm = 0x11B
leaq 0x232a5(%rip), %rcx     # 0x159ffd
xorl %eax, %eax
callq 0xc80f6
movq 0x18(%rbx), %rdx
movl $0x18, %edi
xorl %esi, %esi
callq 0xc8389
movq %rax, 0x8(%rbx)
movq %r15, %rbp
testq %r14, %r14
je 0x136da4
cmpq $0x0, (%rbp)
je 0x136d9b
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movups (%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x136c4e
addq $0x18, %rbp
decq %r14
jne 0x136d7b
movl $0x8, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc8339
movq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
jmp 0x136c6a
movq %rbp, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/johsteffens[P]beth/lib/bcore/bcore_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 0x22e44(%rip), %rdi     # 0x15a017
movl $0x18, %esi
movl $0x8, %edx
callq 0xce5c6
movq %rax, %rbx
leaq -0xb10(%rip), %rsi      # 0x1366dc
leaq 0x16802(%rip), %rdx     # 0x14d9f5
leaq 0x16804(%rip), %rcx     # 0x14d9fe
movq %rax, %rdi
callq 0xcd5ad
leaq -0xb03(%rip), %rsi      # 0x136706
leaq 0x167f3(%rip), %rdx     # 0x14da03
leaq 0xafb3(%rip), %rcx      # 0x1421ca
movq %rbx, %rdi
callq 0xcd5ad
leaq -0xb12(%rip), %rsi      # 0x136714
leaq 0x167e4(%rip), %rdx     # 0x14da11
leaq 0x122af(%rip), %rcx     # 0x1494e3
movq %rbx, %rdi
callq 0xcd5ad
leaq 0xe8(%rip), %rsi        # 0x13732b
leaq 0x1790d(%rip), %rdx     # 0x14eb57
leaq 0x22e6a(%rip), %rcx     # 0x15a0bb
movq %rbx, %rdi
callq 0xcd5ad
leaq 0xfd(%rip), %rsi        # 0x13735d
leaq 0x178e3(%rip), %rdx     # 0x14eb4a
leaq 0x22e59(%rip), %rcx     # 0x15a0c7
movq %rbx, %rdi
callq 0xcd5ad
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22e50(%rip), %rdi     # 0x15a0d3
movl $0x30, %esi
movl $0x8, %edx
callq 0xce5c6
movq %rax, %rbx
leaq -0x81a(%rip), %rsi      # 0x136a82
leaq 0x16752(%rip), %rdx     # 0x14d9f5
leaq 0x16754(%rip), %rcx     # 0x14d9fe
movq %rax, %rdi
callq 0xcd5ad
leaq -0x7a3(%rip), %rsi      # 0x136b16
leaq 0x16743(%rip), %rdx     # 0x14da03
leaq 0xaf03(%rip), %rcx      # 0x1421ca
movq %rbx, %rdi
callq 0xcd5ad
leaq -0x7bb(%rip), %rsi      # 0x136b1b
leaq 0x16734(%rip), %rdx     # 0x14da11
leaq 0x121ff(%rip), %rcx     # 0x1494e3
movq %rbx, %rdi
callq 0xcd5ad
leaq 0x9a(%rip), %rsi        # 0x13738d
leaq 0x1785d(%rip), %rdx     # 0x14eb57
leaq 0xdc1d(%rip), %rcx      # 0x144f1e
movq %rbx, %rdi
callq 0xcd5ad
leaq 0x212(%rip), %rsi       # 0x137522
leaq 0x17833(%rip), %rdx     # 0x14eb4a
leaq 0x19643(%rip), %rcx     # 0x150961
movq %rbx, %rdi
callq 0xcd5ad
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc834d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edi, %edi
callq 0xc84c8
movq %rax, 0x10(%rbx)
testb $0x2, 0x20(%rsp)
jne 0x137387
popq %rbx
retq
popq %rbx
jmp 0x112485
// File: /workspace/github_c_makefile_star2_O1/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 0x22e82(%rip), %rdi     # 0x15a22a
callq 0xcf594
movq %rax, %r15
movq %rax, %rdi
callq 0x112326
movq %rax, %r12
testq %r15, %r15
je 0x1373cd
movq %r15, %rdi
callq 0x1123e1
movq %rax, %rdi
jmp 0x1373cf
xorl %edi, %edi
movabsq $-0x5073d588c3beb52e, %rsi # imm = 0xAF8C2A773C414AD2
callq 0xf58f8
movq %r12, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
cmpq $0x0, 0x18(%r14)
je 0x137510
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x8(%r14), %r12
cmpq $0x0, (%r12,%r15)
je 0x1374f8
addq %r15, %r12
movabsq $-0x408553869e9adebe, %rdi # imm = 0xBF7AAC7961652142
callq 0x1123e1
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 0x1374da
leaq 0x719cb(%rip), %rdx     # 0x1a8e20
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 0x1374aa
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %rbp, %rdx
je 0x1374aa
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %rbp, %rdx
je 0x1374aa
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %rbp, %rdx
jne 0x13750b
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x1374da
movabsq $-0x5073d588c3beb52e, %rdi # imm = 0xAF8C2A773C414AD2
movq %rbp, %rsi
callq 0xf3f85
movq %rax, %r12
leaq 0x71951(%rip), %rdi     # 0x1a8e20
movq %rbp, %rsi
movq %rax, %rdx
callq 0x12128c
movq (%rbx), %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0xf7857
incq %r13
addq $0x18, %r15
cmpq 0x18(%r14), %r13
jb 0x1373fe
jmp 0x137510
xorl %r12d, %r12d
jmp 0x1374ae
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_O1/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 0x136aa8
movq (%rbx), %r12
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rbp
movq %r15, %rsi
callq 0xf58f8
movq %rax, %r13
movq %r12, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq 0x8(%rax), %r12
cmpq %r15, %r12
je 0x1375ff
leaq 0x718a4(%rip), %rax     # 0x1a8e20
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0x1375d6
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x1375d6
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x1375d6
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x13768b
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x1375ff
movq %r15, %rdi
movq %r12, %rsi
callq 0xf3f85
movq %rax, %r13
leaq 0x7182c(%rip), %rdi     # 0x1a8e20
movq %r12, %rsi
movq %rax, %rdx
callq 0x12128c
movq (%rbx), %rsi
movq %r13, %rdi
callq 0xf837b
movq %rax, %r15
movq %rbx, %rdi
callq 0xfae8b
testq %r15, %r15
je 0x137661
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 0x136c4e
movq $0x0, (%r12)
addq $0x18, %r12
decq %r15
jne 0x137621
testb $0x2, 0x10(%rbx)
je 0x13767c
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x112485
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
jmp 0x1375da
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x24ab
btq %rdi, %rsi
jb 0x24bb
cmpq $0x3f, %rdi
jne 0x24a6
movb $0x2e, (%rdx)
jmp 0x24de
testq %rdi, %rdi
je 0x24e3
leal -0x5b(%rdi), %r8d
cmpl $0x22, %r8d
ja 0x24db
btq %r8, %rcx
jae 0x24db
movb $0x5c, (%rdx)
movb (%r14), %dil
movb %dil, 0x1(%rdx)
addq $0x2, %rdx
testl %ebx, %ebx
je 0x24d6
movw $0x3f2e, (%rdx)         # imm = 0x3F2E
addq $0x2, %rdx
incq %r14
jmp 0x248b
movb %dil, (%rdx)
incq %rdx
jmp 0x24c9
movb $0x0, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl %esi, %edx
jl 0x2518
leal (%rdx,%rsi), %r8d
movl %r8d, %eax
shrl $0x1f, %eax
addl %r8d, %eax
sarl %eax
movslq %eax, %r8
cmpl %ecx, (%rdi,%r8,4)
jle 0x2510
decl %eax
movl %eax, %edx
jmp 0x24ee
jge 0x251b
incl %eax
movl %eax, %esi
jmp 0x24ee
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2545
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 0x252e
retq
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x255b
movl %esi, %ecx
xorl %eax, %eax
cmpl %edx, (%rdi,%rax,4)
je 0x255e
incq %rax
cmpq %rax, %rcx
jne 0x254e
xorl %eax, %eax
retq
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_contains_char
int dre2_contains_char( unsigned char *string, unsigned char c )
{
  unsigned char *pch;
  int length;

  length = strlen( string );
  pch = ( unsigned char * )memchr( string, c, length );
  if ( pch != NULL && pch - string <= length )
    return true;
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x2120
movslq %eax, %r15
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x21e0
testq %rax, %rax
setne %cl
subq %r14, %rax
cmpq %r15, %rax
setle %al
andb %cl, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rbx, %rbx
je 0x29df
movzbl (%rbx), %ecx
testl %ecx, %ecx
je 0x2a39
cmpl $0x2b, %ecx
jne 0x29e3
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x2a39
xorl %ecx, %ecx
jmp 0x2a39
xorl %ecx, %ecx
movl $0x0, %edx
testl %eax, %eax
jle 0x2a01
movl $0x1, %edi
movl %eax, %esi
movl %edi, %edx
leal (%rdx,%rdx), %edi
leal (%rdi,%rdi,4), %edi
decl %esi
jne 0x29f5
testl %eax, %eax
jle 0x2a39
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
xorl %ecx, %ecx
movzbl (%rbx,%rsi), %edi
addl $-0x30, %edi
imull %edx, %edi
addl %edi, %ecx
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, %rax
jne 0x2a0e
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, (%rdi)
je 0x2cd2
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x2cbe
movl %esi, %r14d
shlq $0x6, %r14
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x2c55
callq 0x2070
movq (%rbx), %rax
movq $0x0, 0x8(%rax,%r15)
movq (%rbx), %rax
movq 0x18(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x2c73
callq 0x2070
movq (%rbx), %rax
movq $0x0, 0x18(%rax,%r15)
movq (%rbx), %rax
cmpl $-0x3, (%rax,%r15)
jne 0x2c93
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 0x2cb1
callq 0x2070
movq (%rbx), %rax
movq $0x0, 0x30(%rax,%r15)
addq $0x40, %r15
cmpq %r15, %r14
jne 0x2c37
movq (%rbx), %rdi
callq 0x2070
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d0a
callq 0x2070
movq $0x0, 0x430(%rbx)
movq 0x418(%rbx), %rdi
testq %rdi, %rdi
je 0x2d26
callq 0x2070
movq $0x0, 0x418(%rbx)
movq 0x440(%rbx), %rdi
testq %rdi, %rdi
je 0x2d42
callq 0x2070
movq $0x0, 0x440(%rbx)
movq 0x448(%rbx), %rdi
testq %rdi, %rdi
je 0x2d5e
callq 0x2070
movq $0x0, 0x448(%rbx)
movq 0x450(%rbx), %rdi
testq %rdi, %rdi
je 0x2d7a
callq 0x2070
movq $0x0, 0x450(%rbx)
movq 0x458(%rbx), %rdi
testq %rdi, %rdi
je 0x2d8b
callq 0x22e0
movq %rbx, %rdi
popq %rbx
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O1/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
movslq (%rax,%rdx), %rcx
testq %rcx, %rcx
js 0x2f88
movq 0xb064(%rip), %rax      # 0xdfe8
movl (%rax,%rcx,4), %eax
retq
leal 0xf(%rcx), %esi
cmpl $0xa, %esi
ja 0x2fcc
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
subl %ecx, %eax
shlq $0xa, %rax
movq 0xb036(%rip), %rdx      # 0xdfd8
movl (%rdx,%rax), %ecx
cmpl $-0x1, %ecx
je 0x3010
addq %rax, %rdx
addq $0x4, %rdx
xorl %eax, %eax
movq 0xb02e(%rip), %rsi      # 0xdfe8
movslq %ecx, %rcx
addl (%rsi,%rcx,4), %eax
movl (%rdx), %ecx
addq $0x4, %rdx
cmpl $-0x1, %ecx
jne 0x2fba
retq
cmpl $-0x3, %ecx
je 0x3013
movl $0x10000, %eax          # imm = 0x10000
cmpl $-0x10, %ecx
jne 0x2fcb
pxor %xmm0, %xmm0
xorl %eax, %eax
movq 0xb000(%rip), %rcx      # 0xdfe8
paddd (%rcx,%rax,4), %xmm0
addq $0x4, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x2fe8
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 0xafc1(%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 0x302b
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_O1/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 0x3118
movq %r13, 0x10(%rsp)
movl %r13d, %r15d
movl $0x1, %edi
xorl %r13d, %r13d
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movslq (%rdx,%r13,4), %rbp
movl %ebp, (%rbx,%r13,4)
movl $0x186a0, %eax          # imm = 0x186A0
testq %rbp, %rbp
je 0x30f1
movl 0x8(%rsi), %ecx
decl %ecx
cmpl %ecx, %ebp
je 0x30f1
movq (%rsp), %rdi
movl %ebp, %esi
callq 0x2030
movl $0x1, %edi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movl %eax, (%r14,%r13,4)
movq (%rsi), %rax
shlq $0x6, %rbp
cmpl $0x0, (%rax,%rbp)
cmovnsl %edi, %r12d
incq %r13
cmpq %r13, %r15
jne 0x30bd
testl %r12d, %r12d
setne %r12b
movq 0x10(%rsp), %r13
cmpl $0x2, %r13d
jl 0x3184
leal -0x1(%r13), %eax
movl %r13d, %ecx
xorl %edi, %edi
movq %r14, %rdx
movq %rbx, %rsi
movq %rdi, %r8
incq %rdi
movl $0x1, %r9d
movl (%r14,%r8,4), %r10d
movl (%rdx,%r9,4), %r11d
cmpl %r11d, %r10d
jle 0x3160
movl %r11d, (%r14,%r8,4)
movl %r10d, (%rdx,%r9,4)
movl (%rbx,%r8,4), %r10d
movl (%rsi,%r9,4), %r11d
movl %r11d, (%rbx,%r8,4)
movl %r10d, (%rsi,%r9,4)
jmp 0x316c
jne 0x316c
movl (%rbx,%r8,4), %ebp
cmpl (%rsi,%r9,4), %ebp
jl 0x3146
incq %r9
cmpq %r9, %rcx
jne 0x3139
addq $0x4, %rsi
addq $0x4, %rdx
decq %rcx
cmpq %rax, %rdi
jne 0x312d
movq (%rsp), %rcx
testb $0x1, 0x43c(%rcx)
movl (%rbx), %ebp
sete %al
orb %r12b, %al
testb $0x1, %al
jne 0x31c1
testl %r13d, %r13d
jle 0x31c1
movl 0x8(%rcx), %eax
addl $-0x2, %eax
movl %r13d, %ecx
xorl %edx, %edx
movq 0x8(%rsp), %rsi
cmpl %eax, (%rsi,%rdx,4)
je 0x31bf
incq %rdx
cmpq %rdx, %rcx
jne 0x31b0
jmp 0x31c1
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_O1/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), %edx
movl 0xc(%rsi), %ecx
movl 0x14(%rsi), %r8d
cmpl $0x1, %ecx
jne 0x3bba
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 0x3bfb
imull 0x10(%rsi), %ecx
movl 0x4(%rsi), %r9d
imull (%rsi), %r9d
cmpl %r9d, %ecx
jl 0x3bf6
cvtsi2sd %edx, %xmm0
cvtsi2sd %r8d, %xmm1
divsd %xmm1, %xmm0
cmpl %edx, %r8d
setl %dl
ucomisd 0x756a(%rip), %xmm0     # 0xb150
setae %sil
xorl %eax, %eax
cmpl %r9d, %ecx
jne 0x3bfb
orb %sil, %dl
je 0x3bfb
movl 0x8(%rdi), %eax
decl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e3f
movq %rdi, %r12
movl $0x1, (%rax,%r13,4)
movq (%rdi), %rax
shlq $0x6, %r13
cmpl $0x0, 0x10(%rax,%r13)
jle 0x3e3f
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
movq 0x8(%rax,%r13), %rcx
movslq (%rcx,%rbp,4), %rcx
cmpl %ebx, %ecx
jle 0x3e2e
movq %rcx, %rdx
shlq $0x6, %rdx
cmpl $-0x2, (%rax,%rdx)
jb 0x3e24
movq 0x8(%rax,%r13), %rax
movslq (%rax,%rbp,4), %rcx
movl 0x8(%r12), %edx
decl %edx
cmpl %edx, %ecx
jne 0x3e11
movq (%r15), %rdx
movl $0x1, (%rdx,%rcx,4)
movl (%rax,%rbp,4), %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2060
jmp 0x3e2e
movq (%r15), %rax
movl $0x1, (%rax,%rcx,4)
incq %rbp
movq (%r12), %rax
movslq 0x10(%rax,%r13), %rcx
cmpq %rcx, %rbp
jl 0x3dd9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3eec
movq %rdi, %r15
movl $0x1, (%rax,%r12,4)
movq (%rdi), %rax
shlq $0x6, %r12
cmpl $0x0, 0x10(%rax,%r12)
jle 0x3eec
movq %rdx, %rbx
movq %rsi, %r14
xorl %r13d, %r13d
movq 0x8(%rax,%r12), %rcx
movslq (%rcx,%r13,4), %rcx
movq %rcx, %rdx
shlq $0x6, %rdx
cmpl $-0x2, (%rax,%rdx)
jb 0x3ed2
movq 0x8(%rax,%r12), %rax
movslq (%rax,%r13,4), %rcx
movl 0x8(%r15), %edx
decl %edx
cmpl %edx, %ecx
jne 0x3ebe
movq (%r14), %rdx
movl $0x1, (%rdx,%rcx,4)
movl (%rax,%r13,4), %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21c0
jmp 0x3edc
movq (%r14), %rax
movl $0x1, (%rax,%rcx,4)
incq %r13
movq (%r15), %rax
movslq 0x10(%rax,%r12), %rcx
cmpq %rcx, %r13
jl 0x3e8b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rsi
testq %rsi, %rsi
je 0x42fa
incq %rsi
movl %esi, (%r14)
testl %r8d, %r8d
jne 0x4313
movq (%r15), %rdi
shlq $0x6, %rsi
callq 0x22d0
jmp 0x4310
movl $0x1, (%r14)
testl %r8d, %r8d
jne 0x4313
movl $0x40, %edi
callq 0x22a0
movq %rax, (%r15)
movq (%r15), %r12
movslq (%r14), %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 %r13d, %r13d
movl %r13d, -0x30(%r12,%rcx)
movl $0x4, %edi
callq 0x22a0
movslq (%r14), %rcx
shlq $0x6, %rcx
movq %rax, -0x28(%r12,%rcx)
movq (%r15), %r12
movl %r13d, -0x20(%r12,%rcx)
cmpl $-0x3, %ebp
jne 0x4381
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x2200
movslq (%r14), %rcx
shlq $0x6, %rcx
movq %rax, -0x18(%r12,%rcx)
movq (%r15), %rax
movslq (%r14), %rsi
movq %rsi, %rcx
shlq $0x6, %rcx
movq $0x0, -0x10(%rax,%rcx)
movq (%rbx), %rdi
shlq $0x2, %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_O1/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, %r15
movq 0x418(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r15, 0x418(%rbx)
xorl %r13d, %r13d
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x2180
movq %r15, 0x8(%rsp)
movq %r15, 0x418(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2260
movq 0x418(%rbx), %r15
xorl %ebp, %ebp
cmpl $0x0, (%r15,%r12,4)
je 0x44be
movzbl %r12b, %esi
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
jne 0x44be
movslq %ebp, %rax
incl %ebp
movb %r12b, (%r14,%rax)
movq 0x9b2e(%rip), %rax      # 0xdfe8
addl (%rax,%r12,4), %r13d
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x4493
movq %r14, %rdi
callq 0x2070
movq 0x8(%rsp), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
movq %rax, 0x418(%rbx)
shlq $0x20, %r13
movl %ebp, %eax
orq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x8(%rdi)
jle 0x45d3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %r12
movq %r14, %r15
shlq $0x6, %r15
cmpl $0x0, 0x10(%r12,%r15)
jle 0x45b9
xorl %r13d, %r13d
movq 0x8(%r12,%r15), %rax
movslq (%rax,%r13,4), %rbp
shlq $0x6, %rbp
movslq 0x20(%r12,%rbp), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x20(%r12,%rbp)
movq 0x18(%r12,%rbp), %rdi
leaq 0x4(,%rax,4), %rsi
callq 0x22d0
movq %rax, 0x18(%r12,%rbp)
movslq 0x20(%r12,%rbp), %rcx
movl %r14d, -0x4(%rax,%rcx,4)
incq %r13
movq (%rbx), %r12
movslq 0x10(%r12,%r15), %rax
cmpq %rax, %r13
jl 0x456d
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x4558
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq