LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_assign_array
static void prv_assign_array(subtilis_parser_t *p, subtilis_token_t *t,
			     const char *var_name,
			     const subtilis_type_t *id_type,
			     subtilis_error_t *err)
{
	subtilis_type_t array_type;
	subtilis_exp_t *indices[SUBTILIS_MAX_DIMENSIONS];
	size_t dims = 0;

	array_type.type = SUBTILIS_TYPE_VOID;
	subtilis_type_if_array_of(id_type, &array_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dims = subtilis_var_bracketed_int_args_have_b(
	    p, t, indices, SUBTILIS_MAX_DIMENSIONS, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		prv_check_bad_def(p, var_name, err);
		goto cleanup;
	}

	prv_assign_array_or_vector(p, t, dims, indices, var_name, &array_type,
				   true, err);

cleanup:

	subtilis_type_free(&array_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x1c8(%rbp)
movl $0x8, -0x170(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rsi
callq 0x479c0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1c026
jmp 0x1c0a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x1c0(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0xa, %ecx
callq 0x251f0
movq %rax, -0x1c8(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1c066
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1ccd0
jmp 0x1c09c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1c8(%rbp), %rdx
leaq -0x1c0(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %rax
leaq -0x170(%rbp), %r9
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1cdc0
leaq -0x170(%rbp), %rdi
callq 0x3e100
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_assign_vector
static void prv_assign_vector(subtilis_parser_t *p, subtilis_token_t *t,
			      const char *var_name,
			      const subtilis_type_t *id_type,
			      subtilis_error_t *err)
{
	subtilis_type_t vector_type;
	subtilis_exp_t *indices[1];
	size_t dims = 0;

	vector_type.type = SUBTILIS_TYPE_VOID;
	subtilis_type_if_vector_of(id_type, &vector_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	indices[0] = subtilis_curly_bracketed_arg_have_b(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	if (indices[0])
		dims = 1;

	prv_assign_array_or_vector(p, t, dims, indices, var_name, &vector_type,
				   false, err);

cleanup:
	subtilis_type_free(&vector_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x180(%rbp)
movl $0x8, -0x170(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rsi
callq 0x47a50
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1c113
jmp 0x1c190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x259e0
movq %rax, -0x178(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1c136
jmp 0x1c184
cmpq $0x0, -0x178(%rbp)
je 0x1c14b
movq $0x1, -0x180(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x180(%rbp), %rdx
leaq -0x178(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %rax
leaq -0x170(%rbp), %r9
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1cdc0
leaq -0x170(%rbp), %rdi
callq 0x3e100
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_assignment_operator
static subtilis_exp_t *prv_assignment_operator(subtilis_parser_t *p,
					       const char *var_name,
					       subtilis_exp_t *e,
					       subtilis_assign_type_t at,
					       subtilis_error_t *err)
{
	subtilis_exp_t *var;

	if (at == SUBTILIS_ASSIGN_TYPE_EQUAL)
		return e;

	var = subtilis_var_lookup_var(p, var_name, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (at == SUBTILIS_ASSIGN_TYPE_PLUS_EQUAL)
		e = subtilis_exp_add(p, var, e, err);
	else
		e = subtilis_type_if_sub(p, var, e, err);

	var = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_exp_delete(var);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1c91e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c9af
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x47240
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1c93e
jmp 0x1c995
cmpl $0x1, -0x24(%rbp)
jne 0x1c95f
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x37bd0
movq %rax, -0x20(%rbp)
jmp 0x1c978
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x492c0
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1c98b
jmp 0x1c995
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c9af
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: subtilis_parser_let
void subtilis_parser_let(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	const char *tbuf;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if (t->type != SUBTILIS_TOKEN_IDENTIFIER) {
		tbuf = subtilis_token_get_text(t);
		subtilis_error_set_id_expected(err, tbuf, p->l->stream->name,
					       p->l->line);
		return;
	}

	subtilis_parser_assignment(p, t, err);
}

// 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
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x133f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1c9f3
jmp 0x1ca5e
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
je 0x1ca4d
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x12, %esi
leaq 0x8e843(%rip), %rcx     # 0xab276
leaq 0x8db82(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x4cb, 0x8(%rsp)       # imm = 0x4CB
callq 0x156d0
jmp 0x1ca5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1b800
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_check_bad_def
static void prv_check_bad_def(subtilis_parser_t *p, const char *var_name,
			      subtilis_error_t *err)
{
	if (!strncmp(var_name, "DEFPROC", 7) ||
	    !strncmp(var_name, "defPROC", 7))
		subtilis_error_set_defproc_should_be_def_proc(
		    err, p->l->stream->name, p->l->line);
	else if (!strncmp(var_name, "DEFFN", 5) ||
		 !strncmp(var_name, "defFN", 5))
		subtilis_error_set_deffn_should_be_def_fn(
		    err, p->l->stream->name, p->l->line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8d903(%rip), %rsi     # 0xaa5f2
movl $0x7, %edx
callq 0x12050
cmpl $0x0, %eax
je 0x1cd18
movq -0x10(%rbp), %rdi
leaq 0x8d8f1(%rip), %rsi     # 0xaa5fa
movl $0x7, %edx
callq 0x12050
cmpl $0x0, %eax
jne 0x1cd4a
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 $0x50, %esi
leaq 0x8d87f(%rip), %r8      # 0xaa5bc
movl $0x83, %r9d
callq 0x15930
jmp 0x1cdb0
movq -0x10(%rbp), %rdi
leaq 0x8d8ad(%rip), %rsi     # 0xaa602
movl $0x5, %edx
callq 0x12050
cmpl $0x0, %eax
je 0x1cd7e
movq -0x10(%rbp), %rdi
leaq 0x8d899(%rip), %rsi     # 0xaa608
movl $0x5, %edx
callq 0x12050
cmpl $0x0, %eax
jne 0x1cdae
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 $0x51, %esi
leaq 0x8d819(%rip), %r8      # 0xaa5bc
movl $0x87, %r9d
callq 0x15930
jmp 0x1cdb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_get_ass_op
static subtilis_assign_type_t
prv_get_ass_op(subtilis_parser_t *p, subtilis_token_t *t, subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_assign_type_t at = SUBTILIS_ASSIGN_TYPE_UNKNOWN;

	tbuf = subtilis_token_get_text(t);
	if (t->type != SUBTILIS_TOKEN_OPERATOR) {
		subtilis_error_set_assignment_op_expected(
		    err, tbuf, p->l->stream->name, p->l->line);
		return at;
	}

	if (!strcmp(tbuf, "=")) {
		at = SUBTILIS_ASSIGN_TYPE_EQUAL;
	} else if (!strcmp(tbuf, "+=")) {
		at = SUBTILIS_ASSIGN_TYPE_PLUS_EQUAL;
	} else if (!strcmp(tbuf, "-=")) {
		at = SUBTILIS_ASSIGN_TYPE_MINUS_EQUAL;
	} else if (!strcmp(tbuf, ":=")) {
		at = SUBTILIS_ASSIGN_TYPE_CREATE_EQUAL;
	} else {
		subtilis_error_set_assignment_op_expected(
		    err, tbuf, p->l->stream->name, p->l->line);
	}

	return at;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x4, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x1d8be
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x14, %esi
leaq 0x8d9db(%rip), %rcx     # 0xab276
leaq 0x8cd1a(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x9c, 0x8(%rsp)
callq 0x156d0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d98a
movq -0x28(%rbp), %rdi
leaq 0x8cd4b(%rip), %rsi     # 0xaa614
callq 0x12140
cmpl $0x0, %eax
jne 0x1d8df
movl $0x0, -0x2c(%rbp)
jmp 0x1d984
movq -0x28(%rbp), %rdi
leaq 0x8cd02(%rip), %rsi     # 0xaa5ec
callq 0x12140
cmpl $0x0, %eax
jne 0x1d900
movl $0x1, -0x2c(%rbp)
jmp 0x1d982
movq -0x28(%rbp), %rdi
leaq 0x8cce4(%rip), %rsi     # 0xaa5ef
callq 0x12140
cmpl $0x0, %eax
jne 0x1d91e
movl $0x2, -0x2c(%rbp)
jmp 0x1d980
movq -0x28(%rbp), %rdi
leaq 0x8d09e(%rip), %rsi     # 0xaa9c7
callq 0x12140
cmpl $0x0, %eax
jne 0x1d93c
movl $0x3, -0x2c(%rbp)
jmp 0x1d97e
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x14, %esi
leaq 0x8d910(%rip), %rcx     # 0xab276
leaq 0x8cc4f(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0xaa, 0x8(%rsp)
callq 0x156d0
jmp 0x1d980
jmp 0x1d982
jmp 0x1d984
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_assign_string_field
static void prv_assign_string_field(subtilis_parser_t *p, subtilis_token_t *t,
				    const subtilis_type_t *type, size_t reg,
				    size_t loc, subtilis_error_t *err)
{
	subtilis_assign_type_t at;
	subtilis_exp_t *e = NULL;
	const char *tbuf = subtilis_token_get_text(t);

	if (t->type != SUBTILIS_TOKEN_OPERATOR)
		goto assignment_expected;

	if (!strcmp(tbuf, "="))
		at = SUBTILIS_ASSIGN_TYPE_EQUAL;
	else if (!strcmp(tbuf, "+="))
		at = SUBTILIS_ASSIGN_TYPE_PLUS_EQUAL;
	else
		goto assignment_expected;

	e = subtilis_parser_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (at == SUBTILIS_ASSIGN_TYPE_EQUAL)
		subtilis_type_if_assign_ref(p, type, reg, loc, e, err);
	else
		subtilis_string_type_add_eq(p, reg, loc, e, err);

	return;

assignment_expected:
	subtilis_error_set_assignment_op_expected(err, tbuf, p->l->stream->name,
						  p->l->line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x1d9e3
jmp 0x1da86
movq -0x48(%rbp), %rdi
leaq 0x8cc26(%rip), %rsi     # 0xaa614
callq 0x12140
cmpl $0x0, %eax
jne 0x1da01
movl $0x0, -0x34(%rbp)
jmp 0x1da23
movq -0x48(%rbp), %rdi
leaq 0x8cbe0(%rip), %rsi     # 0xaa5ec
callq 0x12140
cmpl $0x0, %eax
jne 0x1da1f
movl $0x1, -0x34(%rbp)
jmp 0x1da21
jmp 0x1da86
jmp 0x1da23
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x24a20
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1da46
jmp 0x1dac8
cmpl $0x0, -0x34(%rbp)
jne 0x1da6b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x477a0
jmp 0x1da84
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x6b320
jmp 0x1dac8
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x14, %esi
leaq 0x8d7c6(%rip), %rcx     # 0xab276
leaq 0x8cb05(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x301, 0x8(%rsp)       # imm = 0x301
callq 0x156d0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_assign_array_field
static void prv_assign_array_field(subtilis_parser_t *p, subtilis_token_t *t,
				   const subtilis_array_desc_t *d,
				   subtilis_error_t *err)
{
	subtilis_exp_t *indices[SUBTILIS_MAX_DIMENSIONS];
	const char *tbuf;
	size_t dims = 0;

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_OPERATOR) || strcmp(tbuf, "(")) {
		subtilis_error_set_expected(err, "(", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

	dims = subtilis_var_bracketed_int_args_have_b(
	    p, t, indices, SUBTILIS_MAX_DIMENSIONS, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_error_set_expected(err, "(", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

	prv_assign_array_or_vector_field(p, t, d, indices, dims, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x1dcbe
movq -0x78(%rbp), %rdi
leaq 0x8d5e8(%rip), %rsi     # 0xab29c
callq 0x12140
cmpl $0x0, %eax
je 0x1dd05
movq -0x20(%rbp), %rdi
movq -0x78(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x8d5b4(%rip), %rdx     # 0xab29c
leaq 0x8c8cd(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x37c, 0x8(%rsp)       # imm = 0x37C
callq 0x156d0
jmp 0x1dd8d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0xa, %ecx
callq 0x251f0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1dd70
movq -0x20(%rbp), %rdi
movq -0x78(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x8d546(%rip), %rdx     # 0xab29c
leaq 0x8c85f(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x384, 0x8(%rsp)       # imm = 0x384
callq 0x156d0
jmp 0x1dd8d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rcx
movq -0x80(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x1de90
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_assignment.c
// Function: prv_assign_vector_field
static void prv_assign_vector_field(subtilis_parser_t *p, subtilis_token_t *t,
				    const subtilis_array_desc_t *d,
				    subtilis_error_t *err)
{
	subtilis_exp_t *indices[1];
	const char *tbuf;
	size_t dims = 0;

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_OPERATOR) || strcmp(tbuf, "{")) {
		subtilis_error_set_expected(err, "{", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

	indices[0] = subtilis_curly_bracketed_arg_have_b(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if (indices[0])
		dims = 1;

	prv_assign_array_or_vector_field(p, t, d, indices, dims, err);
}

// 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 $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x1ddeb
movq -0x30(%rbp), %rdi
leaq 0x8f82a(%rip), %rsi     # 0xad60b
callq 0x12140
cmpl $0x0, %eax
je 0x1de2f
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x1d, %esi
leaq 0x8f7f6(%rip), %rdx     # 0xad60b
leaq 0x8c7a0(%rip), %rax     # 0xaa5bc
movq %rax, (%rsp)
movl $0x396, 0x8(%rsp)       # imm = 0x396
callq 0x156d0
jmp 0x1de7b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x259e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1de4f
jmp 0x1de7b
cmpq $0x0, -0x28(%rbp)
je 0x1de5e
movq $0x1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x1de90
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_vector_fn_type
static void prv_process_vector_fn_type(subtilis_parser_t *p, const char *name,
				       subtilis_type_t *fn_type,
				       subtilis_error_t *err)
{
	subtilis_type_t fn_type_old;

	if (fn_type->type == SUBTILIS_TYPE_VOID) {
		subtilis_error_set_bad_proc_name(err, name, p->l->stream->name,
						 p->l->line);
		return;
	}

	subtilis_type_init_copy(&fn_type_old, fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_type_if_vector_of(&fn_type_old, fn_type, err);
	subtilis_type_free(&fn_type_old);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	fn_type->params.array.num_dims = 1;
	fn_type->params.array.dims[0] = SUBTILIS_DYNAMIC_DIMENSION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x1e978
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0xb, %esi
leaq 0x8c918(%rip), %rcx     # 0xab276
leaq 0x8bccb(%rip), %rax     # 0xaa630
movq %rax, (%rsp)
movl $0x142, 0x8(%rsp)       # imm = 0x142
callq 0x156d0
jmp 0x1e9d8
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x168(%rbp), %rdi
callq 0x3dec0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1e997
jmp 0x1e9d8
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x168(%rbp), %rdi
callq 0x47a50
leaq -0x168(%rbp), %rdi
callq 0x3e100
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1e9c2
jmp 0x1e9d8
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_parser_to_ir_args
static subtilis_ir_arg_t *prv_parser_to_ir_args(subtilis_parser_param_t *params,
						size_t num_params,
						subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_arg_t *args = malloc(sizeof(*args) * num_params);

	if (!args) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	for (i = 0; i < num_params; i++) {
		args[i].type = subtilis_type_if_reg_type(&params[i].type);
		args[i].reg = params[i].reg;
		args[i].nop = params[i].nop;
	}

	return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
imulq $0x18, -0x18(%rbp), %rdi
callq 0x121b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1ef20
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x8b727(%rip), %rdx     # 0xaa630
movl $0x31, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x1efbf
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1efb7
movq -0x10(%rbp), %rdi
imulq $0x158, -0x28(%rbp), %rax # imm = 0x158
addq %rax, %rdi
callq 0x4a550
movl %eax, %ecx
movq -0x30(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
imulq $0x158, -0x28(%rbp), %rcx # imm = 0x158
addq %rcx, %rax
movq 0x148(%rax), %rcx
movq -0x30(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
imulq $0x158, -0x28(%rbp), %rcx # imm = 0x158
addq %rcx, %rax
movq 0x150(%rax), %rcx
movq -0x30(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1ef28
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_parser_to_ptypes
static subtilis_type_t *prv_parser_to_ptypes(subtilis_parser_param_t *params,
					     size_t num_params,
					     subtilis_error_t *err)
{
	size_t i;
	subtilis_type_t *ptypes = malloc(sizeof(*ptypes) * num_params);

	if (!ptypes) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	for (i = 0; i < num_params; i++) {
		subtilis_type_init_copy(&ptypes[i], &params[i].type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

	return ptypes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
imulq $0x148, -0x18(%rbp), %rdi # imm = 0x148
callq 0x121b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1f020
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x8b624(%rip), %rdx     # 0xaa630
movl $0x46, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x1f084
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1f07c
movq -0x30(%rbp), %rdi
imulq $0x148, -0x28(%rbp), %rax # imm = 0x148
addq %rax, %rdi
movq -0x10(%rbp), %rsi
imulq $0x158, -0x28(%rbp), %rax # imm = 0x158
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x3dec0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1f06c
movq $0x0, -0x8(%rbp)
jmp 0x1f084
jmp 0x1f06e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f028
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_delete_params
static void prv_delete_params(subtilis_parser_param_t *params, size_t num_args)
{
	size_t i;

	if (!params)
		return;

	for (i = 0; i < num_args; i++)
		subtilis_type_free(&params[i].type);

	free(params);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1f0a9
jmp 0x1f0e6
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1f0dd
movq -0x8(%rbp), %rdi
imulq $0x158, -0x18(%rbp), %rax # imm = 0x158
addq %rax, %rdi
callq 0x3e100
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1f0b1
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_complete_fn_name
static char *prv_complete_fn_name(char *name, const subtilis_type_t *fn_type,
				  subtilis_error_t *err)
{
	char buffer[64];
	int ptr;
	int name_len;
	char *new_name;

	if (subtilis_type_if_is_array(fn_type)) {
		ptr = snprintf(buffer, 64, "(%d)",
			       fn_type->params.array.num_dims);
		if (ptr >= 64) {
			subtilis_error_set_assertion_failed(err);
			goto on_error;
		}
	} else if (subtilis_type_if_is_vector(fn_type)) {
		buffer[0] = '{';
		buffer[1] = '}';
		buffer[2] = 0;
		ptr = 2;
	} else {
		return name;
	}

	name_len = strlen(name);
	new_name = realloc(name, name_len + ptr + 1);
	if (!new_name) {
		subtilis_error_set_oom(err);
		goto on_error;
	}
	strcpy(new_name + name_len, buffer);

	return new_name;

on_error:
	free(name);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x49ff0
testb $0x1, %al
jne 0x1f113
jmp 0x1f15b
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x40, %esi
leaq 0x8b529(%rip), %rdx     # 0xaa653
movb $0x0, %al
callq 0x12100
movl %eax, -0x64(%rbp)
cmpl $0x40, -0x64(%rbp)
jl 0x1f159
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x8b4e6(%rip), %rdx     # 0xaa630
movl $0x162, %ecx            # imm = 0x162
callq 0x158e0
jmp 0x1f1f1
jmp 0x1f18b
movq -0x18(%rbp), %rdi
callq 0x4a040
testb $0x1, %al
jne 0x1f16a
jmp 0x1f17f
movb $0x7b, -0x60(%rbp)
movb $0x7d, -0x5f(%rbp)
movb $0x0, -0x5e(%rbp)
movl $0x2, -0x64(%rbp)
jmp 0x1f189
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f202
jmp 0x1f18b
movq -0x10(%rbp), %rdi
callq 0x120d0
movl %eax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movl -0x68(%rbp), %eax
addl -0x64(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x121e0
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jne 0x1f1d3
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x8b469(%rip), %rdx     # 0xaa630
movl $0x171, %ecx            # imm = 0x171
callq 0x158e0
jmp 0x1f1f1
movq -0x70(%rbp), %rdi
movslq -0x68(%rbp), %rax
addq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x12060
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f202
movq -0x10(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_delete_ptypes
static void prv_delete_ptypes(subtilis_type_t *ptypes, size_t num_args)
{
	size_t i;

	if (!ptypes)
		return;

	for (i = 0; i < num_args; i++)
		subtilis_type_free(&ptypes[i]);

	free(ptypes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1f229
jmp 0x1f266
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1f25d
movq -0x8(%rbp), %rdi
imulq $0x148, -0x18(%rbp), %rax # imm = 0x148
addq %rax, %rdi
callq 0x3e100
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1f231
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_def
void subtilis_parser_def(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_error_t *err)
{
	subtilis_type_t return_type;
	subtilis_type_t section_type;
	subtilis_symbol_table_t *local_st = NULL;
	char *name = NULL;

	return_type.type = SUBTILIS_TYPE_VOID;
	section_type.type = SUBTILIS_TYPE_VOID;

	if (p->current != p->main) {
		subtilis_error_set_nested_procedure(err, p->l->stream->name,
						    p->l->line);
		return;
	}

	local_st = subtilis_symbol_table_new(err);
	p->local_st = local_st;
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

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

	name = prv_initial_proc_fn_type(p, t, &return_type, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	prv_def_internal(p, t, &return_type, &section_type, name, local_st,
			 NULL, err);
	name = NULL;

on_error:

	subtilis_symbol_table_delete(local_st);
	free(name);
	subtilis_type_free(&section_type);
	subtilis_type_free(&return_type);
	p->local_st = p->main_st;
	p->current = p->main;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x2b0(%rbp)
movq $0x0, -0x2b8(%rbp)
movl $0x8, -0x160(%rbp)
movl $0x8, -0x2a8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
je 0x1f2eb
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 $0x21, %esi
callq 0x158e0
jmp 0x1f3fb
movq -0x18(%rbp), %rdi
callq 0x3c180
movq %rax, -0x2b0(%rbp)
movq -0x2b0(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1f318
jmp 0x1f3ab
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 0x1f337
jmp 0x1f3ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %r8
leaq -0x160(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1f410
movq %rax, -0x2b8(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1f363
jmp 0x1f3ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x2b8(%rbp), %r8
movq -0x2b0(%rbp), %r9
movq -0x18(%rbp), %rax
leaq -0x160(%rbp), %rdx
leaq -0x2a8(%rbp), %rcx
xorl %r10d, %r10d
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1f510
movq $0x0, -0x2b8(%rbp)
movq -0x2b0(%rbp), %rdi
callq 0x3c2b0
movq -0x2b8(%rbp), %rdi
callq 0x12290
leaq -0x2a8(%rbp), %rdi
callq 0x3e100
leaq -0x160(%rbp), %rdi
callq 0x3e100
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_initial_proc_fn_type
static char *prv_initial_proc_fn_type(subtilis_parser_t *p, subtilis_token_t *t,
				      subtilis_type_t *ftype, bool keep_prefix,
				      subtilis_error_t *err)
{
	subtilis_type_t fn_type;
	char *name = NULL;

	fn_type.type = SUBTILIS_TYPE_VOID;

	name = prv_proc_name_and_type(p, t, &fn_type, keep_prefix, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	prv_complete_proc_fn_type(p, t, &fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_type_copy(ftype, &fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	subtilis_type_free(&fn_type);
	return name;

on_error:
	subtilis_type_free(&fn_type);
	free(name);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x180(%rbp)
movl $0x8, -0x178(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x21(%rbp), %al
movq -0x30(%rbp), %r8
leaq -0x178(%rbp), %rdx
andb $0x1, %al
movzbl %al, %ecx
callq 0x1e750
movq %rax, -0x180(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1f479
jmp 0x1f4d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq -0x178(%rbp), %rdx
callq 0x219f0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1f49c
jmp 0x1f4d4
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x178(%rbp), %rsi
callq 0x3e4f0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1f4bb
jmp 0x1f4d4
leaq -0x178(%rbp), %rdi
callq 0x3e100
movq -0x180(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f4f4
leaq -0x178(%rbp), %rdi
callq 0x3e100
movq -0x180(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_lambda
subtilis_exp_t *subtilis_parser_lambda(subtilis_parser_t *p,
				       subtilis_token_t *t,
				       subtilis_error_t *err)
{
	size_t call_index;
	size_t call_reg;
	subtilis_type_t type;
	subtilis_ir_operand_t op1;
	subtilis_exp_t *e = NULL;

	type.type = SUBTILIS_TYPE_VOID;

	call_index = prv_lambda_internal(p, t, &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	op1.label = call_index;
	call_reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_GET_PROC_ADDR, op1, err);

	e = subtilis_exp_new_fn(call_reg, &type, err);

on_error:
	subtilis_type_free(&type);

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x180(%rbp)
movl $0x8, -0x170(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x170(%rbp), %rdx
callq 0x1faa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1fa33
jmp 0x1fa7a
movq -0x20(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x178(%rbp), %rdx
movl $0x9b, %esi
callq 0x38490
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x170(%rbp), %rsi
callq 0x379d0
movq %rax, -0x180(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x3e100
movq -0x180(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_lambda_internal
static size_t prv_lambda_internal(subtilis_parser_t *p, subtilis_token_t *t,
				  subtilis_type_t *type, subtilis_error_t *err)
{
	subtilis_type_t return_type;
	subtilis_type_t section_type;
	subtilis_symbol_table_t *old_local_st;
	subtilis_ir_section_t *old_current;
	size_t call_index = SIZE_MAX;
	subtilis_symbol_table_t *local_st = NULL;
	char *name = NULL;

	section_type.type = SUBTILIS_TYPE_VOID;
	return_type.type = SUBTILIS_TYPE_VOID;
	old_current = p->current;
	old_local_st = p->local_st;

	local_st = subtilis_symbol_table_new(err);
	p->local_st = local_st;
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	name = prv_initial_lambda_proc_fn_type(p, t, &return_type, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	prv_def_internal(p, t, &return_type, &section_type, name, local_st,
			 &call_index, err);
	name = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_type_copy(type, &section_type, err);

on_error:

	subtilis_symbol_table_delete(local_st);
	free(name);
	subtilis_type_free(&section_type);
	subtilis_type_free(&return_type);
	p->local_st = old_local_st;
	p->current = old_current;

	return call_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp            # imm = 0x2F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $-0x1, -0x2c8(%rbp)
movq $0x0, -0x2d0(%rbp)
movq $0x0, -0x2d8(%rbp)
movl $0x8, -0x2b0(%rbp)
movl $0x8, -0x168(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x2c0(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x2b8(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3c180
movq %rax, -0x2d0(%rbp)
movq -0x2d0(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1fb3b
jmp 0x1fbce
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %r8
leaq -0x168(%rbp), %rdx
xorl %ecx, %ecx
callq 0x22cc0
movq %rax, -0x2d8(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1fb67
jmp 0x1fbce
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x2d8(%rbp), %r8
movq -0x2d0(%rbp), %r9
movq -0x20(%rbp), %rax
leaq -0x168(%rbp), %rdx
leaq -0x2b0(%rbp), %rcx
leaq -0x2c8(%rbp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1f510
movq $0x0, -0x2d8(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1fbba
jmp 0x1fbce
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x2b0(%rbp), %rsi
callq 0x3e4f0
movq -0x2d0(%rbp), %rdi
callq 0x3c2b0
movq -0x2d8(%rbp), %rdi
callq 0x12290
leaq -0x2b0(%rbp), %rdi
callq 0x3e100
leaq -0x168(%rbp), %rdi
callq 0x3e100
movq -0x2b8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x2c0(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x2c8(%rbp), %rax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_call_ptr
subtilis_exp_t *subtilis_parser_call_ptr(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 const subtilis_symbol_t *s,
					 const char *var_name, size_t mem_reg,
					 subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e;

	if (!s->is_reg) {
		e = subtilis_type_if_load_from_mem(p, &s->t, mem_reg, s->loc,
						   err);
		reg = e->exp.ir_op.reg;
		subtilis_exp_delete(e);
	} else {
		reg = s->loc;
	}

	return subtilis_parser_call_known_ptr(p, t, &s->t, reg, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x2a8(%rax)
jne 0x200fb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %r8
callq 0x48080
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x36ee0
jmp 0x20106
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1fc30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_parse_param_type
static void prv_parse_param_type(subtilis_parser_t *p, subtilis_token_t *t,
				 subtilis_type_t *ptype, subtilis_error_t *err)
{
	subtilis_type_t type;
	const char *tbuf = subtilis_token_get_text(t);

	subtilis_type_init_copy(&type, &t->tok.id_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if ((type.type == SUBTILIS_TYPE_FN) ||
	    (type.type == SUBTILIS_TYPE_REC)) {
		subtilis_complete_custom_type(p, tbuf, &type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

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

	tbuf = subtilis_token_get_text(t);

	if ((t->type == SUBTILIS_TOKEN_OPERATOR) && (!strcmp(tbuf, "(")))
		prv_process_array_param_type(p, t, &type, ptype, err);
	else if ((t->type == SUBTILIS_TOKEN_OPERATOR) && (!strcmp(tbuf, "{")))
		prv_process_vector_param_type(p, t, &type, ptype, err);
	else
		/* numeric or reference type */

		subtilis_type_copy(ptype, &type, err);

cleanup:

	subtilis_type_free(&type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x170(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
leaq -0x168(%rbp), %rdi
callq 0x3dec0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x208c1
jmp 0x209d2
cmpl $0x9, -0x168(%rbp)
je 0x208d3
cmpl $0x16, -0x168(%rbp)
jne 0x208fe
movq -0x8(%rbp), %rdi
movq -0x170(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x168(%rbp), %rdx
callq 0x25e50
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x208fc
jmp 0x209c6
jmp 0x208fe
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x133f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20920
jmp 0x209c6
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x170(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2096f
movq -0x170(%rbp), %rdi
leaq 0x8a955(%rip), %rsi     # 0xab29c
callq 0x12140
cmpl $0x0, %eax
jne 0x2096f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x168(%rbp), %rdx
callq 0x22a90
jmp 0x209c4
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x209ae
movq -0x170(%rbp), %rdi
leaq 0x8cc85(%rip), %rsi     # 0xad60b
callq 0x12140
cmpl $0x0, %eax
jne 0x209ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x168(%rbp), %rdx
callq 0x22bb0
jmp 0x209c2
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x168(%rbp), %rsi
callq 0x3e4f0
jmp 0x209c4
jmp 0x209c6
leaq -0x168(%rbp), %rdi
callq 0x3e100
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_unwind
void subtilis_parser_unwind(subtilis_parser_t *p, subtilis_error_t *err)
{
	subtilis_ir_operand_t start_label;
	subtilis_ir_operand_t start_inner_label;
	subtilis_ir_operand_t end_label;
	subtilis_ir_operand_t counter;

	if (p->current->cleanup_stack == SIZE_MAX)
		return;

	start_label.label = subtilis_ir_section_new_label(p->current);
	start_inner_label.label = subtilis_ir_section_new_label(p->current);
	end_label.label = subtilis_ir_section_new_label(p->current);
	counter.reg = p->current->cleanup_stack;

	subtilis_ir_section_add_label(p->current, start_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(p->current, SUBTILIS_OP_INSTR_JMPC,
					  counter, start_inner_label, end_label,
					  err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_ir_section_add_label(p->current, start_inner_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_reference_type_pop_and_deref(p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_no_reg(p->current, SUBTILIS_OP_INSTR_JMP,
					     start_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_label(p->current, end_label.label, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $-0x1, 0xb8(%rax)
jne 0x20a07
jmp 0x20b0f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x39960
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20a70
jmp 0x20b0f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %r9
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x43, %esi
callq 0x38360
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20a9d
jmp 0x20b0f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x39960
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20abd
jmp 0x20b0f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6f360
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20ad5
jmp 0x20b0f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20afa
jmp 0x20b0f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x39960
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: subtilis_parser_return
void subtilis_parser_return(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	subtilis_exp_t *e;
	subtilis_type_t fn_type;
	subtilis_ir_operand_t end_label;

	if (p->current == p->main) {
		subtilis_error_set_return_in_main(err, p->l->stream->name,
						  p->l->line);
		return;
	}

	subtilis_type_init_copy(&fn_type,
				p->current->type->type.params.fn.ret_val, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if (fn_type.type == SUBTILIS_TYPE_VOID) {
		subtilis_error_set_return_in_proc(err, p->l->stream->name,
						  p->l->line);
		goto cleanup;
	}

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

	/* Ownership of e is passed to add_fn_ret */

	prv_set_fn_retval(p, e, &fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	end_label.label = p->current->end_label;
	subtilis_ir_section_add_instr_no_reg(p->current, SUBTILIS_OP_INSTR_JMP,
					     end_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	p->current->endproc = true;

cleanup:
	subtilis_type_free(&fn_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
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
jne 0x20b7e
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 $0x2f, %esi
leaq 0x89ac2(%rip), %r8      # 0xaa630
movl $0x6c0, %r9d            # imm = 0x6C0
callq 0x15930
jmp 0x20c86
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
leaq -0x168(%rbp), %rdi
callq 0x3dec0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20bac
jmp 0x20c86
cmpl $0x8, -0x168(%rbp)
jne 0x20bea
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 $0x30, %esi
leaq 0x89a56(%rip), %r8      # 0xaa630
movl $0x6ca, %r9d            # imm = 0x6CA
callq 0x15930
jmp 0x20c7a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24a20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20c0a
jmp 0x20c7a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x168(%rbp), %rdx
callq 0x20c90
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20c2d
jmp 0x20c7a
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x98(%rax), %rax
movq %rax, -0x170(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x170(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20c6b
jmp 0x20c7a
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x1, 0x88(%rax)
leaq -0x168(%rbp), %rdi
callq 0x3e100
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_set_fn_retval
static void prv_set_fn_retval(subtilis_parser_t *p, subtilis_exp_t *e,
			      const subtilis_type_t *fn_type,
			      subtilis_error_t *err)
{
	e = subtilis_type_if_coerce_type(p, e, fn_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_type_if_assign_to_reg(p, p->current->ret_reg, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4a2e0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20ccc
jmp 0x20cec
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0xa8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x47ea0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)