LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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), %r13
movq %rcx, 0x10(%rsp)
movl (%rcx), %ebp
testl %esi, %esi
je 0x758d
testl %edx, %edx
je 0x75d2
movl %edx, %ebx
xorl %r12d, %r12d
testl %ebp, %ebp
jne 0x756a
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r15, %rcx
callq 0x6c68
movslq %ebp, %rax
movb (%r14,%r12), %cl
xorb (%r15,%rax), %cl
movb %cl, (%r13,%r12)
movb %cl, (%r15,%rax)
incl %ebp
andl $0xf, %ebp
incq %r12
cmpl %r12d, %ebx
jne 0x7551
jmp 0x75d2
testl %edx, %edx
je 0x75d2
movl %edx, %ebx
xorl %r12d, %r12d
testl %ebp, %ebp
jne 0x75af
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r15, %rcx
callq 0x6c68
movb (%r14,%r12), %al
movslq %ebp, %rcx
movb (%r15,%rcx), %dl
xorb %al, %dl
movb %dl, (%r13,%r12)
movb %al, (%r15,%rcx)
incl %ebp
andl $0xf, %ebp
incq %r12
cmpl %r12d, %ebx
jne 0x7596
movq 0x10(%rsp), %rax
movl %ebp, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdx, %rdx
je 0x761a
notl %eax
xorl %ecx, %ecx
leaq 0x5192(%rip), %rdi      # 0xc790
movb (%rsi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdi,%r8,4), %eax
incq %rcx
cmpq %rcx, %rdx
jne 0x75fe
notl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x126d9
leaq 0x5f95d(%rip), %rax     # 0x72021
movq %rdx, %rdi
movl $0xf, %esi
movq %rax, %rdx
movl $0x22, %ecx
jmp 0x145f4
addl $0x8000, %esi           # imm = 0x8000
movl %esi, 0x4(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x64e4c(%rip), %rsi     # 0x77548
movq %r14, %rdi
callq 0x12240
testq %rax, %rax
je 0x12752
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 0x49(%rip), %rax        # 0x1277a
movq %rax, 0x210(%rbx)
leaq 0x9b(%rip), %rax        # 0x127da
movq %rax, 0x218(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5f8d1(%rip), %rcx     # 0x7202a
movq %r15, %rdi
movl $0x2, %esi
movq %r14, %rdx
movl $0x37, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1463d
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
movq %r15, %rcx
callq 0x120a0
movq %rax, %r14
movq %r15, %rdi
callq 0x12090
testl %eax, %eax
je 0x127d1
movq %r15, %rdi
callq 0x12190
testl %eax, %eax
jne 0x127d1
leaq 0x6163e(%rip), %rdx     # 0x73df5
leaq 0x5f86c(%rip), %rcx     # 0x7202a
movq %rbx, %rdi
movl $0x3, %esi
movl $0x25, %r8d
callq 0x1463d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x12877
movq %rax, %r15
movq %r14, %rdi
callq 0x120f0
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %r15, 0x208(%rbx)
leaq 0x48(%rip), %rax        # 0x1289b
movq %rax, 0x210(%rbx)
leaq 0x76(%rip), %rax        # 0x128d7
movq %rax, 0x218(%rbx)
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5f7ac(%rip), %rdx     # 0x7202a
movq %r12, %rdi
movl $0x1, %esi
movl $0x62, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x128b2
xorl %ebx, %ebx
jmp 0x128cc
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_O1/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
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, 0x10(%rsp)
movq 0x50(%rsp), %r15
movl $0x370, %edi            # imm = 0x370
callq 0x121d0
testq %rax, %rax
je 0x1297e
movq %rax, %rbx
movq %rbp, %rdi
callq 0x121d0
movq %rax, 0x368(%rbx)
testq %rax, %rax
je 0x12994
movq %r14, (%rbx)
movq %r12, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %r12, 0x18(%rbx)
movq %r13, 0x20(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rbp, 0x358(%rbx)
xorl %eax, %eax
movq %rax, 0x360(%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rbx)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x38(%rbx)
movq %rax, 0x350(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
jmp 0x129b9
leaq 0x5f6cf(%rip), %rdx     # 0x72054
movq %r15, %rdi
movl $0x1, %esi
movl $0x36, %ecx
jmp 0x129b2
movq %rbx, %rdi
callq 0x122c0
leaq 0x5f6b1(%rip), %rdx     # 0x72054
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x3d, %ecx
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12a37
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x350(%rdi), %rdi
callq 0x12a38
movq 0x30(%rbx), %rax
movq 0x208(%rax), %rdi
movq %r14, %rsi
callq *0x218(%rax)
movq 0x368(%rbx), %rdi
callq 0x122c0
cmpq $0x0, 0x48(%rbx)
je 0x12a2a
leaq 0x58(%rbx), %r14
xorl %r15d, %r15d
movq (%r14), %rdi
callq 0x12a38
incq %r15
addq $0x18, %r14
cmpq 0x48(%rbx), %r15
jb 0x12a15
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12a54
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x12a55
cmpl $0x1, %eax
jne 0x12a62
movl $0x10, %edi
jmp 0x12a5a
retq
movl $0x8, %edi
addq %rbx, %rdi
callq 0x2f843
leaq 0x158(%rbx), %rdi
callq 0x14da6
movq %rbx, %rdi
popq %rbx
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O1/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 0x12a90
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x12a98
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 0x5f5ac(%rip), %r10     # 0x72054
leaq 0x5f5b4(%rip), %rax     # 0x72063
leaq 0x6133f(%rip), %rcx     # 0x73df5
movq %rdx, %rdi
movl $0x13, %esi
movq %rax, %rdx
pushq $0x6f
pushq %r10
callq 0x1442a
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14404
addq $0x158, %rbx            # imm = 0x158
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14d4b
cmpl $0x0, (%r14)
je 0x12b0b
leaq 0x5f57e(%rip), %rax     # 0x72087
jmp 0x12b13
movq %rbx, %rdi
callq 0x14dfb
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12bc5
movq %rax, %rbx
movl $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 0x14a40
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %r14, %rdx
callq 0x14a4a
cmpl $0x0, (%r14)
je 0x12be0
movq %r15, %rdi
callq 0x14da6
movq %rbx, %rdi
callq 0x122c0
jmp 0x12bde
leaq 0x5f488(%rip), %rdx     # 0x72054
movq %r14, %rdi
movl $0x1, %esi
movl $0x3f6, %ecx            # imm = 0x3F6
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12c06
cmpl $0x1, %eax
jne 0x12c13
movl $0x10, %edi
jmp 0x12c0b
movl $0x8, %edi
addq %r14, %rdi
callq 0x2f843
leaq 0x158(%r14), %rdi
callq 0x14da6
movl $0x168, %edx            # imm = 0x168
movq %r14, %rdi
movq %rbx, %rsi
callq 0x121b0
movl $0x10, %eax
cmpl $0x6, (%rbx)
je 0x12c44
movl $0x18, %eax
cmpl $0x1, (%r14)
jne 0x12c4c
movq $0x0, (%rbx,%rax)
addq $0x158, %rbx            # imm = 0x158
movl $0x1, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14a40
// File: /workspace/github_c_makefile_star2_O1/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 0x12b56
cmpl $0x0, (%r14)
jne 0x12ce0
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 0x14ba1
movq %rax, %r12
movq %rbx, %r13
addq %rbp, %r13
movq %r15, %rdi
callq 0x14dfb
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x14b32
cmpl $0x0, (%r14)
je 0x12ce2
movq %rbx, %rdi
callq 0x12a38
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_O1/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 0x12ad0
movl (%rbx), %esi
leal -0x1(%rsi), %ecx
cmpl $0x5, %ecx
ja 0x12d6f
leaq 0x5f32e(%rip), %rdx     # 0x7203c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x8(%rbx), %edx
leaq 0x5f397(%rip), %rdi     # 0x720b8
movl $0x1, %esi
jmp 0x12d64
movsd 0x8(%rbx), %xmm0
leaq 0x5f378(%rip), %rdi     # 0x720ac
movl $0x5, %esi
movq %rax, %rdx
movb $0x1, %al
popq %rbx
jmp 0x12110
movl 0x8(%rbx), %edx
leaq 0x5f352(%rip), %rdi     # 0x720a0
movl $0x4, %esi
jmp 0x12d64
movl 0x8(%rbx), %edx
leaq 0x5f359(%rip), %rdi     # 0x720b8
movl $0x6, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
jmp 0x12110
leaq 0x5f34e(%rip), %rdi     # 0x720c4
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x12110
// File: /workspace/github_c_makefile_star2_O1/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 0x12dba
movq 0x30(%rbx), %rdx
movl 0x38(%rbx), %ecx
leaq 0x5f2b4(%rip), %r8      # 0x72054
movq %r14, %rdi
movl $0x40, %esi
movl $0x45f, %r9d            # imm = 0x45F
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14618
cmpq $0x0, 0x350(%rbx)
je 0x12de4
leaq 0x5f289(%rip), %rdx     # 0x72054
movq %r14, %rdi
movl $0xf, %esi
movl $0x464, %ecx            # imm = 0x464
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x145f4
movq %rsi, %rdi
movq %r14, %rsi
callq 0x12c67
cmpl $0x0, (%r14)
jne 0x12e19
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rdx
leaq (%rdx,%rdx,2), %rsi
movq %rcx, 0x50(%rbx,%rsi,8)
movq %rax, 0x58(%rbx,%rsi,8)
movl 0x38(%rbx), %eax
movl %eax, 0x60(%rbx,%rsi,8)
incq %rdx
movq %rdx, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
cmpq $0x0, 0x48(%rdi)
je 0x12e82
movq %rdi, %rbx
movq 0x350(%rdi), %rdi
testq %rdi, %rdi
je 0x12e4e
callq 0x12a38
movq $0x0, 0x350(%rbx)
movq 0x48(%rbx), %rax
leaq (%rax,%rax,2), %rax
movq 0x38(%rbx,%rax,8), %rcx
movq %rcx, 0x40(%rbx)
movl 0x48(%rbx,%rax,8), %ecx
movl %ecx, 0x38(%rbx)
movq 0x40(%rbx,%rax,8), %rdi
movq %r14, %rsi
callq 0x12c67
movq %rax, 0x350(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5f1cb(%rip), %rdx     # 0x72054
movq %r14, %rdi
movl $0xf, %esi
movl $0x475, %ecx            # imm = 0x475
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x12ec1
leaq -0x1(%rax), %rcx
movq %rcx, 0x48(%rdi)
leaq (%rax,%rax,2), %rax
movq 0x40(%rdi,%rax,8), %rdi
jmp 0x12a38
leaq 0x5f18c(%rip), %rdx     # 0x72054
movq %rsi, %rdi
movl $0xf, %esi
movl $0x486, %ecx            # imm = 0x486
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x13afc
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x13ac5
movl $0x2000, %r15d          # imm = 0x2000
addq 0x358(%rbx), %r15
movq 0x368(%rbx), %rdi
movq %r15, %rsi
callq 0x12210
testq %rax, %rax
je 0x13b02
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 0x13afc
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 0x13afc
movq $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5e54b(%rip), %rdx     # 0x72054
movq %r14, %rdi
movl $0x1, %esi
movl $0xcf, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_unknown
static void prv_process_unknown(subtilis_lexer_t *l, char ch,
				subtilis_token_t *t, subtilis_error_t *err)
{
	const char *tbuf;

	prv_set_first(l, t, SUBTILIS_TOKEN_UNKNOWN);
	for (;;) {
		prv_ensure_input(l, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (l->index == l->buf_end)
			break;

		ch = l->buffer[l->index];
		if (prv_is_separator(ch))
			break;
		prv_set_next_with_err(l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	tbuf = subtilis_token_get_text(t);
	subtilis_error_set_unknown_token(err, tbuf, l->stream->name, l->line);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x7, (%rsi)
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x14404
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x13cb6
movabsq $0x100002600, %r12      # imm = 0x100002600
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13a49
cmpl $0x0, (%rbx)
jne 0x13c6d
movq 0x40(%r14), %rax
cmpq 0x360(%r14), %rax
je 0x13c34
movq 0x368(%r14), %rcx
movzbl (%rcx,%rax), %eax
cmpq $0x20, %rax
ja 0x13c13
btq %rax, %r12
jb 0x13c34
movsbl %al, %edi
callq 0x13b20
testb %al, %al
jne 0x13c34
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13cb6
cmpl $0x0, (%rbx)
je 0x13bdf
jmp 0x13c6d
movq %r15, %rdi
callq 0x12ad0
movq 0x30(%r14), %r8
movl 0x38(%r14), %r9d
leaq 0x5e409(%rip), %r10     # 0x72054
leaq 0x601a3(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0xa, %esi
movq %rax, %rdx
pushq $0x394                  # imm = 0x394
pushq %r10
callq 0x1442a
addq $0x10, %rsp
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edx
movq %rax, %rsi
movq %r14, %rcx
callq 0x14b32
cmpl $0x0, (%r14)
jne 0x13cf6
incq 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl $0x5, (%rsi)
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x14404
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x13cb6
leaq 0x24e(%rip), %rdx       # 0x13f8b
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x13d7c
testb %al, %al
je 0x13d6d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b1e
cmpl $0x0, (%r14)
jne 0x13d6d
movq %rax, %rdi
callq 0x120c0
movsd %xmm0, 0x8(%rbx)
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13a49
cmpl $0x0, (%rbx)
jne 0x13de4
movq 0x40(%r15), %rax
movb $0x1, %bpl
cmpq 0x360(%r15), %rax
je 0x13de6
movq 0x368(%r15), %rcx
movsbl (%rcx,%rax), %edx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq *%r12
cmpl $0x1, %eax
je 0x13de6
cmpl $0x2, %eax
je 0x13de4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13cb6
cmpl $0x0, (%rbx)
je 0x13d90
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x8, %ecx
callq 0x13f20
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, (%rsp)
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x12b1e
cmpl $0x0, (%rbx)
je 0x13e61
addq $0x8, %rsp
jmp 0x13ec1
movq %rax, %r14
callq 0x12040
movq %rax, %r13
movl $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x12250
movq %rsp, %rcx
movq (%rcx), %rcx
cmpb $0x0, (%rcx)
jne 0x13e91
cmpl $0x0, (%r13)
je 0x13ecc
movq 0x30(%r15), %r8
movl 0x38(%r15), %r9d
leaq 0x5e1b4(%rip), %rax     # 0x72054
leaq 0x5ff4e(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x8, %esi
movq %r14, %rdx
pushq $0x180                  # imm = 0x180
pushq %rax
callq 0x1442a
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 0x13f16
movq 0x30(%r15), %r8
movl 0x38(%r15), %r9d
leaq 0x5e157(%rip), %rax     # 0x72054
leaq 0x5fef1(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x8, %esi
movq %r14, %rdx
pushq $0x185                  # imm = 0x185
jmp 0x13eb7
movl %eax, 0x8(%r12)
jmp 0x13e5b
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_rec
static void prv_process_rec(subtilis_lexer_t *l, subtilis_token_t *t,
			    const char *tbuf, char ch, subtilis_error_t *err)
{
	if (ch == '&' || ch == '%' || ch == '@' || ch == '$' ||
	    (strlen(tbuf) == 3)) {
		subtilis_error_set_bad_rec_name(err, tbuf, l->stream->name,
						l->line);
		return;
	}

	ch = prv_complete_identifier(l, t, ch, err);
	if (ch == '&' || ch == '%' || ch == '@' || ch == '$') {
		subtilis_error_set_bad_rec_name(err, tbuf, l->stream->name,
						l->line);
		return;
	}

	prv_check_token_buffer(l, t, err, SUBTILIS_ERROR_IDENTIFIER_TOO_LONG);

	t->type = SUBTILIS_TOKEN_KEYWORD;
	t->tok.keyword.type = SUBTILIS_KEYWORD_REC;
	t->tok.keyword.supported = true;
	t->tok.keyword.id_type.type = SUBTILIS_TYPE_VOID;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leal -0x24(%r13), %eax
cmpl $0x1c, %eax
ja 0x14024
movl $0x10000007, %ecx       # imm = 0x10000007
btl %eax, %ecx
jae 0x14024
movq 0x30(%r12), %r8
movl 0x38(%r12), %r9d
leaq 0x5e05b(%rip), %rax     # 0x72054
leaq 0x5fdf5(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x6a, %esi
movq %r14, %rdx
pushq $0x2e4                  # imm = 0x2E4
pushq %rax
callq 0x1442a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x120f0
cmpq $0x3, %rax
je 0x13fe8
movsbl %r13b, %edx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x141c2
movzbl %al, %eax
addl $-0x24, %eax
cmpl $0x1c, %eax
ja 0x14083
movl $0x10000007, %ecx       # imm = 0x10000007
btl %eax, %ecx
jae 0x14083
movq 0x30(%r12), %r8
movl 0x38(%r12), %r9d
leaq 0x5dfea(%rip), %rax     # 0x72054
leaq 0x5fd84(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x6a, %esi
movq %r14, %rdx
pushq $0x2eb                  # imm = 0x2EB
jmp 0x14010
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x9, %ecx
callq 0x13f20
movl $0x1, (%r15)
movl $0x2, 0x8(%r15)
movb $0x1, 0xc(%r15)
movl $0x8, 0x10(%r15)
jmp 0x1401a
// File: /workspace/github_c_makefile_star2_O1/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 $0x24, %edx
jle 0x140f7
cmpl $0x25, %edx
je 0x1410c
cmpl $0x26, %edx
je 0x14113
cmpl $0x40, %edx
jne 0x14105
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x14245
jmp 0x141b7
testl %edx, %edx
je 0x1411a
movl $0x7, %ecx
cmpl $0x24, %edx
je 0x1413d
movl $0x4, %ecx
jmp 0x1413d
movl $0x5, %ecx
jmp 0x1413d
movl $0x6, %ecx
jmp 0x1413d
movsbl %dl, %edx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x141c2
movq 0x40(%r15), %rdx
movl $0x4, %ecx
cmpq 0x360(%r15), %rdx
jne 0x14159
movl %ecx, 0x8(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x9, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x13f20
movzbl %al, %eax
cmpl $0x25, %eax
jg 0x14175
cmpl $0x24, %eax
je 0x14197
cmpl $0x25, %eax
jne 0x1413d
movl $0x5, 0x8(%r14)
jmp 0x141a9
cmpl $0x26, %eax
je 0x141a1
cmpl $0x40, %eax
jne 0x1413d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13cb6
cmpl $0x0, (%rbx)
jne 0x141bc
jmp 0x140e4
movl $0x7, 0x8(%r14)
jmp 0x141a9
movl $0x6, 0x8(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13cb6
cmpl $0x0, (%rbx)
je 0x14141
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rcx, %rsi
callq 0x13a49
cmpl $0x0, (%r14)
jne 0x14235
movq 0x40(%r12), %rax
cmpq 0x360(%r12), %rax
je 0x14237
movq 0x368(%r12), %rcx
movb (%rcx,%rax), %bl
movl %ebx, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x1a, %al
jb 0x14219
leal -0x30(%rbx), %eax
cmpb $0xa, %al
setae %al
cmpb $0x5f, %bl
setne %cl
testb %al, %cl
jne 0x14237
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x13cb6
cmpl $0x0, (%r14)
jne 0x14235
movq %r12, %rdi
movq %r14, %rsi
jmp 0x141d8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
movl %eax, (%rdi)
movb %al, 0x4(%rdi)
movb %al, 0x404(%rdi)
movb %al, 0x804(%rdi)
movl %eax, 0xa04(%rdi)
movb %al, 0xa08(%rdi)
movl %eax, 0xc08(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/error.c
// Function: subtilis_error_set_full
void subtilis_error_set_full(subtilis_error_t *e, subtilis_error_type_t type,
			     const char *data1, const char *data2,
			     const char *file, unsigned int line,
			     const char *subtilis_file,
			     unsigned int subtilis_line)
{
	e->type = type;
	strncpy(e->data1, data1, SUBTILIS_CONFIG_ERROR_LEN);
	e->data1[SUBTILIS_CONFIG_ERROR_LEN - 1] = 0;
	strncpy(e->data2, data2, SUBTILIS_CONFIG_ERROR_LEN);
	e->data2[SUBTILIS_CONFIG_ERROR_LEN - 1] = 0;
	strncpy(e->file, file, SUBTILIS_CONFIG_PATH_MAX);
	e->file[SUBTILIS_CONFIG_PATH_MAX - 1] = 0;
	e->line = line;
	strncpy(e->subtilis_file, subtilis_file, SUBTILIS_CONFIG_PATH_MAX);
	e->subtilis_file[SUBTILIS_CONFIG_PATH_MAX - 1] = 0;
	e->subtilis_line = subtilis_line;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rax
movq %rdi, %rbx
movq 0x40(%rsp), %r14
movl %esi, (%rdi)
addq $0x4, %rdi
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0x12050
xorl %r13d, %r13d
movb %r13b, 0x403(%rbx)
leaq 0x404(%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
movq %r12, %rsi
callq 0x12050
movb %r13b, 0x803(%rbx)
leaq 0x804(%rbx), %rdi
movl $0x200, %edx            # imm = 0x200
movq %r15, %rsi
callq 0x12050
movb %r13b, 0xa03(%rbx)
movl %ebp, 0xa04(%rbx)
leaq 0xa08(%rbx), %rdi
movl $0x200, %edx            # imm = 0x200
movq %r14, %rsi
callq 0x12050
movb %r13b, 0xc07(%rbx)
movl 0x48(%rsp), %eax
movl %eax, 0xc08(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/error.c
// Function: subtilis_error_set_int
void subtilis_error_set_int(subtilis_error_t *e, subtilis_error_type_t type,
			    int data1, int data2, const char *file,
			    unsigned int line, const char *subtilis_file,
			    unsigned int subtilis_line)
{
	char num1[32];
	char num2[32];

	snprintf(num1, sizeof(num1), "%d", data1);
	snprintf(num2, sizeof(num2), "%d", data2);

	subtilis_error_set_full(e, type, num1, num2, file, line, subtilis_file,
				subtilis_line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %ecx
movl %esi, %r15d
movq %rdi, %r12
leaq 0x5f14e(%rip), %r13     # 0x7364b
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12120
leaq 0x30(%rsp), %rbx
movl $0x20, %esi
movq %rbx, %rdi
movq %r13, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x12120
movq %r12, %rdi
movl %r15d, %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rcx
movq %r14, %r8
movl 0xc(%rsp), %r9d
movl 0x98(%rsp), %eax
pushq %rax
pushq 0x98(%rsp)
callq 0x1442a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/error.c
// Function: subtilis_error_fprintf
void subtilis_error_fprintf(FILE *f, subtilis_error_t *e, bool verbose)
{
	int args;

	if (e->type == SUBTILIS_ERROR_OK)
		return;
	if (strlen(e->file) > 0)
		fprintf(f, "%s: %d: ", e->file, e->line);

	args = prv_errors[e->type].args;
	if (args == 0)
		fprintf(f, "%s", prv_errors[e->type].msg);
	else if (args == 1)
		fprintf(f, prv_errors[e->type].msg, e->data1);
	else if (args == 2)
		fprintf(f, prv_errors[e->type].msg, e->data1, e->data2);
	if (verbose)
		fprintf(f, "  generated by %s:%d\n", e->subtilis_file,
			e->subtilis_line);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, (%rsi)
je 0x14761
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x804(%rsi)
je 0x146dc
leaq 0x804(%rbx), %rdx
movl 0xa04(%rbx), %ecx
leaq 0x5da10(%rip), %rsi     # 0x720e2
movq %r14, %rdi
xorl %eax, %eax
callq 0x12170
movl (%rbx), %ecx
shlq $0x4, %rcx
leaq 0x86737(%rip), %rdx     # 0x9ae20
leaq (%rdx,%rcx), %rax
movl 0x8(%rcx,%rdx), %ecx
cmpl $0x2, %ecx
je 0x1471f
cmpl $0x1, %ecx
je 0x1470c
testl %ecx, %ecx
jne 0x14737
movq (%rax), %rdi
movq %r14, %rsi
callq 0x12130
jmp 0x14737
movq (%rax), %rsi
leaq 0x4(%rbx), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x12170
jmp 0x14737
movq (%rax), %rsi
leaq 0x4(%rbx), %rdx
leaq 0x404(%rbx), %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x12170
testb %bpl, %bpl
je 0x14761
movl 0xc08(%rbx), %ecx
addq $0xa08, %rbx            # imm = 0xA08
leaq 0x5d99b(%rip), %rsi     # 0x720eb
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x12170
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/utils.c
// Function: subtilis_utils_basename
const char *subtilis_utils_basename(const char *path)
{
	size_t len = strlen(path);
	int i;

	if (len == 0)
		return path;
	i = ((int)len) - 1;
	if (path[i] == SUBTILIS_CONFIG_PATH_SEPARATOR)
		i--;
	for (; i >= 0 && path[i] != SUBTILIS_CONFIG_PATH_SEPARATOR; i--)
		;
	if (i >= 0)
		return &path[i + 1];
	else
		return path;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x120f0
testq %rax, %rax
je 0x14896
cltq
leaq -0x1(%rax), %rcx
cmpb $0x2e, -0x1(%rbx,%rax)
leal -0x2(%rax), %eax
cmovnel %ecx, %eax
testl %eax, %eax
js 0x14896
movl %eax, %ecx
cmpb $0x2e, (%rbx,%rcx)
je 0x14890
leal -0x1(%rcx), %eax
testl %ecx, %ecx
jg 0x1487f
jmp 0x14896
addq %rcx, %rbx
incq %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/utils.c
// Function: subtilis_get_i32_time
int32_t subtilis_get_i32_time(void)
{
	struct tm ts;
	time_t t = time(NULL);

	memset(&ts, 0, sizeof(ts));
	ts.tm_year = 2018 - 1900;
	ts.tm_mon = 11;
	ts.tm_mday = 22;

	t = t - mktime(&ts);

	return (int32_t)(t * 100);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorl %edi, %edi
callq 0x121c0
movq %rax, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movaps %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movabsq $0x760000000b, %rax     # imm = 0x760000000B
movq %rax, 0x10(%rdi)
movl $0x16, 0xc(%rdi)
callq 0x121f0
subl %eax, %ebx
imull $0x64, %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/utils.c
// Function: subtils_get_file_size
bool subtils_get_file_size(FILE *f, int32_t *size)
{
	long cur_pos = ftell(f);
	long fsize;

	if (cur_pos == -1)
		return false;

	if (fseek(f, 0L, SEEK_END))
		return false;

	fsize = (int32_t)ftell(f);
	if (fsize == -1)
		return false;

	if (fseek(f, 0L, cur_pos))
		return false;

	*size = fsize;

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12180
cmpq $-0x1, %rax
je 0x1492c
movq %rax, %r12
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x12200
testl %eax, %eax
jne 0x1492f
movq %r14, %rdi
callq 0x12180
movq %rax, %r13
cmpl $-0x1, %r13d
jne 0x1493c
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x12200
testl %eax, %eax
jne 0x1492f
movl %r13d, (%rbx)
movb $0x1, %r15b
jmp 0x1492f
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/utils.c
// Function: subtilis_make_cmdline
char *subtilis_make_cmdline(int argc, char **argv, subtilis_error_t *err)
{
	size_t size = 0;
	size_t i;
	char *ret_val;

	for (i = 1; i < argc; i++)
		size += strlen(argv[i]) + 1;

	if (size < 2) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	ret_val = malloc(size);
	if (!ret_val) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	ret_val[0] = 0;

	for (i = 1; i < argc - 1; i++) {
		strcat(ret_val, argv[i]);
		strcat(ret_val, " ");
	}
	strcat(ret_val, argv[i]);

	return ret_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jb 0x14995
movslq %ebp, %r12
movl $0x1, %r13d
xorl %r15d, %r15d
movq (%rbx,%r13,8), %rdi
callq 0x120f0
addq %rax, %r15
incq %r15
incq %r13
cmpq %r13, %r12
jne 0x1497c
jmp 0x14998
xorl %r15d, %r15d
cmpq $0x1, %r15
ja 0x149b4
leaq 0x5e584(%rip), %rdx     # 0x72f29
movq %r14, %rdi
movl $0xf, %esi
movl $0x59, %ecx
jmp 0x14a28
movq %r15, %rdi
callq 0x121d0
testq %rax, %rax
je 0x14a14
movq %rax, %r15
movb $0x0, (%rax)
decl %ebp
movl $0x1, %r14d
cmpl $0x2, %ebp
jb 0x149fa
movslq %ebp, %r12
movq (%rbx,%r14,8), %rsi
movq %r15, %rdi
callq 0x12270
movq %r15, %rdi
callq 0x120f0
movw $0x20, (%r15,%rax)
incq %r14
cmpq %r14, %r12
jne 0x149d7
movq (%rbx,%r14,8), %rsi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12270
leaq 0x5e50e(%rip), %rdx     # 0x72f29
movq %r14, %rdi
movl $0x1, %esi
movl $0x5f, %ecx
callq 0x145f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_reserve
void subtilis_buffer_reserve(subtilis_buffer_t *buffer, size_t length,
			     subtilis_error_t *err)
{
	size_t rem = 0;
	size_t new_max_size = 0;
	size_t extra_space = sizeof(subtilis_fixed_buffer_t);
	subtilis_fixed_buffer_t *b = buffer->buffer;

	if (b) {
		length += b->start;
		if (length <= b->max_size)
			return;
	}
	rem = length % buffer->granularity;
	new_max_size =
	    (rem == 0) ? length : (length - rem) + buffer->granularity;

	b = (subtilis_fixed_buffer_t *)realloc(buffer->buffer,
					       new_max_size + extra_space);
	if (!b) {
		subtilis_error_set_oom(err);
		return;
	}

	if (!buffer->buffer) {
		b->start = 0;
		b->end = 0;
	}
	b->max_size = new_max_size;
	buffer->buffer = b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x14a67
addq 0x8(%rdi), %rsi
cmpq (%rdi), %rsi
jbe 0x14aa2
movq (%rbx), %r15
movq %rsi, %rax
xorl %edx, %edx
divq %r15
addq %rsi, %r15
subq %rdx, %r15
testq %rdx, %rdx
cmoveq %rsi, %r15
leaq 0x20(%r15), %rsi
callq 0x12210
testq %rax, %rax
je 0x14aa8
cmpq $0x0, 0x8(%rbx)
jne 0x14a9b
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r15, (%rax)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5e9ca(%rip), %rdx     # 0x73479
movq %r14, %rdi
movl $0x1, %esi
movl $0x30, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_expand_if_full
void subtilis_buffer_expand_if_full(subtilis_buffer_t *buffer,
				    subtilis_error_t *err)
{
	subtilis_fixed_buffer_t *b = buffer->buffer;

	if (!b)
		subtilis_buffer_reserve(buffer, buffer->granularity, err);
	else if ((b->max_size - b->end) == 0)
		subtilis_buffer_reserve(buffer,
					buffer->granularity + b->max_size, err);
}

// Assembly:
movq %rsi, %rdx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x14ae3
movq (%rax), %rsi
cmpq 0x10(%rax), %rsi
jne 0x14aeb
addq (%rdi), %rsi
jmp 0x14a4a
movq (%rdi), %rsi
jmp 0x14a4a
retq