LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/util.c
// Function: resolve_host_ip
int resolve_host_ip( const char* host, char* ip )
{
    struct hostent* ent;
    char* addr;
    unsigned char b1,b2,b3,b4;

     ent = gethostbyname( host );
    if( ent == NULL )
        return -1;
    addr = *ent->h_addr_list;
    if( !addr )
        return -1;
    b1 = addr[0];
    b2 = addr[1];
    b3 = addr[2];
    b4 = addr[3];

    sprintf( ip, "%d.%d.%d.%d", b1, b2, b3, b4 );
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x2190
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x58c7
movq 0x18(%rax), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x58c7
movzbl (%rax), %edx
movzbl 0x1(%rax), %ecx
movzbl 0x2(%rax), %r8d
movzbl 0x3(%rax), %r9d
leaq 0x1b11(%rip), %rsi      # 0x73cc
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2260
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/util.c
// Function: write_log
int write_log( const char* fmt, ... )
{
    FILE* f;
    time_t t;
    struct tm* tm;
    va_list  ap;
    //struct timeval tmv;

    f = fopen( log_file, "a" );
    if( f == NULL )
        return -1;
    
    t = time( 0 );
    //gettimeofday( &tmv, NULL );
    
    tm = localtime( &t );
    
    if( *fmt )
    {
        va_start( ap, fmt );
        //fprintf(f,"[%02d-%02d %02d:%02d:%02d.%03d]  ",tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,tmv.tv_usec / 1000 );
        fprintf( f, "[%02d-%02d %02d:%02d:%02d]  ", tm->tm_mon+1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec );
        vfprintf( f, fmt, ap);
        fprintf( f, "\n" );
        va_end( ap );
    }
    
    fclose( f );
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r14
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x5939
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x9880(%rip), %rdi      # 0xf1c0
leaq 0x1a91(%rip), %rsi      # 0x73d8
callq 0x2230
testq %rax, %rax
je 0x59e7
movq %rax, %r15
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x21c0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2030
cmpb $0x0, (%r14)
je 0x59dd
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r12
movq %rcx, 0x10(%r12)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%r12)
movabsq $0x3000000008, %rcx     # imm = 0x3000000008
movq %rcx, (%r12)
movl 0x10(%rax), %edx
incl %edx
movl 0xc(%rax), %ecx
movl 0x8(%rax), %r8d
movl (%rax), %esi
movl 0x4(%rax), %r9d
movl %esi, (%rsp)
leaq 0x1a20(%rip), %rsi      # 0x73da
movq %r15, %rdi
xorl %eax, %eax
callq 0x21a0
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2240
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x2150
movq %r15, %rdi
callq 0x20e0
jmp 0x59ea
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/util.c
// Function: hex2asc
int hex2asc( char* hex, int len, char* buf, int buflen )
{
    char bits[] = "0123456789abcdef";
    
    unsigned char u;
    int i;

    if( buflen < len * 2 )
        return -1;
    buf[len*2]=0;
    
    for( i = 0; i < len; i++ )
    {
        u = hex[i];
        
        buf[i*2+0] = bits[ u >> 4 ];
        buf[i*2+1] = bits[ u & 0x0f ];
    }
    
    return 0;
    
}

// Assembly:
movslq %esi, %rax
addq %rax, %rax
cmpl %ecx, %eax
jle 0x5c57
pushq $-0x1
popq %rax
retq
movb $0x0, (%rdx,%rax)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
leaq 0x18b7(%rip), %rcx      # 0x7520
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x5c56
movzbl (%rdi,%r8), %r9d
movl %r9d, %r10d
shrl $0x4, %r10d
movb (%r10,%rcx), %r10b
movb %r10b, (%rdx,%r8,2)
andl $0xf, %r9d
movb (%r9,%rcx), %r9b
movb %r9b, 0x1(%rdx,%r8,2)
incq %r8
jmp 0x5c6c
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/util.c
// Function: strlower
char *strlower( char *s )
{
    int i, len = strlen(s);
    for( i = 0; i < len; i++ ){
        s[i] = ( s[i] >= 'A' && s[i] <= 'Z' ? s[i] +32 : s[i] );
    }
    return s;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x20f0
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x5cca
movzbl (%rbx,%rcx), %edx
leal -0x41(%rdx), %esi
leal 0x20(%rdx), %edi
cmpb $0x1a, %sil
movzbl %dil, %esi
cmovael %edx, %esi
movb %sil, (%rbx,%rcx)
incq %rcx
jmp 0x5ca7
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/util.c
// Function: change_process_user
int change_process_user( char* user )
{
    struct passwd *pw;
    
    pw = getpwnam( user );
    if( !pw )
        return -1;
        
    if( setgid(pw->pw_gid ) )
        return -1;    
    
    if( setuid( pw->pw_uid ) )
        return -1;

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x2180
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x5cfe
movq %rax, %r14
movl 0x14(%rax), %edi
callq 0x2220
testl %eax, %eax
jne 0x5cfe
movl 0x10(%r14), %edi
callq 0x2280
xorl %ebx, %ebx
negl %eax
sbbl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/util.c
// Function: crypto_derive_key
int crypto_derive_key(const char *pass, unsigned char *key, int key_len)
{
    int datal;
    datal = strlen((const char *)pass);
    md5_context ctx;



    unsigned char md_buf[16];
    int addmd;
    unsigned int i, j, mds;

    mds = 16;


    for (j = 0, addmd = 0; j < key_len; addmd++) {
        md5_starts(&ctx);
        if (addmd) {
            md5_update(&ctx, md_buf, mds);
        }
        md5_update(&ctx, (unsigned char *)pass, datal);
        md5_finish(&ctx, &(md_buf[0]));

        for (i = 0; i < mds; i++, j++) {
            if (j >= key_len)
                break;
            key[j] = md_buf[i];
        }
    }


    return key_len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
callq 0x20f0
movq %rax, 0x10(%rsp)
movl %ebx, 0xc(%rsp)
movl %ebx, %ebp
xorl %r15d, %r15d
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
cmpl 0xc(%rsp), %r15d
jae 0x5dad
leaq 0x38(%rsp), %rdi
movq %r13, %rbx
movq %rdi, %r13
callq 0x2778
testl %r12d, %r12d
je 0x5d68
movq %r13, %rdi
movq %rbx, %rsi
pushq $0x10
popq %rdx
callq 0x27a3
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x27a3
movq %r13, %rdi
movq %rbx, %r13
movq %rbx, %rsi
callq 0x346a
movl %r15d, %r15d
xorl %eax, %eax
cmpq $0xf, %rax
ja 0x5da8
cmpq %rbp, %r15
jae 0x5da8
movb 0x20(%rsp,%rax), %cl
movb %cl, (%r14,%r15)
incq %rax
incq %r15
jmp 0x5d8d
incl %r12d
jmp 0x5d3e
movl 0xc(%rsp), %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/util.c
// Function: pack_update_pkg
int pack_update_pkg( char* passwd, char* buf, char* msg, int msglen )
{
    aes_context ctx;
    
    upd_pack_hdr *hdr;
    char tmp[1024];
    unsigned char aes_key[32];
    unsigned char iv[16];
    unsigned int  checksum;
    unsigned int  timestamp;
    int offset = 0;
    int left = msglen + sizeof(upd_pack_hdr);
    int proc_len;
    
    int iv_off = 0;
    
    hdr = (upd_pack_hdr*)buf;
    
    crypto_derive_key( passwd, aes_key, 32 );
    md5( (unsigned char*)passwd, strlen( passwd ), iv );
    
    timestamp = time( NULL );
    hdr->time_stamp = htonl( timestamp );
    hdr->checksum   = 0;
    hdr->rnd        = rand();

    memcpy( buf + sizeof(upd_pack_hdr), msg, msglen );
    
    checksum = crc32( 0, buf, sizeof(upd_pack_hdr) + msglen );
    hdr->checksum = htonl( checksum );
    aes_setkey_enc( &ctx, aes_key, 256 );
    
    while( left )
    {
        proc_len = left > sizeof(tmp) ? sizeof(tmp) : left;
        
        aes_crypt_cfb128( &ctx, AES_ENCRYPT, proc_len, &iv_off, iv, (unsigned char*)buf + offset, (unsigned char*)tmp );
        memcpy( buf + offset, tmp, proc_len );
        
        left -= proc_len;
        offset += proc_len;
    }
    
    
    return 0;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x678, %rsp            # imm = 0x678
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movslq %ecx, %r13
leaq 0xc(%r13), %r14
leaq 0xc(%rsp), %rax
andl $0x0, (%rax)
leaq 0x20(%rsp), %r12
pushq $0x20
popq %rdx
movq %r12, %rsi
callq 0x5d08
movq %r15, %rdi
callq 0x20f0
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %eax, %esi
callq 0x3577
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x21c0
bswapl %eax
movl %eax, 0x8(%rbx)
andl $0x0, 0x4(%rbx)
callq 0x22a0
movl %eax, (%rbx)
leaq 0xc(%rbx), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x21b0
xorl %edi, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6d24
bswapl %eax
movl %eax, 0x4(%rbx)
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x6018
leaq 0x270(%rsp), %r13
testl %r14d, %r14d
je 0x5ebf
movl $0x400, %eax            # imm = 0x400
cmpl %eax, %r14d
movl $0x400, %r12d           # imm = 0x400
cmovbl %r14d, %r12d
movl %r15d, %ebp
addq %rbx, %rbp
movq %r13, (%rsp)
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rsi
movl %r12d, %edx
leaq 0xc(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbp, %r9
callq 0x6c61
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x21b0
subl %r12d, %r14d
addl %r15d, %r12d
movl %r12d, %r15d
jmp 0x5e68
xorl %eax, %eax
addq $0x678, %rsp            # imm = 0x678
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/aes.c
// Function: aes_setkey_dec
int aes_setkey_dec( aes_context *ctx, const unsigned char *key, int keysize )
{
    int i, j;
    aes_context cty;
    unsigned long *RK;
    unsigned long *SK;
    int ret;

    switch( keysize )
    {
        case 128: ctx->nr = 10; break;
        case 192: ctx->nr = 12; break;
        case 256: ctx->nr = 14; break;
        default : return( ERR_AES_INVALID_KEY_LENGTH );
    }


    ctx->rk = RK = ctx->buf;

    ret = aes_setkey_enc( &cty, key, keysize );
    if( ret != 0 )
        return( ret );

    SK = cty.rk + cty.nr * 4;

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
    {
        for( j = 0; j < 4; j++, SK++ )
        {
            *RK++ = RT0[ FSb[ ( *SK       ) & 0xFF ] ] ^
                    RT1[ FSb[ ( *SK >>  8 ) & 0xFF ] ] ^
                    RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
                    RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
        }
    }

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    memset( &cty, 0, sizeof( aes_context ) );

    return( 0 );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
cmpl $0x80, %edx
je 0x6327
cmpl $0x100, %edx            # imm = 0x100
je 0x6323
movl $0xfffff800, %eax       # imm = 0xFFFFF800
cmpl $0xc0, %edx
jne 0x6437
pushq $0xc
jmp 0x6329
pushq $0xe
jmp 0x6329
pushq $0xa
popq %rax
movl %eax, (%rbx)
leaq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %rsp, %rdi
callq 0x6018
testl %eax, %eax
jne 0x6437
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
addq $-0x20, %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x28(%rax), %rcx
movq %rcx, 0x18(%rbx)
movq 0x30(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq 0x38(%rax), %rdx
leaq 0x30(%rbx), %rcx
movq %rdx, 0x28(%rbx)
movl (%rbx), %edx
leaq 0x122b(%rip), %rsi      # 0x75b0
leaq 0x1324(%rip), %rdi      # 0x76b0
movl $0xff, %r8d
leaq 0x1b17(%rip), %r9       # 0x7eb0
leaq 0x2310(%rip), %r10      # 0x86b0
leaq 0x2b09(%rip), %r11      # 0x8eb0
cmpl $0x2, %edx
jl 0x6417
decl %edx
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpl $0x4, %r14d
je 0x640b
movq (%rax,%r14,8), %r15
movzbl %r15b, %r12d
movzbl (%r12,%rsi), %r12d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %r8d, %r13d
movzbl (%r13,%rsi), %r13d
movq (%r9,%r13,8), %r13
xorq (%rdi,%r12,8), %r13
movl %r15d, %r12d
shrl $0x10, %r12d
andl %r8d, %r12d
movzbl (%r12,%rsi), %r12d
xorq (%r10,%r12,8), %r13
shrl $0x18, %r15d
movzbl (%r15,%rsi), %r15d
xorq (%r11,%r15,8), %r13
movq %r13, (%rcx,%r14,8)
incq %r14
addq $-0x8, %rbx
jmp 0x63b3
subq %rbx, %rcx
subq %rbx, %rax
addq $-0x40, %rax
jmp 0x63a7
movq (%rax), %rdx
movq %rdx, (%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rcx)
xorl %eax, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/aes.c
// Function: aes_crypt_cbc
int aes_crypt_cbc( aes_context *ctx,
                    int mode,
                    int length,
                    unsigned char iv[16],
                    const unsigned char *input,
                    unsigned char *output )
{
    int i;
    unsigned char temp[16];

    if( length % 16 )
        return( ERR_AES_INVALID_INPUT_LENGTH );



    if( mode == AES_DECRYPT )
    {
        while( length > 0 )
        {
            memcpy( temp, input, 16 );
            aes_crypt_ecb( ctx, mode, input, output );

            for( i = 0; i < 16; i++ )
                output[i] = (unsigned char)( output[i] ^ iv[i] );

            memcpy( iv, temp, 16 );

            input  += 16;
            output += 16;
            length -= 16;
        }
    }
    else
    {
        while( length > 0 )
        {
            for( i = 0; i < 16; i++ )
                output[i] = (unsigned char)( input[i] ^ iv[i] );

            aes_crypt_ecb( ctx, mode, output, output );
            memcpy( iv, output, 16 );

            input  += 16;
            output += 16;
            length -= 16;
        }
    }

    return( 0 );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl $0xfffff7f0, %eax       # imm = 0xFFFFF7F0
testb $0xf, %bpl
jne 0x6c52
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %r12d
movq %rdi, %r13
testl %esi, %esi
je 0x6c4c
testl %ebp, %ebp
jle 0x6c50
xorl %eax, %eax
cmpq $0x10, %rax
je 0x6be8
movb (%r15,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x6bd2
movq %r13, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x6448
movups (%rbx), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addl $-0x10, %ebp
jmp 0x6bc8
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x6448
xorl %eax, %eax
cmpq $0x10, %rax
je 0x6c39
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
jmp 0x6c27
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addl $-0x10, %ebp
testl %ebp, %ebp
jg 0x6c0d
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/aes.c
// Function: aes_crypt_cfb128
int aes_crypt_cfb128( aes_context *ctx,
                       int mode,
                       int length,
                       int *iv_off,
                       unsigned char iv[16],
                       const unsigned char *input,
                       unsigned char *output )
{
    int c, n = *iv_off;

    if( mode == AES_DECRYPT )
    {
        while( length-- )
        {
            if( n == 0 )
                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );

            c = *input++;
            *output++ = (unsigned char)( c ^ iv[n] );
            iv[n] = (unsigned char) c;

            n = (n + 1) & 0x0F;
        }
    }
    else
    {
        while( length-- )
        {
            if( n == 0 )
                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );

            iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );

            n = (n + 1) & 0x0F;
        }
    }

    *iv_off = n;

    return( 0 );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdi, 0x8(%rsp)
movq 0x50(%rsp), %rbx
movq %rcx, 0x10(%rsp)
movl (%rcx), %r13d
movl %edx, %ebp
xorl %r12d, %r12d
testl %esi, %esi
je 0x6d03
cmpl %r12d, %ebp
je 0x6d08
testl %r13d, %r13d
jne 0x6cad
movq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0x6448
movslq %r13d, %rax
movb (%r14,%r12), %cl
xorb (%r15,%rax), %cl
movb %cl, (%rbx,%r12)
movb %cl, (%r15,%rax)
incl %r13d
andl $0xf, %r13d
incq %r12
jmp 0x6c90
testl %r13d, %r13d
jne 0x6ce4
movq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0x6448
movb (%r14,%r12), %al
movslq %r13d, %rcx
movb (%r15,%rcx), %dl
xorb %al, %dl
movb %dl, (%rbx,%r12)
movb %al, (%r15,%rcx)
incl %r13d
andl $0xf, %r13d
incq %r12
cmpl %r12d, %ebp
jne 0x6ccc
movq 0x10(%rsp), %rax
movl %r13d, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/bloomsource[P]dns_update/crc32.c
// Function: crc32
uint32_t crc32(uint32_t crc, const void *buf, size_t size)
{
	const uint8_t *p;

	p = buf;
	crc = crc ^ ~0U;

	while (size--)
		crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);

	return crc ^ ~0U;
}

// Assembly:
movl %edi, %eax
notl %eax
xorl %ecx, %ecx
leaq 0x4a7f(%rip), %rdi      # 0xb7b0
cmpq %rcx, %rdx
je 0x6d4d
movb (%rsi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdi,%r8,4), %eax
incq %rcx
jmp 0x6d31
notl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/subtro.c
// Function: prv_set_prog_size
static void prv_set_prog_size(uint8_t *code, size_t bytes_written,
			      subtilis_error_t *err)
{
	if (bytes_written < 8) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	((uint32_t *)code)[1] =
	    SUBTILIS_RISCOS_ARM2_PROGRAM_START + (int32_t)bytes_written;
}

// Assembly:
cmpq $0x7, %rsi
ja 0x1266d
leaq 0x599c5(%rip), %rax     # 0x6c021
pushq $0xf
popq %rsi
pushq $0x22
popq %rcx
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x1429e
addl $0x8000, %esi           # imm = 0x8000
movl %esi, 0x4(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/stream.c
// Function: subtilis_stream_from_file
void subtilis_stream_from_file(subtilis_stream_t *s, const char *path,
			       subtilis_error_t *err)
{
	FILE *f;

	f = fopen(path, "r");
	if (!f) {
		subtilis_error_set_file_open(err, path);
		goto on_err;
	}

	strncpy(s->name, path, SUBTILIS_CONFIG_PATH_MAX);
	s->name[SUBTILIS_CONFIG_PATH_MAX] = 0;

	s->handle = f;
	s->read = prv_file_read;
	s->close = prv_file_close;

on_err:
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5ee8c(%rip), %rsi     # 0x7151c
movq %r14, %rdi
callq 0x12240
testq %rax, %rax
je 0x126e6
movq %rax, %r12
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12050
movb $0x0, 0x200(%rbx)
movq %r12, 0x208(%rbx)
leaq 0x45(%rip), %rax        # 0x1270a
movq %rax, 0x210(%rbx)
leaq 0x91(%rip), %rax        # 0x12764
movq %rax, 0x218(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5993d(%rip), %rcx     # 0x6c02a
pushq $0x2
popq %rsi
pushq $0x37
popq %r8
movq %r15, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x142e3
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/stream.c
// Function: prv_file_read
static size_t prv_file_read(void *ptr, size_t n, void *handle,
			    subtilis_error_t *err)
{
	size_t read = fread(ptr, 1, n, (FILE *)handle);

	if (ferror((FILE *)handle) && !feof((FILE *)handle))
		subtilis_error_set_file_read(err);

	return read;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rdx
pushq $0x1
popq %rsi
movq %r15, %rcx
callq 0x120a0
movq %rax, %r14
movq %r15, %rdi
callq 0x12090
testl %eax, %eax
je 0x1275b
movq %r15, %rdi
callq 0x12190
testl %eax, %eax
jne 0x1275b
leaq 0x5b680(%rip), %rdx     # 0x6ddc5
leaq 0x598de(%rip), %rcx     # 0x6c02a
pushq $0x3
popq %rsi
pushq $0x25
popq %r8
movq %rbx, %rdi
callq 0x142e3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/stream.c
// Function: subtilis_stream_from_text
void subtilis_stream_from_text(subtilis_stream_t *s, const char *text,
			       subtilis_error_t *err)
{
	subtilis_text_stream_t *stream = malloc(sizeof(*stream));

	if (!stream) {
		subtilis_error_set_oom(err);
		return;
	}
	stream->len = strlen(text);
	stream->read = 0;
	stream->text = text;
	s->handle = stream;
	s->read = prv_text_read;
	s->close = prv_text_close;
	s->name[0] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x127fb
movq %rax, %r12
movq %r14, %rdi
callq 0x120f0
movq %rax, (%r12)
andq $0x0, 0x8(%r12)
movq %r14, 0x10(%r12)
movq %r12, 0x208(%rbx)
leaq 0x44(%rip), %rax        # 0x1281b
movq %rax, 0x210(%rbx)
leaq 0x72(%rip), %rax        # 0x12857
movq %rax, 0x218(%rbx)
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x59828(%rip), %rdx     # 0x6c02a
pushq $0x1
popq %rsi
pushq $0x62
popq %rcx
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/stream.c
// Function: prv_text_read
static size_t prv_text_read(void *ptr, size_t n, void *handle,
			    subtilis_error_t *err)
{
	subtilis_text_stream_t *stream = (subtilis_text_stream_t *)handle;
	size_t left = stream->len - stream->read;

	if (left == 0)
		return 0;
	if (left < n)
		n = left;

	memcpy(ptr, &stream->text[stream->read], n);
	stream->read += n;

	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %rax
movq 0x8(%rdx), %rsi
subq %rsi, %rax
jne 0x12832
xorl %ebx, %ebx
jmp 0x1284c
movq %rdx, %r14
cmpq %rbx, %rax
cmovbq %rax, %rbx
addq 0x10(%rdx), %rsi
movq %rbx, %rdx
callq 0x121b0
addq %rbx, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_lexer_new
subtilis_lexer_t *subtilis_lexer_new(subtilis_stream_t *s, size_t buf_size,
				     const subtilis_keyword_t *basic_keywords,
				     size_t num_basic_keywords,
				     const subtilis_keyword_t *ass_keywords,
				     size_t num_ass_keywords,
				     subtilis_error_t *err)
{
	subtilis_lexer_t *l;

	l = malloc(sizeof(*l));
	if (!l) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	l->buffer = malloc(buf_size);
	if (!l->buffer) {
		free(l);
		subtilis_error_set_oom(err);
		return NULL;
	}

	l->keywords = basic_keywords;
	l->num_keywords = num_basic_keywords;
	l->basic_keywords = basic_keywords;
	l->num_basic_keywords = num_basic_keywords;
	l->ass_keywords = ass_keywords;
	l->num_ass_keywords = num_ass_keywords;
	l->buf_size = buf_size;
	l->buf_end = 0;
	l->stream = s;
	l->line = 1;
	l->character = 1;
	l->index = 0;
	l->num_blocks = 0;
	l->next = NULL;

	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
movl $0x370, %edi            # imm = 0x370
callq 0x121d0
testq %rax, %rax
je 0x128ed
movq %rax, %rbx
movq %rbp, %rdi
callq 0x121d0
movq %rax, 0x368(%rbx)
testq %rax, %rax
je 0x128fb
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %r13, 0x20(%rbx)
movq (%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rbp, 0x358(%rbx)
andq $0x0, 0x360(%rbx)
movq %r12, 0x30(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x38(%rbx)
andq $0x0, 0x350(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
jmp 0x1291c
leaq 0x59760(%rip), %rdx     # 0x6c054
pushq $0x1
popq %rsi
pushq $0x36
jmp 0x1290f
movq %rbx, %rdi
callq 0x122c0
leaq 0x5974a(%rip), %rdx     # 0x6c054
pushq $0x1
popq %rsi
pushq $0x3d
popq %rcx
movq 0x40(%rsp), %rdi
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_lexer_delete
void subtilis_lexer_delete(subtilis_lexer_t *l, subtilis_error_t *err)
{
	size_t i;

	if (l) {
		subtilis_token_delete(l->next);
		l->stream->close(l->stream->handle, err);
		free(l->buffer);

		for (i = 0; i < l->num_blocks; i++)
			subtilis_token_delete(l->blocks[i].t);

		free(l);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x12995
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x350(%rdi), %rdi
callq 0x12996
movq 0x30(%rbx), %rax
movq 0x208(%rax), %rdi
movq %r14, %rsi
callq *0x218(%rax)
movq 0x368(%rbx), %rdi
callq 0x122c0
leaq 0x58(%rbx), %r14
xorl %r15d, %r15d
cmpq 0x48(%rbx), %r15
jae 0x12988
movq (%r14), %rdi
callq 0x12996
incq %r15
addq $0x18, %r14
jmp 0x12971
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_token_delete
void subtilis_token_delete(subtilis_token_t *t)
{
	if (!t)
		return;

	if (t->type == SUBTILIS_TOKEN_IDENTIFIER)
		subtilis_type_free(&t->tok.id_type);
	else if (t->type == SUBTILIS_TOKEN_KEYWORD)
		subtilis_type_free(&t->tok.keyword.id_type);

	subtilis_buffer_free(&t->buf);
	free(t);
}

// Assembly:
testq %rdi, %rdi
je 0x129af
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x129b0
cmpl $0x1, %eax
jne 0x129bb
pushq $0x10
jmp 0x129b2
retq
pushq $0x8
popq %rdi
addq %rbx, %rdi
callq 0x2dc7c
leaq 0x158(%rbx), %rdi
callq 0x14a01
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_lexer_set_ass_keywords
void subtilis_lexer_set_ass_keywords(subtilis_lexer_t *l, bool ass,
				     subtilis_error_t *err)
{
	if (!ass) {
		l->keywords = l->basic_keywords;
		l->num_keywords = l->num_basic_keywords;
		return;
	}

	if (!l->ass_keywords) {
		subtilis_error_set_not_supported(
		    err, "Assembly language on this target is", l->stream->name,
		    l->line);
		return;
	}

	l->keywords = l->ass_keywords;
	l->num_keywords = l->num_ass_keywords;
}

// Assembly:
testl %esi, %esi
je 0x129e9
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x129f1
movq %rax, (%rdi)
movq 0x28(%rdi), %rax
movq %rax, 0x8(%rdi)
retq
movups 0x10(%rdi), %xmm0
movups %xmm0, (%rdi)
retq
pushq %rax
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x59653(%rip), %r10     # 0x6c054
leaq 0x5965b(%rip), %rax     # 0x6c063
leaq 0x5b3b6(%rip), %rcx     # 0x6ddc5
pushq $0x13
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
pushq $0x6f
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_token_get_text
const char *subtilis_token_get_text(subtilis_token_t *t)
{
	const char *tbuf;
	subtilis_error_t err;

	subtilis_error_init(&err);
	subtilis_buffer_zero_terminate(&t->buf, &err);
	if (err.type == SUBTILIS_ERROR_OK)
		tbuf = subtilis_buffer_get_string(&t->buf);
	else
		tbuf = "<TOKEN TEXT UNAVAILABLE>";
	return tbuf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x140a4
addq $0x158, %rbx            # imm = 0x158
movq %rbx, %rdi
movq %r14, %rsi
callq 0x149a8
cmpl $0x0, (%r14)
je 0x12a60
leaq 0x59629(%rip), %rax     # 0x6c087
jmp 0x12a68
movq %rbx, %rdi
callq 0x14a53
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_token_new
subtilis_token_t *subtilis_token_new(subtilis_error_t *err)
{
	subtilis_token_t *t;

	t = malloc(sizeof(*t));
	if (!t) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	t->type = SUBTILIS_TOKEN_EOF;
	memset(&t->tok, 0, sizeof(t->tok));
	subtilis_buffer_init(&t->buf, SUBTILIS_MAX_TOKEN_SIZE + 1);
	subtilis_buffer_reserve(&t->buf, SUBTILIS_MAX_TOKEN_SIZE + 1, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_buffer_free(&t->buf);
		free(t);
		t = NULL;
	}
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x168, %edi            # imm = 0x168
callq 0x121d0
testq %rax, %rax
je 0x12b17
movq %rax, %rbx
andl $0x0, (%rax)
leaq 0x8(%rax), %rdi
movl $0x150, %edx            # imm = 0x150
xorl %esi, %esi
callq 0x12140
movq %rbx, %r15
addq $0x158, %r15            # imm = 0x158
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
callq 0x146a8
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %r14, %rdx
callq 0x146b1
cmpl $0x0, (%r14)
je 0x12b30
movq %r15, %rdi
callq 0x14a01
movq %rbx, %rdi
callq 0x122c0
jmp 0x12b2e
leaq 0x59536(%rip), %rdx     # 0x6c054
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x3f6, %ecx            # imm = 0x3F6
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_token_claim
void subtilis_token_claim(subtilis_token_t *dest, subtilis_token_t *src)
{
	/*
	 * This is truly horrid.
	 */
	if (dest->type == SUBTILIS_TOKEN_IDENTIFIER)
		subtilis_type_free(&dest->tok.id_type);
	else if (dest->type == SUBTILIS_TOKEN_KEYWORD)
		subtilis_type_free(&dest->tok.keyword.id_type);
	subtilis_buffer_free(&dest->buf);
	*dest = *src;
	if (src->type == SUBTILIS_TOKEN_IDENTIFIER)
		src->tok.id_type.params.fn.ret_val = NULL;
	else if (dest->type == SUBTILIS_TOKEN_KEYWORD)
		src->tok.keyword.id_type.params.fn.ret_val = NULL;
	subtilis_buffer_init(&src->buf, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x12b53
cmpl $0x1, %eax
jne 0x12b5e
pushq $0x10
jmp 0x12b55
pushq $0x8
popq %rdi
addq %r14, %rdi
callq 0x2dc7c
leaq 0x158(%r14), %rdi
callq 0x14a01
movl $0x168, %edx            # imm = 0x168
movq %r14, %rdi
movq %rbx, %rsi
callq 0x121b0
cmpl $0x6, (%rbx)
jne 0x12b83
pushq $0x10
jmp 0x12b8b
cmpl $0x1, (%r14)
jne 0x12b91
pushq $0x18
popq %rax
andq $0x0, (%rbx,%rax)
addq $0x158, %rbx            # imm = 0x158
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x146a8
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_token_dup
subtilis_token_t *subtilis_token_dup(const subtilis_token_t *src,
				     subtilis_error_t *err)
{
	size_t buf_size;
	subtilis_token_t *t;

	t = subtilis_token_new(err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	t->type = src->type;
	t->tok = src->tok;
	buf_size = subtilis_buffer_get_size(&src->buf);
	subtilis_buffer_append(&t->buf, subtilis_buffer_get_string(&src->buf),
			       buf_size, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_token_delete(t);
		t = NULL;
	}

	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x12aab
cmpl $0x0, (%r14)
jne 0x12c23
movq %rax, %rbx
movl (%r15), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x8(%r15), %rsi
movl $0x150, %edx            # imm = 0x150
callq 0x121b0
movl $0x158, %ebp            # imm = 0x158
addq %rbp, %r15
movq %r15, %rdi
callq 0x14804
movq %rax, %r12
movq %rbx, %r13
addq %rbp, %r13
movq %r15, %rdi
callq 0x14a53
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x14795
cmpl $0x0, (%r14)
je 0x12c25
movq %rbx, %rdi
callq 0x12996
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_dump_token
void subtilis_dump_token(subtilis_token_t *t)
{
	const char *tbuf = subtilis_token_get_text(t);

	if (t->type == SUBTILIS_TOKEN_INTEGER)
		printf("[%d %" PRIu32 " %s]\n", t->type, t->tok.integer, tbuf);
	else if (t->type == SUBTILIS_TOKEN_REAL)
		printf("[%d %f %s]\n", t->type, t->tok.real, tbuf);
	else if (t->type == SUBTILIS_TOKEN_KEYWORD)
		printf("[%d %d %s]\n", t->type, t->tok.keyword.type, tbuf);
	else if (t->type == SUBTILIS_TOKEN_IDENTIFIER)
		printf("[%d %d %s]\n", t->type, t->tok.id_type.type, tbuf);
	else
		printf("[%d %s]\n", t->type, tbuf);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x12a25
movl (%rbx), %esi
leal -0x1(%rsi), %ecx
cmpl $0x5, %ecx
ja 0x12ca8
leaq 0x593eb(%rip), %rdx     # 0x6c03c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x8(%rbx), %edx
leaq 0x59454(%rip), %rdi     # 0x6c0b8
pushq $0x1
jmp 0x12c9c
movsd 0x8(%rbx), %xmm0
leaq 0x59438(%rip), %rdi     # 0x6c0ac
pushq $0x5
popq %rsi
movq %rax, %rdx
movb $0x1, %al
popq %rbx
jmp 0x12110
movl 0x8(%rbx), %edx
leaq 0x59414(%rip), %rdi     # 0x6c0a0
pushq $0x4
jmp 0x12c9c
movl 0x8(%rbx), %edx
leaq 0x5941e(%rip), %rdi     # 0x6c0b8
pushq $0x6
popq %rsi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
jmp 0x12110
leaq 0x59415(%rip), %rdi     # 0x6c0c4
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_lexer_push_block
void subtilis_lexer_push_block(subtilis_lexer_t *l, const subtilis_token_t *t,
			       subtilis_error_t *err)
{
	subtilis_token_t *t_dup;

	if (l->num_blocks == SUBTILIS_LEXER_MAX_BLOCKS) {
		subtilis_error_set_too_many_blocks(err, l->stream->name,
						   l->line);
		return;
	}

	if (l->next) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	t_dup = subtilis_token_dup(t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	l->blocks[l->num_blocks].index = l->index;
	l->blocks[l->num_blocks].t = t_dup;
	l->blocks[l->num_blocks].line = l->line;
	l->num_blocks++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x20, 0x48(%rdi)
jne 0x12cf1
movq 0x30(%rbx), %rdx
movl 0x38(%rbx), %ecx
leaq 0x5937b(%rip), %r8      # 0x6c054
pushq $0x40
popq %rsi
movq %r14, %rdi
movl $0x45f, %r9d            # imm = 0x45F
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x142c0
cmpq $0x0, 0x350(%rbx)
je 0x12d19
leaq 0x59352(%rip), %rdx     # 0x6c054
pushq $0xf
popq %rsi
movq %r14, %rdi
movl $0x464, %ecx            # imm = 0x464
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1429e
movq %rsi, %rdi
movq %r14, %rsi
callq 0x12baa
cmpl $0x0, (%r14)
jne 0x12d4e
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rdx
imulq $0x18, %rdx, %rsi
movq %rcx, 0x50(%rbx,%rsi)
movq %rax, 0x58(%rbx,%rsi)
movl 0x38(%rbx), %eax
movl %eax, 0x60(%rbx,%rsi)
incq %rdx
movq %rdx, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_lexer_set_block_start
void subtilis_lexer_set_block_start(subtilis_lexer_t *l, subtilis_error_t *err)
{
	if (l->num_blocks == 0) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (l->next) {
		subtilis_token_delete(l->next);
		l->next = NULL;
	}

	l->index = l->blocks[l->num_blocks - 1].index;
	l->line = l->blocks[l->num_blocks - 1].line;
	l->next = subtilis_token_dup(l->blocks[l->num_blocks - 1].t, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x12db8
movq %rdi, %r14
movq 0x350(%rdi), %rdi
testq %rdi, %rdi
je 0x12d86
callq 0x12996
andq $0x0, 0x350(%r14)
movq 0x48(%r14), %rax
imulq $0x18, %rax, %rax
movq 0x38(%r14,%rax), %rcx
movq %rcx, 0x40(%r14)
movl 0x48(%r14,%rax), %ecx
movl %ecx, 0x38(%r14)
movq 0x40(%r14,%rax), %rdi
movq %rbx, %rsi
callq 0x12baa
movq %rax, 0x350(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x59295(%rip), %rdx     # 0x6c054
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x475, %ecx            # imm = 0x475
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_lexer_pop_block
void subtilis_lexer_pop_block(subtilis_lexer_t *l, subtilis_error_t *err)
{
	if (l->num_blocks == 0) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	l->num_blocks--;
	subtilis_token_delete(l->blocks[l->num_blocks].t);
}

// Assembly:
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x12df5
leaq -0x1(%rax), %rcx
movq %rcx, 0x48(%rdi)
imulq $0x18, %rax, %rax
movq 0x40(%rdi,%rax), %rdi
jmp 0x12996
leaq 0x59258(%rip), %rdx     # 0x6c054
pushq $0xf
popq %rax
movq %rsi, %rdi
movl %eax, %esi
movl $0x486, %ecx            # imm = 0x486
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: prv_ensure_input
static void prv_ensure_input(subtilis_lexer_t *l, subtilis_error_t *err)
{
	size_t new_buf_size;
	char *new_buffer;

	if (l->index < l->buf_end)
		return;

	if (l->num_blocks == 0) {
		l->buf_end = l->stream->read(l->buffer, l->buf_size,
					     l->stream->handle, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		l->index = 0;
		return;
	}

	/* We can't overwrite the existing data in the buffer because we
	 * have stacked blocks.  So we're just going to have to make our
	 * buffer bigger and append to it.  This feature is currently only
	 * used by the assemblers.
	 */

	new_buf_size = l->buf_size + SUBTILIS_CONFIG_LEXER_BUF_SIZE_INC;
	new_buffer = realloc(l->buffer, new_buf_size);
	if (!new_buffer) {
		subtilis_error_set_oom(err);
		return;
	}

	l->buf_size = new_buf_size;
	l->buffer = new_buffer;
	l->buf_end += l->stream->read(&l->buffer[l->index],
				      SUBTILIS_CONFIG_LEXER_BUF_SIZE_INC,
				      l->stream->handle, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x40(%rdi), %rax
cmpq 0x360(%rdi), %rax
jb 0x13a3d
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x13a09
movl $0x2000, %r15d          # imm = 0x2000
addq 0x358(%rbx), %r15
movq 0x368(%rbx), %rdi
movq %r15, %rsi
callq 0x12210
testq %rax, %rax
je 0x13a43
movq %r15, 0x358(%rbx)
movq %rax, 0x368(%rbx)
movq 0x30(%rbx), %r8
addq 0x40(%rbx), %rax
movq 0x208(%r8), %rdx
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rdi
movq %r14, %rcx
callq *0x210(%r8)
addq %rax, 0x360(%rbx)
jmp 0x13a3d
movq 0x30(%rbx), %rax
movq 0x368(%rbx), %rdi
movq 0x358(%rbx), %rsi
movq 0x208(%rax), %rdx
movq %r14, %rcx
callq *0x210(%rax)
movq %rax, 0x360(%rbx)
cmpl $0x0, (%r14)
jne 0x13a3d
andq $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5860a(%rip), %rdx     # 0x6c054
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0xcf, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: prv_set_next_with_err
static void prv_set_next_with_err(subtilis_lexer_t *l, subtilis_token_t *t,
				  subtilis_error_t *err)
{
	char ch = l->buffer[l->index];

	subtilis_buffer_append(&t->buf, &ch, 1, err);
	if (err->type == SUBTILIS_ERROR_OK)
		l->index++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x368(%rdi), %rax
movq 0x40(%rdi), %rcx
movb (%rax,%rcx), %cl
leaq 0x7(%rsp), %rax
movb %cl, (%rax)
leaq 0x158(%rsi), %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
movq %r14, %rcx
callq 0x14795
cmpl $0x0, (%r14)
jne 0x13afd
incq 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_float
static void prv_process_float(subtilis_lexer_t *l, subtilis_token_t *t,
			      subtilis_error_t *err)
{
	const char *tbuf;

	prv_set_first(l, t, SUBTILIS_TOKEN_REAL);
	if (!prv_extract_number(l, t, prv_float_end, err))
		return;

	tbuf = subtilis_token_get_text_with_err(t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	t->tok.real = atof(tbuf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl $0x5, (%rsi)
callq 0x13a85
leaq 0x236(%rip), %rdx       # 0x13d5b
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x13b5b
testb %al, %al
je 0x13b55
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12a73
cmpl $0x0, (%r14)
jne 0x13b55
movq %rax, %rdi
callq 0x120c0
movsd %xmm0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: prv_extract_number
static bool prv_extract_number(subtilis_lexer_t *l, subtilis_token_t *t,
			       token_end_t end_fn, subtilis_error_t *err)
{
	subtilis_token_end_t end;
	bool processed = false;

	for (;;) {
		prv_ensure_input(l, err);
		if (err->type != SUBTILIS_ERROR_OK)
			break;
		if (l->index == l->buf_end) {
			processed = true;
			break;
		}
		end = end_fn(l, t, l->buffer[l->index], err);
		if (end == SUBTILIS_TOKEN_END_RETURN) {
			break;
		} else if (end == SUBTILIS_TOKEN_END_NOT_TOKEN) {
			processed = true;
			break;
		}

		prv_set_next_with_err(l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			break;
	}

	prv_check_token_buffer(l, t, err, SUBTILIS_ERROR_NUMBER_TOO_LONG);

	return processed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1398d
cmpl $0x0, (%rbx)
jne 0x13bc3
movq 0x40(%r15), %rax
movb $0x1, %bpl
cmpq 0x360(%r15), %rax
je 0x13bc5
movq 0x368(%r15), %rcx
movsbl (%rcx,%rax), %edx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq *%r12
cmpl $0x1, %eax
je 0x13bc5
cmpl $0x2, %eax
je 0x13bc3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13abf
cmpl $0x0, (%rbx)
je 0x13b6f
xorl %ebp, %ebp
pushq $0x8
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13cf0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: prv_parse_integer
static void prv_parse_integer(subtilis_lexer_t *l, subtilis_token_t *t,
			      int base, subtilis_error_t *err)
{
	char *end_ptr = 0;
	unsigned long num;
	const char *tbuf;

	tbuf = subtilis_token_get_text_with_err(t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	errno = 0;
	num = strtoul(tbuf, &end_ptr, base);
	if (*end_ptr != 0 || errno != 0) {
		subtilis_error_set_number_too_long(err, tbuf, l->stream->name,
						   l->line);
		return;
	}
	if ((base == 10 && num > 2147483647) || (num > 0xffffffff)) {
		subtilis_error_set_number_too_long(err, tbuf, l->stream->name,
						   l->line);
		return;
	}

	t->tok.integer = (int32_t)num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
andq $0x0, (%rsp)
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x12a73
cmpl $0x0, (%rbx)
je 0x13c38
addq $0x8, %rsp
jmp 0x13c93
movq %rax, %r14
callq 0x12040
movq %rax, %r13
andl $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x12250
movq %rsp, %rcx
movq (%rcx), %rcx
cmpb $0x0, (%rcx)
jne 0x13c65
cmpl $0x0, (%r13)
je 0x13c9e
movq 0x30(%r15), %r8
movl 0x38(%r15), %r9d
leaq 0x583e0(%rip), %rax     # 0x6c054
leaq 0x5a14a(%rip), %rcx     # 0x6ddc5
pushq $0x8
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
pushq $0x180                  # imm = 0x180
pushq %rax
callq 0x140cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0xa, %ebp
sete %cl
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
seta %dl
andb %cl, %dl
movq %rax, %rcx
shrq $0x20, %rcx
setne %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x13ce6
movq 0x30(%r15), %r8
movl 0x38(%r15), %r9d
leaq 0x58385(%rip), %rax     # 0x6c054
leaq 0x5a0ef(%rip), %rcx     # 0x6ddc5
pushq $0x8
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
pushq $0x185                  # imm = 0x185
jmp 0x13c89
movl %eax, 0x8(%r12)
jmp 0x13c32
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: prv_validate_identifier
static void prv_validate_identifier(subtilis_lexer_t *l, subtilis_token_t *t,
				    char ch, subtilis_error_t *err)
{
	if (ch == 0) {
		ch = prv_complete_identifier(l, t, ch, err);
		if (l->index == l->buf_end) {
			t->tok.id_type.type = SUBTILIS_TYPE_REAL;
		} else if (ch == '$') {
			t->tok.id_type.type = SUBTILIS_TYPE_STRING;
			prv_set_next_with_err(l, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		} else if (ch == '%') {
			t->tok.id_type.type = SUBTILIS_TYPE_INTEGER;
			prv_set_next_with_err(l, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		} else if (ch == '&') {
			t->tok.id_type.type = SUBTILIS_TYPE_BYTE;
			prv_set_next_with_err(l, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		} else if (ch == '@') {
			prv_set_next_with_err(l, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
			prv_complete_custom_type(l, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		} else {
			t->tok.id_type.type = SUBTILIS_TYPE_REAL;
		}
	} else {
		if (ch == '$') {
			t->tok.id_type.type = SUBTILIS_TYPE_STRING;
		} else if (ch == '%') {
			t->tok.id_type.type = SUBTILIS_TYPE_INTEGER;
		} else if (ch == '&') {
			t->tok.id_type.type = SUBTILIS_TYPE_BYTE;
		} else if (ch == '@') {
			prv_complete_custom_type(l, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		} else {
			t->tok.id_type.type = SUBTILIS_TYPE_REAL;
		}
	}

	prv_check_token_buffer(l, t, err, SUBTILIS_ERROR_IDENTIFIER_TOO_LONG);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x40, %edx
je 0x13e60
cmpl $0x24, %edx
je 0x13e02
cmpl $0x25, %edx
je 0x13e0a
cmpl $0x26, %edx
je 0x13e06
testl %edx, %edx
jne 0x13e0e
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x13e79
movq 0x40(%r15), %rdx
pushq $0x4
popq %rcx
cmpq 0x360(%r15), %rdx
je 0x13e11
cmpb $0x40, %al
je 0x13e4d
movzbl %al, %eax
cmpl $0x25, %eax
je 0x13e2b
cmpl $0x26, %eax
je 0x13e35
cmpl $0x24, %eax
jne 0x13e11
movl $0x7, 0x8(%r14)
jmp 0x13e3d
pushq $0x7
jmp 0x13e10
pushq $0x6
jmp 0x13e10
pushq $0x5
jmp 0x13e10
pushq $0x4
popq %rcx
movl %ecx, 0x8(%r14)
pushq $0x9
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x13cf0
movl $0x5, 0x8(%r14)
jmp 0x13e3d
movl $0x6, 0x8(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13abf
jmp 0x13e6e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13abf
cmpl $0x0, (%rbx)
jne 0x13e73
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13ef7
cmpl $0x0, (%rbx)
je 0x13e15
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/lexer.c
// Function: prv_complete_identifier
static char prv_complete_identifier(subtilis_lexer_t *l, subtilis_token_t *t,
				    char ch, subtilis_error_t *err)
{
	for (;;) {
		prv_ensure_input(l, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return 0;
		if (l->index == l->buf_end)
			break;

		ch = l->buffer[l->index];
		if (!((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') ||
		      (ch >= '0' && ch <= '9') || (ch == '_')))
			break;
		prv_set_next_with_err(l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return 0;
	}

	return ch;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1398d
cmpl $0x0, (%r14)
jne 0x13ee7
movq 0x40(%r12), %rax
cmpq 0x360(%r12), %rax
je 0x13ee9
movq 0x368(%r12), %rcx
movb (%rcx,%rax), %bl
movl %ebx, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x1a, %al
jb 0x13ed3
leal -0x30(%rbx), %eax
cmpb $0xa, %al
setae %al
cmpb $0x5f, %bl
setne %cl
testb %al, %cl
jne 0x13ee9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x13abf
cmpl $0x0, (%r14)
je 0x13e8c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/error.c
// Function: subtilis_error_init
void subtilis_error_init(subtilis_error_t *e)
{
	e->type = SUBTILIS_ERROR_OK;
	e->data1[0] = 0;
	e->data2[0] = 0;
	e->file[0] = 0;
	e->line = 0;
	e->subtilis_file[0] = 0;
	e->subtilis_line = 0;
}

// Assembly:
andl $0x0, (%rdi)
xorl %eax, %eax
movb %al, 0x4(%rdi)
movb %al, 0x404(%rdi)
movb %al, 0x804(%rdi)
andl $0x0, 0xa04(%rdi)
movb %al, 0xa08(%rdi)
andl $0x0, 0xc08(%rdi)
retq