LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_hexadecimal_end
static subtilis_token_end_t prv_hexadecimal_end(subtilis_lexer_t *l,
						subtilis_token_t *t, char ch,
						subtilis_error_t *err)
{
	if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') ||
	    (ch >= 'A' && ch <= 'F')) {
		return SUBTILIS_TOKEN_END_TOKEN;
	}
	return SUBTILIS_TOKEN_END_NOT_TOKEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x14c97
movsbl -0x19(%rbp), %eax
cmpl $0x39, %eax
jle 0x14cbb
movsbl -0x19(%rbp), %eax
cmpl $0x61, %eax
jl 0x14ca9
movsbl -0x19(%rbp), %eax
cmpl $0x66, %eax
jle 0x14cbb
movsbl -0x19(%rbp), %eax
cmpl $0x41, %eax
jl 0x14cc4
movsbl -0x19(%rbp), %eax
cmpl $0x46, %eax
jg 0x14cc4
movl $0x0, -0x4(%rbp)
jmp 0x14ccb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/lexer.c
// Function: prv_process_call
static void prv_process_call(subtilis_lexer_t *l, subtilis_token_t *t,
			     bool proc, char ch, subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_type_t id_type;

	t->type = SUBTILIS_TOKEN_IDENTIFIER;
	prv_validate_identifier(l, t, ch, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (proc) {
		if (t->tok.id_type.type != SUBTILIS_TYPE_REAL) {
			tbuf = subtilis_token_get_text(t);
			subtilis_error_set_bad_proc_name(
			    err, tbuf, l->stream->name, l->line);
			return;
		}
		t->tok.keyword.type = SUBTILIS_KEYWORD_PROC;
		t->tok.keyword.supported = true;
		t->tok.keyword.id_type.type = SUBTILIS_TYPE_VOID;
	} else {
		subtilis_type_init_copy(&id_type, &t->tok.id_type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_type_free(&t->tok.id_type);
		t->tok.keyword.id_type = id_type;
		t->tok.keyword.type = SUBTILIS_KEYWORD_FN;
		t->tok.keyword.supported = true;
	}
	t->type = SUBTILIS_TOKEN_KEYWORD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x6, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x12(%rbp), %al
movq -0x20(%rbp), %rcx
movsbl %al, %edx
callq 0x150e0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14d63
jmp 0x14e4b
testb $0x1, -0x11(%rbp)
je 0x14de1
movq -0x10(%rbp), %rax
cmpl $0x4, 0x8(%rax)
je 0x14dc1
movq -0x10(%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 $0xb, %esi
leaq 0x964d2(%rip), %rcx     # 0xab276
leaq 0x942d9(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0x2cc, 0x8(%rsp)       # imm = 0x2CC
callq 0x156d0
jmp 0x14e4b
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x10(%rax)
jmp 0x14e41
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
leaq -0x170(%rbp), %rdi
callq 0x3dec0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14e04
jmp 0x14e4b
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e100
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
leaq -0x170(%rbp), %rsi
movl $0x148, %edx            # imm = 0x148
callq 0x12190
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x26, %eax
je 0x14eb0
movsbl -0x19(%rbp), %eax
cmpl $0x25, %eax
je 0x14eb0
movsbl -0x19(%rbp), %eax
cmpl $0x40, %eax
je 0x14eb0
movsbl -0x19(%rbp), %eax
cmpl $0x24, %eax
je 0x14eb0
movq -0x18(%rbp), %rdi
callq 0x120d0
cmpq $0x3, %rax
jne 0x14ef1
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r9d
movl $0x6a, %esi
leaq 0x963a2(%rip), %rcx     # 0xab276
leaq 0x941a9(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0x2e4, 0x8(%rsp)       # imm = 0x2E4
callq 0x156d0
jmp 0x14fab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x19(%rbp), %al
movq -0x28(%rbp), %rcx
movsbl %al, %edx
callq 0x152e0
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x26, %eax
je 0x14f2f
movsbl -0x19(%rbp), %eax
cmpl $0x25, %eax
je 0x14f2f
movsbl -0x19(%rbp), %eax
cmpl $0x40, %eax
je 0x14f2f
movsbl -0x19(%rbp), %eax
cmpl $0x24, %eax
jne 0x14f6d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r9d
movl $0x6a, %esi
leaq 0x96323(%rip), %rcx     # 0xab276
leaq 0x9412a(%rip), %rax     # 0xa9084
movq %rax, (%rsp)
movl $0x2eb, 0x8(%rsp)       # imm = 0x2EB
callq 0x156d0
jmp 0x14fab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x9, %ecx
callq 0x14bb0
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x10(%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: prv_skip_line
static void prv_skip_line(subtilis_lexer_t *l, subtilis_error_t *err)
{
	do {
		while (l->index < l->buf_end && l->buffer[l->index] != '\n')
			l->index++;

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

		if (l->index == l->buf_end)
			return;
	} while (l->buffer[l->index] != '\n');
	l->index++;
	l->line++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x15012
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x360(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0x1504c
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x15055
jmp 0x15067
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x15012
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13890
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1507f
jmp 0x150d5
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jne 0x15096
jmp 0x150d5
jmp 0x15098
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x15010
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%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_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 %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)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13890
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x15318
movb $0x0, -0x1(%rbp)
jmp 0x153b4
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jne 0x1532f
jmp 0x153ae
movq -0x10(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x41, %eax
jl 0x1535a
movsbl -0x19(%rbp), %eax
cmpl $0x5a, %eax
jle 0x15389
movsbl -0x19(%rbp), %eax
cmpl $0x61, %eax
jl 0x1536c
movsbl -0x19(%rbp), %eax
cmpl $0x7a, %eax
jle 0x15389
movsbl -0x19(%rbp), %eax
cmpl $0x30, %eax
jl 0x1537e
movsbl -0x19(%rbp), %eax
cmpl $0x39, %eax
jle 0x15389
movsbl -0x19(%rbp), %eax
cmpl $0x5f, %eax
je 0x15389
jmp 0x153ae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x14700
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x153a9
movb $0x0, -0x1(%rbp)
jmp 0x153b4
jmp 0x152f9
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x404(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x804(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa04(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa08(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc08(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x12040
movq -0x8(%rbp), %rax
movb $0x0, 0x403(%rax)
movq -0x8(%rbp), %rdi
addq $0x404, %rdi            # imm = 0x404
movq -0x20(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x12040
movq -0x8(%rbp), %rax
movb $0x0, 0x803(%rax)
movq -0x8(%rbp), %rdi
addq $0x804, %rdi            # imm = 0x804
movq -0x28(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x12040
movq -0x8(%rbp), %rax
movb $0x0, 0xa03(%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xa04(%rax)
movq -0x8(%rbp), %rdi
addq $0xa08, %rdi            # imm = 0xA08
movq 0x10(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x12040
movq -0x8(%rbp), %rax
movb $0x0, 0xc07(%rax)
movl 0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc08(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
movl -0x10(%rbp), %ecx
movl $0x20, %esi
leaq 0x94e71(%rip), %rdx     # 0xaa65b
movb $0x0, %al
callq 0x12100
leaq -0x70(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x20, %esi
leaq 0x94e57(%rip), %rdx     # 0xaa65b
movb $0x0, %al
callq 0x12100
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movl 0x18(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x156d0
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/error.c
// Function: subtilis_error_set_dbl
void subtilis_error_set_dbl(subtilis_error_t *e, subtilis_error_type_t type,
			    double data1, double 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), "%f", data1);
	snprintf(num2, sizeof(num2), "%f", data2);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movl $0x20, %esi
leaq 0x97e40(%rip), %rdx     # 0xad6c0
movb $0x1, %al
callq 0x12100
leaq -0x80(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movl $0x20, %esi
leaq 0x97e24(%rip), %rdx     # 0xad6c0
movb $0x1, %al
callq 0x12100
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq -0x38(%rbp), %r10
movl -0x3c(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x156d0
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/error.c
// Function: subtilis_error_set_errno
void subtilis_error_set_errno(subtilis_error_t *e, subtilis_error_type_t type,
			      const char *data1, const char *subtilis_file,
			      unsigned int subtilis_line)
{
	char buf[32];

	sprintf(buf, "%d", errno);
	subtilis_error_set_full(e, type, data1, buf, "", 0, subtilis_file,
				subtilis_line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x12030
movq -0x58(%rbp), %rdi
movl (%rax), %edx
leaq 0x94c96(%rip), %rsi     # 0xaa65b
movb $0x0, %al
callq 0x12250
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq -0x20(%rbp), %r10
movl -0x24(%rbp), %eax
leaq 0x9588d(%rip), %r8      # 0xab276
xorl %r9d, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x156d0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x15a25
jmp 0x15b53
movq -0x10(%rbp), %rdi
addq $0x804, %rdi            # imm = 0x804
callq 0x120d0
cmpq $0x0, %rax
jbe 0x15a62
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x804, %rdx            # imm = 0x804
movq -0x10(%rbp), %rax
movl 0xa04(%rax), %ecx
leaq 0x936b7(%rip), %rsi     # 0xa9112
movb $0x0, %al
callq 0x12150
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xbe6ef(%rip), %rax     # 0xd4160
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x15ab1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xbe6c9(%rip), %rax     # 0xd4160
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x953ef(%rip), %rsi     # 0xaae97
movb $0x0, %al
callq 0x12150
jmp 0x15b26
cmpl $0x1, -0x18(%rbp)
jne 0x15ae5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xbe696(%rip), %rax     # 0xd4160
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
movb $0x0, %al
callq 0x12150
jmp 0x15b24
cmpl $0x2, -0x18(%rbp)
jne 0x15b22
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xbe662(%rip), %rax     # 0xd4160
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
movq -0x10(%rbp), %rcx
addq $0x404, %rcx            # imm = 0x404
movb $0x0, %al
callq 0x12150
jmp 0x15b24
jmp 0x15b26
testb $0x1, -0x11(%rbp)
je 0x15b53
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0xa08, %rdx            # imm = 0xA08
movq -0x10(%rbp), %rax
movl 0xc08(%rax), %ecx
leaq 0x935cf(%rip), %rsi     # 0xa911b
movb $0x0, %al
callq 0x12150
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/error.c
// Function: subtilis_error_set_bad_arg_type
void subtilis_error_set_bad_arg_type(subtilis_error_t *e, size_t arg,
				     const char *expected, const char *got,
				     const char *file, unsigned int line,
				     const char *subtilis_file,
				     unsigned int subtilis_line)
{
	char arg_num[32];
	char msg[SUBTILIS_CONFIG_ERROR_LEN];

	snprintf(arg_num, sizeof(arg_num), "%zu", arg);
	snprintf(msg, sizeof(msg), "expected %s got %s", expected, got);

	subtilis_error_set_full(e, SUBTILIS_ERROR_BAD_ARG_TYPE, arg_num, msg,
				file, line, subtilis_file, subtilis_line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
leaq 0x956ac(%rip), %rdx     # 0xab2ba
movb $0x0, %al
callq 0x12100
leaq -0x450(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0x93515(%rip), %rdx     # 0xa9145
movb $0x0, %al
callq 0x12100
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x450(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq 0x10(%rbp), %r10
movl 0x18(%rbp), %eax
movl $0x2a, %esi
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x156d0
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x120d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15c9d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15d1d
movq -0x18(%rbp), %rax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x15cc1
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15cc3
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jl 0x15ce3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x15cec
jmp 0x15cf9
jmp 0x15cee
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15cc3
cmpl $0x0, -0x1c(%rbp)
jl 0x15d15
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x15d1d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x121a0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x12110
movl $0x76, -0x24(%rbp)
movl $0xb, -0x28(%rbp)
movl $0x16, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x121c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
imulq $0x64, -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12160
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x15dca
movb $0x0, -0x1(%rbp)
jmp 0x15e31
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x121d0
cmpl $0x0, %eax
je 0x15de7
movb $0x0, -0x1(%rbp)
jmp 0x15e31
movq -0x10(%rbp), %rdi
callq 0x12160
cltq
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x15e03
movb $0x0, -0x1(%rbp)
jmp 0x15e31
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x121d0
cmpl $0x0, %eax
je 0x15e21
movb $0x0, -0x1(%rbp)
jmp 0x15e31
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jae 0x15e9b
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x120d0
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15e63
cmpq $0x2, -0x28(%rbp)
jae 0x15ec9
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x940a7(%rip), %rdx     # 0xa9f59
movl $0x59, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x15f72
movq -0x28(%rbp), %rdi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x15f01
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x9406c(%rip), %rdx     # 0xa9f59
movl $0x5f, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x15f72
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x15f55
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x12240
movq -0x38(%rbp), %rdi
leaq 0x949c1(%rip), %rsi     # 0xaa903
callq 0x12240
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15f10
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x12240
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x20, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x16023
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
ja 0x16021
jmp 0x160d6
jmp 0x16023
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x16045
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x16058
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1609c
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x9441b(%rip), %rdx     # 0xaa4ab
movl $0x30, %ecx
callq 0x158e0
jmp 0x160d6
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x160bf
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16119
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x15fc0
jmp 0x1614b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
cmpq $0x0, %rax
jne 0x16149
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
addq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x15fc0
jmp 0x1614b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_append_reserve
void subtilis_buffer_append_reserve(subtilis_buffer_t *buffer, size_t length,
				    subtilis_error_t *err)
{
	size_t new_end = length;
	size_t new_length;
	subtilis_fixed_buffer_t *b = buffer->buffer;

	if (b) {
		new_end += b->end;
		new_length = new_end - b->start;
	} else {
		new_length = length;
	}

	subtilis_buffer_reserve(buffer, new_length, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	b = buffer->buffer;
	b->end = new_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x161b1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x28(%rbp)
jmp 0x161b9
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15fc0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x161d5
jmp 0x161ed
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_append
void subtilis_buffer_append(subtilis_buffer_t *buffer, const void *data,
			    size_t length, subtilis_error_t *err)
{
	size_t old_size;

	if (length == 0)
		return;

	old_size = subtilis_buffer_get_size(buffer);

	subtilis_buffer_append_reserve(buffer, length, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	(void)memcpy(buffer->buffer->data + old_size, data, length);
}

// 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)
cmpq $0x0, -0x18(%rbp)
jne 0x16221
jmp 0x16267
movq -0x8(%rbp), %rdi
callq 0x16270
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x16160
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1624a
jmp 0x16267
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12190
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_append_buffer
void subtilis_buffer_append_buffer(subtilis_buffer_t *target,
				   subtilis_buffer_t *source,
				   subtilis_error_t *err)
{
	subtilis_fixed_buffer_t *b = source->buffer;

	if (!b)
		return;

	subtilis_buffer_append(target, b->data,
			       subtilis_buffer_get_size(source), err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x162d9
jmp 0x1630a
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16270
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x16200
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_insert
void subtilis_buffer_insert(subtilis_buffer_t *buffer, size_t pos,
			    const void *data, size_t length,
			    subtilis_error_t *err)
{
	size_t new_length;
	void *move_from;
	subtilis_fixed_buffer_t *b;
	size_t size = subtilis_buffer_get_size(buffer);

	if (pos > size) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	new_length = size + length;

	subtilis_buffer_reserve(buffer, new_length, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	b = buffer->buffer;
	move_from = b->data + pos + b->start;
	if (pos < size)
		memmove(((char *)move_from) + length, move_from, size - pos);

	memcpy(move_from, data, length);
	b->end += length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16270
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x163b2
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x94108(%rip), %rdx     # 0xaa4ab
movl $0x8c, %ecx
callq 0x158e0
jmp 0x16442
movq -0x48(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x15fc0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x163da
jmp 0x16442
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x18, %rax
addq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x16421
movq -0x38(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
subq -0x10(%rbp), %rdx
callq 0x12200
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12190
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_delete
void subtilis_buffer_delete(subtilis_buffer_t *buffer, size_t pos,
			    size_t length, subtilis_error_t *err)
{
	size_t last_pos = pos + length;
	void *move_to;
	void *move_from;
	size_t bytes_to_move;
	subtilis_fixed_buffer_t *b = buffer->buffer;
	size_t size;

	if (!b) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	size = b->end - b->start;

	if (last_pos > size) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (last_pos == size) {
		b->end = pos + b->start;
	} else {
		move_to = ((char *)b->data) + pos + b->start;
		move_from = ((char *)move_to) + length;
		bytes_to_move = size - last_pos;
		memmove(move_to, move_from, bytes_to_move);
		b->end -= length;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x164a6
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x94014(%rip), %rdx     # 0xaa4ab
movl $0xaa, %ecx
callq 0x158e0
jmp 0x16554
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x48(%rbp), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x50(%rbp), %rax
jbe 0x164e0
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x93fd7(%rip), %rdx     # 0xaa4ab
movl $0xb1, %ecx
callq 0x158e0
jmp 0x16554
movq -0x28(%rbp), %rax
cmpq -0x50(%rbp), %rax
jne 0x16500
movq -0x10(%rbp), %rcx
movq -0x48(%rbp), %rax
addq 0x8(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x16554
movq -0x48(%rbp), %rax
addq $0x18, %rax
addq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x12200
movq -0x18(%rbp), %rdx
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_zero_terminate
void subtilis_buffer_zero_terminate(subtilis_buffer_t *buffer,
				    subtilis_error_t *err)
{
	uint8_t zero = 0;
	subtilis_fixed_buffer_t *b = buffer->buffer;

	if (!b || (b->start == b->end) || (((char *)b->data)[b->end - 1] != 0))
		subtilis_buffer_append(buffer, &zero, 1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x165b3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x165b3
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movsbl 0x18(%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x165c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x16200
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_remove_terminator
void subtilis_buffer_remove_terminator(subtilis_buffer_t *buffer)
{
	subtilis_fixed_buffer_t *b = buffer->buffer;

	if (!b)
		return;

	while ((b->end > b->start) && (((char *)b->data)[b->end - 1] == 0))
		b->end--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x165ed
jmp 0x1663f
jmp 0x165ef
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x11(%rbp)
jbe 0x16624
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movsbl 0x18(%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1662d
jmp 0x1663f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x165ef
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_free
void subtilis_buffer_free(subtilis_buffer_t *buffer)
{
	if (!buffer->buffer)
		return;

	free(buffer->buffer);
	buffer->buffer = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16669
jmp 0x16682
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_buffer_reset
void subtilis_buffer_reset(subtilis_buffer_t *buffer)
{
	subtilis_fixed_buffer_t *b = buffer->buffer;

	if (b) {
		b->start = 0;
		b->end = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x166c3
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/buffer.c
// Function: subtilis_fixed_buffer_compress
void subtilis_fixed_buffer_compress(subtilis_fixed_buffer_t *fixed_buffer)
{
	if (fixed_buffer->start > 0) {
		(void)memmove(fixed_buffer->data,
			      fixed_buffer->data + fixed_buffer->start,
			      fixed_buffer->end - fixed_buffer->start);
		fixed_buffer->end -= fixed_buffer->start;
		fixed_buffer->start = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x16807
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
subq 0x8(%rax), %rdx
callq 0x12200
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser.c
// Function: subtilis_parser_delete
void subtilis_parser_delete(subtilis_parser_t *p)
{
	size_t i;

	if (!p)
		return;

	for (i = 0; i < p->num_calls; i++)
		subtilis_parser_call_delete(p->calls[i]);
	free(p->calls);

	for (i = 0; i < p->num_call_addrs; i++)
		subtilis_parser_call_addr_delete(p->call_addrs[i]);
	free(p->call_addrs);

	subtilis_ir_prog_delete(p->prog);
	subtilis_symbol_table_delete(p->main_st);
	subtilis_symbol_table_delete(p->st);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16ad8
jmp 0x16ba6
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x16b17
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x46fe0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x16ae0
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x12290
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jae 0x16b66
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x47110
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x16b2f
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x38b40
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x3c2b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3c2b0
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser.c
// Function: subtilis_parse
void subtilis_parse(subtilis_parser_t *p, subtilis_error_t *err)
{
	subtilis_token_t *t = NULL;

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

	prv_root(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_parser_check_calls(p, err);

cleanup:

	subtilis_token_delete(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17150
jmp 0x17182
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x17190
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1716c
jmp 0x17179
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20e10
movq -0x18(%rbp), %rdi
callq 0x12c50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser.c
// Function: prv_initialise_free_mem
static void prv_initialise_free_mem(subtilis_parser_t *p, subtilis_token_t *t,
				    subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e;

	if (!p->settings.check_mem_leaks)
		return;

	reg = subtilis_ir_section_add_instr1(p->current,
					     SUBTILIS_OP_INSTR_HEAP_FREE, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	e = subtilis_exp_new_int32_var(reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_var_assign_hidden(p, subtilis_heap_free_on_startup_var,
				   &subtilis_type_integer, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0xba(%rax)
jne 0x17453
jmp 0x174c3
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rdx
movl $0x87, %esi
callq 0x384e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17478
jmp 0x174c3
movq -0x20(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x37770
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17496
jmp 0x174c3
movq -0x8(%rbp), %rdi
leaq 0xbd3a7(%rip), %rax     # 0xd4848
movq (%rax), %rsi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x9441d(%rip), %rdx     # 0xab8d0
callq 0x47150
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x174c3
jmp 0x174c3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser.c
// Function: prv_dim
static void prv_dim(subtilis_parser_t *p, subtilis_token_t *t,
		    subtilis_error_t *err)
{
	if (p->current != p->main) {
		subtilis_error_dim_in_proc(err, p->l->stream->name, p->l->line);
		return;
	}

	subtilis_parser_create_array(p, t, false, 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
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
je 0x17798
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x37, %esi
leaq 0x92d30(%rip), %r8      # 0xaa4bb
movl $0x94, %r9d
callq 0x15930
jmp 0x177ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0x19790
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser.c
// Function: prv_end
static void prv_end(subtilis_parser_t *p, subtilis_token_t *t,
		    subtilis_error_t *err)
{
	subtilis_ir_operand_t end_label;

	if (p->current != p->main) {
		subtilis_ir_section_add_instr_no_arg(
		    p->current, SUBTILIS_OP_INSTR_END, err);
	} else {
		end_label.label = p->current->nofree_label;
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_JMP, end_label, err);
	}
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->current->endproc = true;
}

// 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 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
je 0x177fe
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rdx
movl $0x74, %esi
callq 0x385f0
jmp 0x1782b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17836
jmp 0x17864
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x17855
jmp 0x17864
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x1, 0x88(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)