LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x12080
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12070
cmpl $0x0, %eax
je 0x12850
movq -0x18(%rbp), %rdi
callq 0x12170
cmpl $0x0, %eax
jne 0x12850
movq -0x20(%rbp), %rdi
movl $0x3, %esi
leaq 0x98a38(%rip), %rdx     # 0xab276
leaq 0x967e5(%rip), %rcx     # 0xa902a
movl $0x25, %r8d
callq 0x15990
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x128f5
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x96741(%rip), %rdx     # 0xa902a
movl $0x62, %ecx
callq 0x158e0
jmp 0x1295a
movq -0x10(%rbp), %rdi
callq 0x120d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x208(%rax)
movq -0x8(%rbp), %rax
leaq 0x26(%rip), %rcx        # 0x12960
movq %rcx, 0x210(%rax)
movq -0x8(%rbp), %rax
leaq 0xb4(%rip), %rcx        # 0x12a00
movq %rcx, 0x218(%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x129a4
movq $0x0, -0x8(%rbp)
jmp 0x129eb
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x129b6
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rax
addq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x12190
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x370, %edi            # imm = 0x370
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x12a80
movq 0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x9661b(%rip), %rdx     # 0xa9084
movl $0x36, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x12b8b
movq -0x18(%rbp), %rdi
callq 0x121b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x368(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x368(%rax)
jne 0x12ad5
movq -0x40(%rbp), %rdi
callq 0x12290
movq 0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x965c6(%rip), %rdx     # 0xa9084
movl $0x3d, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x12b8b
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x358(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x360(%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x40(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x40(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x350(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12c45
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rdi
callq 0x12c50
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x218(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq 0x208(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rdi
callq 0x12290
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x12c3c
movq -0x8(%rbp), %rax
addq $0x50, %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x12c50
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12c07
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12c65
jmp 0x12cb2
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x12c7d
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e100
jmp 0x12c99
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x12c97
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
callq 0x3e100
jmp 0x12c99
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16650
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x12cff
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x12d6a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x12d4b
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r9d
movl $0x13, %esi
leaq 0x96369(%rip), %rdx     # 0xa9093
leaq 0x98545(%rip), %rcx     # 0xab276
leaq 0x9634c(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0x6f, 0x8(%rsp)
callq 0x156d0
jmp 0x12d6a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc20, %rsp            # imm = 0xC20
movq %rdi, -0x8(%rbp)
leaq -0xc1c(%rbp), %rdi
callq 0x15670
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
leaq -0xc1c(%rbp), %rsi
callq 0x16560
cmpl $0x0, -0xc1c(%rbp)
jne 0x12dc1
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16760
movq %rax, -0x10(%rbp)
jmp 0x12dcc
leaq 0x962ef(%rip), %rax     # 0xa90b7
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xc20, %rsp            # imm = 0xC20
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_token_get_text_with_err
const char *subtilis_token_get_text_with_err(subtilis_token_t *t,
					     subtilis_error_t *err)
{
	subtilis_buffer_zero_terminate(&t->buf, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	return subtilis_buffer_get_string(&t->buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x18(%rbp), %rsi
callq 0x16560
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x12e17
movq $0x0, -0x8(%rbp)
jmp 0x12e2b
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16760
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x168, %edi            # imm = 0x168
callq 0x121b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12e85
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x96213(%rip), %rdx     # 0xa9084
movl $0x3f6, %ecx            # imm = 0x3F6
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x12f03
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x150, %edx            # imm = 0x150
callq 0x12110
movq -0x18(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movl $0x100, %esi            # imm = 0x100
callq 0x15f80
movq -0x18(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x10(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x15fc0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x12efb
movq -0x18(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16650
movq -0x18(%rbp), %rdi
callq 0x12290
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x12f38
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e100
jmp 0x12f54
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x12f52
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
callq 0x3e100
jmp 0x12f54
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16650
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x168, %edx            # imm = 0x168
callq 0x12190
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x12f8d
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x12fa4
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x12fa2
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x12fa4
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movl $0x1, %esi
callq 0x15f80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12e40
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x12ff3
movq $0x0, -0x8(%rbp)
jmp 0x13081
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0x150, %edx            # imm = 0x150
callq 0x12190
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16270
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16760
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x16200
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x13079
movq -0x28(%rbp), %rdi
callq 0x12c50
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12d70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x130d6
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rcx
leaq 0x96006(%rip), %rdi     # 0xa90d0
movb $0x0, %al
callq 0x120f0
jmp 0x13174
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x13102
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rdx
leaq 0x95fe3(%rip), %rdi     # 0xa90dc
movb $0x1, %al
callq 0x120f0
jmp 0x13172
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1312c
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rcx
leaq 0x95fc5(%rip), %rdi     # 0xa90e8
movb $0x0, %al
callq 0x120f0
jmp 0x13170
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x13156
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rcx
leaq 0x95f9b(%rip), %rdi     # 0xa90e8
movb $0x0, %al
callq 0x120f0
jmp 0x1316e
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rdx
leaq 0x95f8d(%rip), %rdi     # 0xa90f4
movb $0x0, %al
callq 0x120f0
jmp 0x13170
jmp 0x13172
jmp 0x13174
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x20, 0x48(%rax)
jne 0x131ce
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movl $0x40, %esi
leaq 0x95ec6(%rip), %r8      # 0xa9084
movl $0x45f, %r9d            # imm = 0x45F
callq 0x15930
jmp 0x13280
movq -0x8(%rbp), %rax
cmpq $0x0, 0x350(%rax)
je 0x131fb
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x95e98(%rip), %rdx     # 0xa9084
movl $0x464, %ecx            # imm = 0x464
callq 0x158e0
jmp 0x13280
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12fc0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x13217
jmp 0x13280
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq -0x8(%rbp), %rdx
imulq $0x18, 0x48(%rdx), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq -0x8(%rbp), %rdx
imulq $0x18, 0x48(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq -0x8(%rbp), %rdx
imulq $0x18, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x132ca
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x95dc9(%rip), %rdx     # 0xa9084
movl $0x475, %ecx            # imm = 0x475
callq 0x158e0
jmp 0x13378
movq -0x8(%rbp), %rax
cmpq $0x0, 0x350(%rax)
je 0x132f7
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rdi
callq 0x12c50
movq -0x8(%rbp), %rax
movq $0x0, 0x350(%rax)
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x12fc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x350(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x133b7
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x95cd9(%rip), %rdx     # 0xa9084
movl $0x486, %ecx            # imm = 0x486
callq 0x158e0
jmp 0x133e4
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq -0x8(%rbp), %rcx
imulq $0x18, 0x48(%rcx), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x12c50
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: subtilis_lexer_get
void subtilis_lexer_get(subtilis_lexer_t *l, subtilis_token_t *t,
			subtilis_error_t *err)
{
	bool rem;

	do {
		if (l->next) {
			/*
			 * We transfer ownership of our buffer.
			 */

			subtilis_token_claim(t, l->next);
			subtilis_token_delete(l->next);
			l->next = NULL;
			rem = false;
		} else {
			prv_reinit_token(t);
			prv_skip_white(l, err);
			if ((err->type != SUBTILIS_ERROR_OK) ||
			    (l->index == l->buf_end))
				return;
			rem = prv_process_token(l, t, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	} while (rem);
	subtilis_buffer_zero_terminate(&t->buf, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x350(%rax)
je 0x1344b
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rsi
callq 0x12f10
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rdi
callq 0x12c50
movq -0x8(%rbp), %rax
movq $0x0, 0x350(%rax)
movb $0x0, -0x19(%rbp)
jmp 0x134a4
movq -0x10(%rbp), %rdi
callq 0x134d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13550
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1347f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jne 0x13481
jmp 0x134c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13640
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x134a2
jmp 0x134c4
jmp 0x134a4
jmp 0x134a6
testb $0x1, -0x19(%rbp)
jne 0x13404
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x18(%rbp), %rsi
callq 0x16560
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_reinit_token
static void prv_reinit_token(subtilis_token_t *t)
{
	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);
	t->type = SUBTILIS_TOKEN_EOF;
	memset(&t->tok, 0, sizeof(t->tok));
	t->tok.id_type.type = SUBTILIS_TYPE_VOID;
	subtilis_buffer_reset(&t->buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x134f4
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e100
jmp 0x13510
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1350e
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
callq 0x3e100
jmp 0x13510
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x150, %edx            # imm = 0x150
callq 0x12110
movq -0x8(%rbp), %rax
movl $0x8, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16690
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_skip_white
static void prv_skip_white(subtilis_lexer_t *l, subtilis_error_t *err)
{
	do {
		while (l->index < l->buf_end &&
		       prv_is_whitespace(l->buffer[l->index])) {
			if (l->buffer[l->index] == '\n')
				l->line++;
			l->index++;
		}

		prv_ensure_input(l, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		if (l->index == l->buf_end)
			return;
	} while (prv_is_whitespace(l->buffer[l->index]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x13562
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x360(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0x1359b
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movsbl (%rax,%rcx), %edi
callq 0x13840
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x135a4
jmp 0x135df
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x135cd
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x13562
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13890
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x135f7
jmp 0x13634
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jne 0x1360e
jmp 0x13634
jmp 0x13610
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movsbl (%rax,%rcx), %edi
callq 0x13840
testb $0x1, %al
jne 0x13560
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jae 0x138ba
jmp 0x139eb
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x1392c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x210(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x368(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x358(%rcx), %rsi
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq 0x208(%rcx), %rdx
movq -0x10(%rbp), %rcx
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x360(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1391b
jmp 0x139eb
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x139eb
movq -0x8(%rbp), %rax
movq 0x358(%rax), %rax
addq $0x2000, %rax           # imm = 0x2000
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x121e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1397c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x95714(%rip), %rdx     # 0xa9084
movl $0xcf, %ecx
callq 0x158e0
jmp 0x139eb
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x358(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x368(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x210(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x368(%rcx), %rdi
movq -0x8(%rbp), %rcx
addq 0x40(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq 0x208(%rcx), %rdx
movq -0x10(%rbp), %rcx
movl $0x2000, %esi           # imm = 0x2000
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x360(%rax), %rcx
movq %rcx, 0x360(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_is_simple_operator
static bool prv_is_simple_operator(char c)
{
	return c == '/' || c == '*' || c == '(' || c == ')' || c == '=' ||
	       c == ',' || c == ';' || c == '^' || c == '[' || c == ']' ||
	       c == '|' || c == '~' || c == '?' || c == '$' || c == '!' ||
	       c == '{' || c == '}';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x28, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x29, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3d, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2c, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3b, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5e, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5b, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5d, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7c, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x24, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x21, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7b, %ecx
movb %al, -0x2(%rbp)
je 0x13b13
movsbl -0x1(%rbp), %eax
cmpl $0x7d, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_decimal
static void prv_process_decimal(subtilis_lexer_t *l, subtilis_token_t *t,
				subtilis_error_t *err)
{
	prv_set_first(l, t, SUBTILIS_TOKEN_INTEGER);
	if (!prv_extract_number(l, t, prv_decimal_end, err))
		return;

	prv_parse_integer(l, t, 10, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x13b20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq 0xad7(%rip), %rdx       # 0x14a20
callq 0x14940
testb $0x1, %al
jne 0x13f54
jmp 0x13f6a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0xa, %edx
callq 0x14a90
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_hexadecimal
static void prv_process_hexadecimal(subtilis_lexer_t *l, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	t->type = SUBTILIS_TOKEN_INTEGER;
	l->index++;
	if (!prv_extract_number(l, t, prv_hexadecimal_end, err))
		return;

	prv_parse_integer(l, t, 16, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq 0xcbf(%rip), %rdx       # 0x14c70
callq 0x14940
testb $0x1, %al
jne 0x13fbc
jmp 0x13fd2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x10, %edx
callq 0x14a90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_binary
static void prv_process_binary(subtilis_lexer_t *l, subtilis_token_t *t,
			       subtilis_error_t *err)
{
	t->type = SUBTILIS_TOKEN_INTEGER;
	l->index++;
	if (!prv_extract_number(l, t, prv_binary_end, err))
		return;

	prv_parse_integer(l, t, 2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq 0xcaf(%rip), %rdx       # 0x14cd0
callq 0x14940
testb $0x1, %al
jne 0x1402c
jmp 0x14042
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x2, %edx
callq 0x14a90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x7, %edx
callq 0x13b20
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13890
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14607
jmp 0x146af
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jne 0x1461e
jmp 0x14666
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x15630
testb $0x1, %al
jne 0x14646
jmp 0x14648
jmp 0x14666
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14700
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14664
jmp 0x146af
jmp 0x145ec
movq -0x18(%rbp), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r9d
movl $0xa, %esi
leaq 0x96bdf(%rip), %rcx     # 0xab276
leaq 0x949e6(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0x394, 0x8(%rsp)       # imm = 0x394
callq 0x156d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x18(%rbp), %rcx
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x16200
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x14763
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_negative_decimal
static void prv_process_negative_decimal(subtilis_lexer_t *l,
					 subtilis_token_t *t,
					 subtilis_error_t *err)
{
	const char *tbuf;

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

	l->next = subtilis_token_new(err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_set_first(l, l->next, SUBTILIS_TOKEN_INTEGER);
	if (!prv_extract_number(l, l->next, prv_decimal_end, err))
		return;

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

	if (strcmp(tbuf, "2147483648")) {
		prv_parse_integer(l, l->next, 10, err);
	} else {
		/* This is a special case where we have the smallest possible
		 * 32 bit integer.  Here we return 1 token, the integer, rather
		 * than the '-' on this call to the lexer and the integer on the
		 * next.
		 */

		subtilis_token_claim(t, l->next);
		subtilis_token_delete(l->next);
		l->next = NULL;
		t->tok.integer = -2147483648;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x350(%rax)
je 0x147b1
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x948e2(%rip), %rdx     # 0xa9084
movl $0x1ac, %ecx            # imm = 0x1AC
callq 0x158e0
jmp 0x148ac
movq -0x18(%rbp), %rdi
callq 0x12e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x350(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x147d6
jmp 0x148ac
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rsi
movl $0x4, %edx
callq 0x13b20
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rsi
movq -0x18(%rbp), %rcx
leaq 0x217(%rip), %rdx       # 0x14a20
callq 0x14940
testb $0x1, %al
jne 0x14817
jmp 0x148ac
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12de0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1483a
jmp 0x148ac
movq -0x20(%rbp), %rdi
leaq 0x948b8(%rip), %rsi     # 0xa90fd
callq 0x12140
cmpl $0x0, %eax
je 0x1486e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rsi
movq -0x18(%rbp), %rcx
movl $0xa, %edx
callq 0x14a90
jmp 0x148ac
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rsi
callq 0x12f10
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rdi
callq 0x12c50
movq -0x8(%rbp), %rax
movq $0x0, 0x350(%rax)
movq -0x10(%rbp), %rax
movl $0x80000000, 0x8(%rax)  # imm = 0x80000000
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x5, %edx
callq 0x13b20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq 0x337(%rip), %rdx       # 0x14c30
callq 0x14940
testb $0x1, %al
jne 0x14904
jmp 0x14932
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12de0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14920
jmp 0x14932
movq -0x20(%rbp), %rdi
callq 0x120a0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13890
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14977
jmp 0x149f7
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jne 0x14992
movb $0x1, -0x25(%rbp)
jmp 0x149f7
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq 0x368(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x40(%rdx), %rdx
movb (%rcx,%rdx), %dl
movq -0x20(%rbp), %rcx
movsbl %dl, %edx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jne 0x149c8
jmp 0x149f7
cmpl $0x1, -0x24(%rbp)
jne 0x149d4
movb $0x1, -0x25(%rbp)
jmp 0x149f7
jmp 0x149d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14700
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x149f2
jmp 0x149f7
jmp 0x1495c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x8, %ecx
callq 0x14bb0
movb -0x25(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_decimal_end
static subtilis_token_end_t prv_decimal_end(subtilis_lexer_t *l,
					    subtilis_token_t *t, char ch,
					    subtilis_error_t *err)
{
	if (!(ch >= '0' && ch <= '9')) {
		if (ch == '.') {
			prv_process_float(l, t, err);
			return SUBTILIS_TOKEN_END_RETURN;
		}
		return SUBTILIS_TOKEN_END_NOT_TOKEN;
	}
	return SUBTILIS_TOKEN_END_TOKEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x30, %eax
jl 0x14a4b
movsbl -0x19(%rbp), %eax
cmpl $0x39, %eax
jle 0x14a77
movsbl -0x19(%rbp), %eax
cmpl $0x2e, %eax
jne 0x14a6e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x148c0
movl $0x2, -0x4(%rbp)
jmp 0x14a7e
movl $0x1, -0x4(%rbp)
jmp 0x14a7e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12de0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14ace
jmp 0x14ba7
callq 0x12030
movl $0x0, (%rax)
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0x12220
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x14b03
callq 0x12030
cmpl $0x0, (%rax)
je 0x14b41
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r9d
movl $0x8, %esi
leaq 0x9674f(%rip), %rcx     # 0xab276
leaq 0x94556(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0x180, 0x8(%rsp)       # imm = 0x180
callq 0x156d0
jmp 0x14ba7
cmpl $0xa, -0x14(%rbp)
jne 0x14b51
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
ja 0x14b5c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x30(%rbp)
jbe 0x14b9a
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r9d
movl $0x8, %esi
leaq 0x966f6(%rip), %rcx     # 0xab276
leaq 0x944fd(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0x185, 0x8(%rsp)       # imm = 0x185
callq 0x156d0
jmp 0x14ba7
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_check_token_buffer
static void prv_check_token_buffer(subtilis_lexer_t *l, subtilis_token_t *t,
				   subtilis_error_t *err,
				   subtilis_error_type_t type)
{
	const char *tbuf;

	if (subtilis_buffer_get_size(&t->buf) <= SUBTILIS_MAX_TOKEN_SIZE)
		return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x16270
cmpq $0xff, %rax
ja 0x14be1
jmp 0x14c28
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r9d
leaq 0x96666(%rip), %rcx     # 0xab276
leaq 0x9446d(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0xe4, 0x8(%rsp)
callq 0x156d0
addq $0x40, %rsp
popq %rbp
retq
nop