LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x280e8(%rip), %rax     # 0x1598e7
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
movl $0x8, %edx
callq 0xa67c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xff5(%rip), %rsi      # 0x130830
leaq 0x1b396(%rip), %rdx     # 0x14cbc2
leaq 0x1b398(%rip), %rcx     # 0x14cbcb
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq -0xfb3(%rip), %rsi      # 0x130890
leaq 0x1b386(%rip), %rdx     # 0x14cbd0
leaq 0xd507(%rip), %rcx      # 0x13ed58
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq -0xfa1(%rip), %rsi      # 0x1308c0
leaq 0x1b376(%rip), %rdx     # 0x14cbde
leaq 0x14d3d(%rip), %rcx     # 0x1465ac
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq 0x5d1(%rip), %rsi       # 0x131e50
leaq 0x1c511(%rip), %rdx     # 0x14dd97
leaq 0x280fe(%rip), %rcx     # 0x15998b
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq 0x5f3(%rip), %rsi       # 0x131e90
leaq 0x1c4e6(%rip), %rdx     # 0x14dd8a
leaq 0x280ec(%rip), %rcx     # 0x159997
callq 0xa5930
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x280d4(%rip), %rax     # 0x1599a3
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0xa67c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xc45(%rip), %rsi      # 0x130cb0
leaq 0x1b2c6(%rip), %rdx     # 0x14cbc2
leaq 0x1b2c8(%rip), %rcx     # 0x14cbcb
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq -0xb73(%rip), %rsi      # 0x130da0
leaq 0x1b2b6(%rip), %rdx     # 0x14cbd0
leaq 0xd437(%rip), %rcx      # 0x13ed58
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq -0xb71(%rip), %rsi      # 0x130dc0
leaq 0x1b2a6(%rip), %rdx     # 0x14cbde
leaq 0x14c6d(%rip), %rcx     # 0x1465ac
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq 0x671(%rip), %rsi       # 0x131fc0
leaq 0x1c441(%rip), %rdx     # 0x14dd97
leaq 0x1013f(%rip), %rcx     # 0x141a9c
callq 0xa5930
movq -0x10(%rbp), %rdi
leaq 0x753(%rip), %rsi       # 0x1320c0
leaq 0x1c416(%rip), %rdx     # 0x14dd8a
leaq 0x1e304(%rip), %rcx     # 0x14fc7f
callq 0xa5930
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x27b1c(%rip), %rdi     # 0x159afa
callq 0xa7a50
movq %rax, -0x10(%rbp)
leaq 0x1f5bf(%rip), %rdi     # 0x1515ad
callq 0x1317d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x132230
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rax
movabsq $-0x5073d588c3beb52e, %rsi # imm = 0xAF8C2A773C414AD2
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1321d0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1320b3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x38(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x1320a3
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
imulq $0x18, -0x38(%rbp), %rax
addq %rax, %rdx
leaq -0x50(%rbp), %rdi
callq 0x132300
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x132270
jmp 0x1320a5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x13203c
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x130cf0
movq -0x40(%rbp), %rax
leaq -0x20(%rbp), %rdi
movabsq $-0x5073d588c3beb52e, %rsi # imm = 0xAF8C2A773C414AD2
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1321d0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
callq 0x1324b0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xdb2d0
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1321a0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
imulq $0x18, -0x38(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1315b0
movq -0x30(%rbp), %rax
imulq $0x18, -0x38(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x132146
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x131f70
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johsteffens[P]beth/lib/bcore/bcore_prsg.c
// Function: bcore_prsg_signal_handler
vd_t bcore_prsg_signal_handler( const bcore_signal_s* o )
{
    switch( bcore_signal_s_handle_type( o, typeof( "bcore_prsg" ) ) )
    {
        case TYPEOF_init1:
        {
        }
        break;

        case TYPEOF_selftest:
        {
            selftest();
        }
        break;

        default: break;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x11074(%rip), %rdi     # 0x1438ff
callq 0x1328e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xc7f40
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
movabsq $0x6a72ce8f8250efc6, %rcx # imm = 0x6A72CE8F8250EFC6
subq %rcx, %rax
je 0x1328c9
jmp 0x1328b4
movq -0x10(%rbp), %rax
movabsq $0x7ee758bbfced33e3, %rcx # imm = 0x7EE758BBFCED33E3
subq %rcx, %rax
je 0x1328cb
jmp 0x1328d2
jmp 0x1328d4
callq 0x132900
jmp 0x1328d4
jmp 0x1328d4
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johsteffens[P]beth/lib/bcore/bcore_prsg.c
// Function: selftest
static void selftest( void )
{
    BLM_INIT();
    bcore_prsg* prsg = ( bcore_prsg* )BLM_CREATE( bcore_prsg_lcg_u3_00_s );
    bcore_prsg_a_reseed( prsg, 1234 );

    /// same sequence should be reproducible on different platforms
    ASSERT( bcore_prsg_a_gen_u3( prsg ) ==  6370341672916135467u );
    ASSERT( bcore_prsg_a_gen_u3( prsg ) ==  9413649121373430640u );
    ASSERT( bcore_prsg_a_gen_u3( prsg ) ==  5049661203087052977u );
    ASSERT( bcore_prsg_a_gen_u3( prsg ) == 15841467423200399038u );

    BLM_DOWN();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x7fa21(%rip), %rax     # 0x1b2330
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbfe80
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, %al
callq 0x49220
movq -0x50(%rbp), %rdi
movq %rax, %rdx
movabsq $-0x1804b258fae5f3f6, %rsi # imm = 0xE7FB4DA7051A0C0A
callq 0xc00e0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movl $0x4d2, %esi            # imm = 0x4D2
callq 0x132d70
movq -0x48(%rbp), %rdi
callq 0x132db0
movabsq $0x586800000008ae2b, %rcx # imm = 0x586800000008AE2B
cmpq %rcx, %rax
je 0x1329ab
leaq 0x1016(%rip), %rdi      # 0x13399f
leaq 0x2717f(%rip), %rsi     # 0x159b0f
leaq 0x23746(%rip), %rdx     # 0x1560dd
leaq 0x271a5(%rip), %rcx     # 0x159b43
movl $0x1d, %r8d
movb $0x0, %al
callq 0x9cea0
movq -0x48(%rbp), %rdi
callq 0x132db0
movabsq $-0x7d5bfffff05e5c90, %rcx # imm = 0x82A400000FA1A370
cmpq %rcx, %rax
je 0x1329ec
leaq 0xfd5(%rip), %rdi       # 0x13399f
leaq 0x2717f(%rip), %rsi     # 0x159b50
leaq 0x23705(%rip), %rdx     # 0x1560dd
leaq 0x27164(%rip), %rcx     # 0x159b43
movl $0x1e, %r8d
movb $0x0, %al
callq 0x9cea0
movq -0x48(%rbp), %rdi
callq 0x132db0
movabsq $0x4614001c261350b1, %rcx # imm = 0x4614001C261350B1
cmpq %rcx, %rax
je 0x132a2d
leaq 0xf94(%rip), %rdi       # 0x13399f
leaq 0x27172(%rip), %rsi     # 0x159b84
leaq 0x236c4(%rip), %rdx     # 0x1560dd
leaq 0x27123(%rip), %rcx     # 0x159b43
movl $0x1f, %r8d
movb $0x0, %al
callq 0x9cea0
movq -0x48(%rbp), %rdi
callq 0x132db0
movabsq $-0x2427cd4f6f37b142, %rcx # imm = 0xDBD832B090C84EBE
cmpq %rcx, %rax
je 0x132a6e
leaq 0xf53(%rip), %rdi       # 0x13399f
leaq 0x27165(%rip), %rsi     # 0x159bb8
leaq 0x23683(%rip), %rdx     # 0x1560dd
leaq 0x270e2(%rip), %rcx     # 0x159b43
movl $0x20, %r8d
movb $0x0, %al
callq 0x9cea0
leaq -0x40(%rbp), %rdi
callq 0xc06e0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2100
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x2492
movl 0xc(%rsp), %eax
shll $0x2, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x249f
movl 0xc(%rsp), %eax
shll %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rdi
movl $0x1, %esi
callq 0x21d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x25a1
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
addl $-0x24, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x59, %eax
ja 0x2545
movq (%rsp), %rax
leaq 0xab0a(%rip), %rcx      # 0xd000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb $0x5c, (%rax)
movq 0x10(%rsp), %rax
movb (%rax), %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
jmp 0x255f
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb $0x2e, (%rax)
jmp 0x255f
movq 0x10(%rsp), %rax
movb (%rax), %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
cmpl $0x0, 0x2c(%rsp)
je 0x258e
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb $0x2e, (%rax)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb $0x3f, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x24c7
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x25ec
movl $0x0, 0x24(%rsp)
jmp 0x266c
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0xc(%rsp), %eax
jle 0x2632
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x8(%rsp), %edx
subl $0x1, %edx
movl 0xc(%rsp), %ecx
callq 0x22d0
movl %eax, 0x24(%rsp)
jmp 0x266c
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0xc(%rsp), %eax
jge 0x2664
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
addl $0x1, %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x22d0
movl %eax, 0x24(%rsp)
jmp 0x266c
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0xffffffff, -0x14(%rsp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x26de
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movslq -0x10(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x26cf
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rsp)
movl -0x10(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x26d1
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x2699
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x273e
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rsp), %eax
jne 0x272f
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2746
jmp 0x2731
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x2705
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2100
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movzbl 0x17(%rsp), %esi
movslq 0x4(%rsp), %rdx
callq 0x21b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x27b0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movslq 0x4(%rsp), %rcx
cmpq %rcx, %rax
jg 0x27b0
movl $0x1, 0x24(%rsp)
jmp 0x27b8
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2100
movl %eax, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2d61
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x2d6e
movl $0x0, 0x24(%rsp)
jmp 0x2e1d
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x2d88
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2e1d
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x2db0
imull $0xa, 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2d90
movl 0x10(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x2e15
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
subl $0x30, %eax
imull 0x10(%rsp), %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2dd0
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x324b
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x3232
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x3126
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
je 0x317a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $-0x3, (%rax)
jne 0x31cc
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq $0x0, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x30(%rax)
je 0x3220
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq $0x0, 0x30(%rax)
jmp 0x3222
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x30c4
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq (%rsp), %rax
movl 0x8(%rax), %esi
callq 0x2160
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2070
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
cmpq $0x0, 0x430(%rax)
je 0x32a9
movq (%rsp), %rax
movq 0x430(%rax), %rdi
callq 0x2070
movq (%rsp), %rax
movq $0x0, 0x430(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x418(%rax)
je 0x32d6
movq (%rsp), %rax
movq 0x418(%rax), %rdi
callq 0x2070
movq (%rsp), %rax
movq $0x0, 0x418(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x440(%rax)
je 0x3303
movq (%rsp), %rax
movq 0x440(%rax), %rdi
callq 0x2070
movq (%rsp), %rax
movq $0x0, 0x440(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x448(%rax)
je 0x3330
movq (%rsp), %rax
movq 0x448(%rax), %rdi
callq 0x2070
movq (%rsp), %rax
movq $0x0, 0x448(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x450(%rax)
je 0x335d
movq (%rsp), %rax
movq 0x450(%rax), %rdi
callq 0x2070
movq (%rsp), %rax
movq $0x0, 0x450(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x458(%rax)
je 0x337b
movq (%rsp), %rax
movq 0x458(%rax), %rdi
callq 0x22c0
movq (%rsp), %rdi
callq 0x2070
movq $0x0, (%rsp)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movslq -0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x24(%rsp)
movq -0x30(%rsp), %rax
cmpl $0x0, (%rax)
jl 0x374f
movq -0x30(%rsp), %rax
movslq (%rax), %rcx
movq 0xe8a5(%rip), %rax      # 0x11fe8
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0x3896
movq -0x30(%rsp), %rax
cmpl $-0xf, (%rax)
jl 0x37e4
movq -0x30(%rsp), %rax
cmpl $-0x5, (%rax)
jg 0x37e4
movq -0x30(%rsp), %rax
imull $-0x1, (%rax), %eax
subl $0x5, %eax
movl %eax, -0x20(%rsp)
movl $0x0, -0x18(%rsp)
movslq -0x20(%rsp), %rcx
movq 0xe84e(%rip), %rax      # 0x11fd8
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x37d7
movslq -0x20(%rsp), %rcx
movq 0xe830(%rip), %rax      # 0x11fd8
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movslq (%rax,%rcx,4), %rcx
movq 0xe829(%rip), %rax      # 0x11fe8
movl (%rax,%rcx,4), %eax
addl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x377e
movl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x3896
movq -0x30(%rsp), %rax
cmpl $-0x10, (%rax)
jne 0x382e
movl $0x0, -0x18(%rsp)
cmpl $0x100, -0x18(%rsp)     # imm = 0x100
jge 0x3824
movslq -0x18(%rsp), %rcx
movq 0xe7dc(%rip), %rax      # 0x11fe8
movl (%rax,%rcx,4), %eax
addl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x37f6
movl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x3896
movq -0x30(%rsp), %rax
cmpl $-0x3, (%rax)
jne 0x388e
movl $0x0, -0x18(%rsp)
cmpl $0x100, -0x18(%rsp)     # imm = 0x100
jge 0x3884
movq -0x30(%rsp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3875
movslq -0x18(%rsp), %rcx
movq 0xe77e(%rip), %rax      # 0x11fe8
movl (%rax,%rcx,4), %eax
addl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0x3877
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x3840
movl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x3896
movl $0x10000, -0x4(%rsp)    # imm = 0x10000
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rsp)
movq -0x18(%rsp), %rax
cvtsi2sdl 0x14(%rax), %xmm0
movsd %xmm0, -0x30(%rsp)
movsd -0x28(%rsp), %xmm0
divsd -0x30(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x4e9c
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq -0x10(%rsp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x18(%rcx), %rcx
movslq (%rcx), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $-0x4, (%rax)
jne 0x4e9c
movl $0x0, -0x4(%rsp)
jmp 0x4f4c
movq -0x18(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
imull 0x10(%rcx), %eax
movq -0x18(%rsp), %rcx
movl (%rcx), %ecx
movq -0x18(%rsp), %rdx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jl 0x4f31
movq -0x18(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
imull 0x10(%rcx), %eax
movq -0x18(%rsp), %rcx
movl (%rcx), %ecx
movq -0x18(%rsp), %rdx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jne 0x4ef8
movq -0x18(%rsp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x4f31
movq -0x18(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
imull 0x10(%rcx), %eax
movq -0x18(%rsp), %rcx
movl (%rcx), %ecx
movq -0x18(%rsp), %rdx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jne 0x4f42
movsd -0x38(%rsp), %xmm0
movsd 0xb495(%rip), %xmm1     # 0x103c0
ucomisd %xmm1, %xmm0
jb 0x4f42
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x4f4c
jmp 0x4f44
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x525f
jmp 0x53e9
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movl $0x1, (%rax,%rcx,4)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jge 0x53e9
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x53d7
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $-0x1, (%rax)
je 0x5310
movq (%rsp), %rax
cmpl $-0x2, (%rax)
jne 0x53a5
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x20(%rsp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x536f
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl $0x1, (%rax,%rcx,4)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
callq 0x2060
jmp 0x53d5
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0x53d7
jmp 0x53d9
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x527b
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x541f
jmp 0x557d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movl $0x1, (%rax,%rcx,4)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jge 0x557d
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $-0x1, (%rax)
je 0x54a6
movq (%rsp), %rax
cmpl $-0x2, (%rax)
jne 0x553b
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x20(%rsp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5505
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl $0x1, (%rax,%rcx,4)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
callq 0x2190
jmp 0x556b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0x556d
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x543b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl $0x100, %edi            # imm = 0x100
movl $0x1, %esi
callq 0x21d0
movq %rax, 0x18(%rsp)
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x21d0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x418(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x418(%rax)
movl $0x0, 0x30(%rsp)
cmpl $0x100, 0x30(%rsp)      # imm = 0x100
jge 0x5f87
movq 0x10(%rsp), %rax
movslq 0x30(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x5f5f
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x418(%rax)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x2240
movl $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x1, 0x2c(%rsp)
cmpl $0x100, 0x2c(%rsp)      # imm = 0x100
jge 0x603e
movq 0x38(%rsp), %rax
movq 0x418(%rax), %rax
movslq 0x2c(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x602f
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
movzbl %al, %esi
callq 0x2140
cmpl $0x0, %eax
jne 0x602f
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movl 0x28(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movslq 0x2c(%rsp), %rcx
movq 0xbfc4(%rip), %rax      # 0x11fe8
movl (%rax,%rcx,4), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x6031
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x5fbe
movq 0x18(%rsp), %rdi
callq 0x2070
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2070
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x418(%rax)
movl 0x28(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x621f
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x1c(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jge 0x620d
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x1c(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x18(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x20(%rax), %rsi
shlq $0x2, %rsi
callq 0x22b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x1c(%rsp), %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6154
jmp 0x620f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6121
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jondurbin[P]dre2/src/dre2_parse.c
// Function: dre2_duplicate_node
void dre2_duplicate_node( struct dre2_node **v, int *node_count, int last_node, int **minimal )
{
  dre2_add_node( v, node_count, ( *v )[last_node].c, minimal, false );
  ( *v )[*node_count - 1].group_id = ( *v )[last_node].group_id;
  if ( ( *v )[last_node].c == DRE2_CHAR_CLASS )
    memcpy( ( *v )[*node_count - 1].possible, ( *v )[last_node].possible, RANGE * sizeof( int ) );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %edx
movq 0x8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x20a0
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x3c(%rax), %ecx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x6, %rdx
addq %rdx, %rax
movl %ecx, 0x3c(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $-0x3, (%rax)
jne 0x7125
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2200
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jondurbin[P]dre2/src/dre2_parse.c
// Function: print_reverse_dre2
void print_reverse_dre2( struct dre2 *graph )
{
  printf( "=======================\n" );
  printf( "|| Node || Parents   ||\n" );
  printf( "=======================\n" );
  int i, j;
  for ( i = graph->count - 1; i >= 0; i-- )
  {
     printf( "Node %d (%c): ", i, graph->v[i].c == DRE2_GROUP_OPEN || graph->v[i].c == DRE2_GROUP_CLOSE ? 'G' : graph->v[i].c );
     for ( j = 0; j < graph->v[i].p_count; j++ )
       printf( "%d, ", graph->v[i].p[j] );
     printf( "\n" );
  }
  printf( "\n" );
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x73a8(%rip), %rdi      # 0x10498
movb $0x0, %al
callq 0x2130
leaq 0x73e4(%rip), %rdi      # 0x104e2
movb $0x0, %al
callq 0x2130
leaq 0x738c(%rip), %rdi      # 0x10498
movb $0x0, %al
callq 0x2130
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x921d
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0x9167
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $-0x2, (%rax)
jne 0x9171
movl $0x47, %eax
movl %eax, (%rsp)
jmp 0x918a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %esi
movl (%rsp), %edx
leaq 0x7332(%rip), %rdi      # 0x104ca
movb $0x0, %al
callq 0x2130
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x20(%rcx), %eax
jge 0x91ff
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x72ee(%rip), %rdi      # 0x104d9
movb $0x0, %al
callq 0x2130
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x91a7
leaq 0x72ff(%rip), %rdi      # 0x10505
movb $0x0, %al
callq 0x2130
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9122
leaq 0x72e1(%rip), %rdi      # 0x10505
movb $0x0, %al
callq 0x2130
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/jondurbin[P]dre2/src/dre2_match.c
// Function: dre2_matched_substring
void dre2_matched_substring( unsigned char *input, struct dre2_match_value *value, unsigned char **match )
{
  int size;

  if ( value->start_pos < 0 )
    value->start_pos = 0;
  size = value->end_pos - value->start_pos;
  if ( size <= 0 )
  {
    ( *match )[0] = '\0';
  } else
  {
    sprintf( *match, "%.*s", size, input + value->start_pos );
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x9f9a
movq 0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x18(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jg 0x9fc2
movq 0x10(%rsp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
jmp 0x9fed
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rcx
leaq 0x6515(%rip), %rsi      # 0x104fb
movb $0x0, %al
callq 0x2350
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jondurbin[P]dre2/src/dre2_match.c
// Function: dre2_full_match
struct dre2_match_value dre2_full_match( struct dre2 *graph, unsigned char *input, int length, int *r_temp, int *reachable, int *state )
{
  unsigned char *pch;
  struct dre2_single_match result;
  struct dre2_match_value ret_val;

  result.assertion_match = false;
  ret_val.start_pos = 0;
  ret_val.end_pos = length;
  ret_val.matched = false;
  pch = input;
  result = dre2_matcher( graph, input, pch, 0, DRE2_RIGHT, length, r_temp, reachable, state );
  if ( result.match != NULL )
  {
    if ( result.match - input == length || result.match - input == length + 1 )
      ret_val.matched = true;
    if ( result.match - input == length - 1 && ( input[length - 1] == '\n' || input[length - 1] == '\r' ) )
      ret_val.matched = true;
    if ( result.match - input == length - 2 && ( input[length - 2] == '\r' && input[length - 1] == '\n' ) )
      ret_val.matched = true;
  }
  return ret_val;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movl %edx, 0x7c(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq %r9, 0x60(%rsp)
movl $0x0, 0x40(%rsp)
movl $0x0, 0x98(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x9c(%rsp)
movl $0x0, 0x90(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x58(%rsp), %rcx
movl 0x7c(%rsp), %ebx
movq 0x70(%rsp), %r11
movq 0x68(%rsp), %r10
movq 0x60(%rsp), %rax
leaq 0x28(%rsp), %rdi
xorl %r8d, %r8d
movl $0x1, %r9d
movl %ebx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x2270
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0xb42e
movq 0x50(%rsp), %rax
movq 0x80(%rsp), %rcx
subq %rcx, %rax
movslq 0x7c(%rsp), %rcx
cmpq %rcx, %rax
je 0xb361
movq 0x50(%rsp), %rax
movq 0x80(%rsp), %rcx
subq %rcx, %rax
movl 0x7c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0xb36c
movl $0x1, 0x90(%rsp)
movq 0x50(%rsp), %rax
movq 0x80(%rsp), %rcx
subq %rcx, %rax
movl 0x7c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0xb3cc
movq 0x80(%rsp), %rax
movl 0x7c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0xb3c1
movq 0x80(%rsp), %rax
movl 0x7c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0xb3cc
movl $0x1, 0x90(%rsp)
movq 0x50(%rsp), %rax
movq 0x80(%rsp), %rcx
subq %rcx, %rax
movl 0x7c(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0xb42c
movq 0x80(%rsp), %rax
movl 0x7c(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0xb42c
movq 0x80(%rsp), %rax
movl 0x7c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xb42c
movl $0x1, 0x90(%rsp)
jmp 0xb42e
movq 0x90(%rsp), %rax
movq 0x98(%rsp), %rdx
addq $0xa0, %rsp
popq %rbx
retq
nopw (%rax,%rax)