LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_mod
subtilis_exp_t *subtilis_type_if_mod(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1 = subtilis_type_if_to_int(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a2);
		return NULL;
	}

	a2 = subtilis_type_if_to_int(p, a2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	return prv_call_binary_fn(p, a1, a2, prv_type_map[a1->type.type]->mod,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49439
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4949d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4946a
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4949d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8b3cb(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x198(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x49010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_divr
subtilis_exp_t *subtilis_type_if_divr(subtilis_parser_t *p, subtilis_exp_t *a1,
				      subtilis_exp_t *a2, subtilis_error_t *err)
{
	bool swapped;

	a1 = subtilis_type_if_to_float64(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a2);
		return NULL;
	}

	a2 = subtilis_type_if_to_float64(p, a2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	swapped = prv_order_expressions(&a1, &a2);
	return prv_call_binary_nc_fn(
	    p, a1, a2, prv_type_map[a1->type.type]->divr, swapped, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x48ae0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x494f9
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x49578
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x48ae0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4952a
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x49578
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x48e90
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8b2f9(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x1a0(%rax), %rcx
movb -0x29(%rbp), %al
movq -0x28(%rbp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x48f20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_call_binary_nc_logical_fn
static subtilis_exp_t *prv_call_binary_nc_logical_fn(
	subtilis_parser_t *p, subtilis_exp_t *a1, subtilis_exp_t *a2,
	subtilis_type_if_binary_nc_t fn, bool swapped, subtilis_error_t *err)

/* clang-format on */
{
	subtilis_exp_t *e;

	if (!fn) {
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	e = fn(p, a1, a2, swapped, err);

	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	if (e->type.type == SUBTILIS_TYPE_REAL) {
		e->type.type = SUBTILIS_TYPE_INTEGER;
	} else if ((e->type.type != SUBTILIS_TYPE_INTEGER) &&
		   (e->type.type != SUBTILIS_TYPE_CONST_INTEGER)) {
		subtilis_error_set_assertion_failed(err);
		subtilis_exp_delete(e);
		e = NULL;
	}
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x49664
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rdi
movl $0xf, %esi
leaq 0x62cf0(%rip), %rdx     # 0xac33d
movl $0x8b, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x496f6
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %r8
andb $0x1, %cl
movzbl %cl, %ecx
callq *%rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4969a
movq $0x0, -0x8(%rbp)
jmp 0x496f6
movq -0x40(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x496af
movq -0x40(%rbp), %rax
movl $0x5, (%rax)
jmp 0x496ee
movq -0x40(%rbp), %rax
cmpl $0x5, (%rax)
je 0x496ec
movq -0x40(%rbp), %rax
cmpl $0x1, (%rax)
je 0x496ec
movq -0x38(%rbp), %rdi
movl $0xf, %esi
leaq 0x62c6c(%rip), %rdx     # 0xac33d
movl $0x97, %ecx
callq 0x158e0
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x40(%rbp)
jmp 0x496ee
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_lsl
subtilis_exp_t *subtilis_type_if_lsl(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)

{
	if (!subtilis_type_if_is_integer(&a1->type)) {
		a1 = subtilis_type_if_to_int(p, a1, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			subtilis_exp_delete(a2);
			return NULL;
		}
	}

	if (!subtilis_type_if_is_integer(&a2->type)) {
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			subtilis_exp_delete(a1);
			return NULL;
		}
	}

	return prv_call_binary_fn(p, a1, a2, prv_type_map[a1->type.type]->lsl,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x499a0
testb $0x1, %al
jne 0x49918
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49916
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4998b
jmp 0x49918
movq -0x20(%rbp), %rdi
callq 0x499a0
testb $0x1, %al
jne 0x49958
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49956
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4998b
jmp 0x49958
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8aedd(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x1d0(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x49010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_lsr
subtilis_exp_t *subtilis_type_if_lsr(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)

{
	if (!subtilis_type_if_is_integer(&a1->type)) {
		a1 = subtilis_type_if_to_int(p, a1, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			subtilis_exp_delete(a2);
			return NULL;
		}
	}

	if (!subtilis_type_if_is_integer(&a2->type)) {
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			subtilis_exp_delete(a1);
			return NULL;
		}
	}

	return prv_call_binary_fn(p, a1, a2, prv_type_map[a1->type.type]->lsr,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x499a0
testb $0x1, %al
jne 0x49a48
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49a46
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x49abb
jmp 0x49a48
movq -0x20(%rbp), %rdi
callq 0x499a0
testb $0x1, %al
jne 0x49a88
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49a86
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x49abb
jmp 0x49a88
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8adad(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x1d8(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x49010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_asr
subtilis_exp_t *subtilis_type_if_asr(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)

{
	if (!subtilis_type_if_is_integer(&a1->type)) {
		a1 = subtilis_type_if_to_int(p, a1, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			subtilis_exp_delete(a2);
			return NULL;
		}
	}

	if (!subtilis_type_if_is_integer(&a2->type)) {
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			subtilis_exp_delete(a1);
			return NULL;
		}
	}

	return prv_call_binary_fn(p, a1, a2, prv_type_map[a1->type.type]->asr,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x499a0
testb $0x1, %al
jne 0x49b28
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49b26
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x49b9b
jmp 0x49b28
movq -0x20(%rbp), %rdi
callq 0x499a0
testb $0x1, %al
jne 0x49b68
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49b66
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x49b9b
jmp 0x49b68
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8accd(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x1e0(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x49010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_is_inf
subtilis_exp_t *subtilis_type_if_is_inf(subtilis_parser_t *p, subtilis_exp_t *e,
					subtilis_error_t *err)
{
	if (!subtilis_type_if_is_numeric(&e->type)) {
		subtilis_error_set_numeric_expected(
		    err, subtilis_type_name(&e->type), p->l->stream->name,
		    p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}
	return prv_call_unary_fn(p, e, prv_type_map[e->type.type]->is_inf, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x49cd6
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x2c, %esi
leaq 0x615cb(%rip), %rcx     # 0xab276
leaq 0x6268b(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x420, 0x8(%rsp)       # imm = 0x420
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x49d05
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8ab63(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x1f8(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x47c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_call
subtilis_exp_t *subtilis_type_if_call(subtilis_parser_t *p,
				      const subtilis_type_t *type,
				      subtilis_ir_arg_t *args, size_t num_args,
				      subtilis_error_t *err)
{
	subtilis_type_if_call_t fn;

	fn = prv_type_map[type->type]->call;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, type, args, num_args, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8aac5(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x200(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x49dc5
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x6258c(%rip), %rdx     # 0xac33d
movl $0x430, %ecx            # imm = 0x430
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x49de3
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%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/frontend/type_if.c
// Function: subtilis_type_if_call_ptr
subtilis_exp_t *subtilis_type_if_call_ptr(subtilis_parser_t *p,
					  const subtilis_type_t *type,
					  subtilis_ir_arg_t *args,
					  size_t num_args, size_t ptr,
					  subtilis_error_t *err)
{
	subtilis_type_if_call_ptr_t fn;

	fn = prv_type_map[type->type]->call_ptr;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, type, args, num_args, ptr, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8aa31(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x208(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x49e59
movq -0x38(%rbp), %rdi
movl $0xf, %esi
leaq 0x624f8(%rip), %rdx     # 0xac33d
movl $0x440, %ecx            # imm = 0x440
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x49e7b
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_ret
void subtilis_type_if_ret(subtilis_parser_t *p, const subtilis_type_t *type,
			  size_t reg, subtilis_error_t *err)
{
	subtilis_type_if_reg_t fn;

	fn = prv_type_map[type->type]->ret;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, reg, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a999(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x210(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x49ee9
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x62460(%rip), %rdx     # 0xac33d
movl $0x44d, %ecx            # imm = 0x44D
callq 0x158e0
jmp 0x49efb
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_print
void subtilis_type_if_print(subtilis_parser_t *p, subtilis_exp_t *e,
			    subtilis_error_t *err)
{
	subtilis_type_if_print_t fn;
	char error_buffer[128];

	fn = prv_type_map[e->type.type]->print;
	if (!fn) {
		snprintf(error_buffer, 128, "print on %s",
			 subtilis_type_name(&e->type));
		subtilis_error_set_not_supported(
		    err, error_buffer, p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return;
	}
	fn(p, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a91a(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x218(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x49fd4
leaq -0xa0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e190
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl $0x80, %esi
leaq 0x623f6(%rip), %rdx     # 0xac373
movb $0x0, %al
callq 0x12100
movq -0x18(%rbp), %rdi
leaq -0xa0(%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 $0x13, %esi
leaq 0x612c5(%rip), %rcx     # 0xab276
leaq 0x62385(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x45e, 0x8(%rsp)       # imm = 0x45E
callq 0x156d0
movq -0x10(%rbp), %rdi
callq 0x36ee0
jmp 0x49fe6
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_is_scalar_ref
bool subtilis_type_if_is_scalar_ref(const subtilis_type_t *type,
				    subtilis_error_t *err)
{
	subtilis_type_t element_type;
	bool retval;

	if (subtilis_type_if_is_array(type) ||
	    subtilis_type_if_is_vector(type)) {
		prv_type_map[type->type]->element_type(type, &element_type,
						       err);
		if (err->type != SUBTILIS_ERROR_OK)
			return false;
		if ((type->type == SUBTILIS_TYPE_ARRAY_REC) ||
		    (type->type == SUBTILIS_TYPE_VECTOR_REC))
			retval = subtilis_type_rec_is_scalar(&element_type);
		else
			retval = subtilis_type_if_is_numeric(&element_type) ||
				 element_type.type == SUBTILIS_TYPE_FN;
		subtilis_type_free(&element_type);
		return retval;
	}

	return (type->type == SUBTILIS_TYPE_STRING);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49ff0
testb $0x1, %al
jne 0x4a122
movq -0x10(%rbp), %rdi
callq 0x4a040
testb $0x1, %al
jne 0x4a122
jmp 0x4a1d9
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a71f(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x80(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x160(%rbp), %rsi
callq *%rax
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4a15f
movb $0x0, -0x1(%rbp)
jmp 0x4a1e8
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
je 0x4a171
movq -0x10(%rbp), %rax
cmpl $0x15, (%rax)
jne 0x4a187
leaq -0x160(%rbp), %rdi
callq 0x3f160
andb $0x1, %al
movb %al, -0x161(%rbp)
jmp 0x4a1c0
leaq -0x160(%rbp), %rdi
callq 0x49d10
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x162(%rbp)
jne 0x4a1b2
cmpl $0x9, -0x160(%rbp)
sete %al
movb %al, -0x162(%rbp)
movb -0x162(%rbp), %al
andb $0x1, %al
movb %al, -0x161(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x3e100
movb -0x161(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4a1e8
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_is_serializable_ref
bool subtilis_type_if_is_serializable_ref(const subtilis_type_t *type,
					  subtilis_error_t *err)
{
	subtilis_type_t element_type;
	bool retval;

	if (subtilis_type_if_is_array(type) ||
	    subtilis_type_if_is_vector(type)) {
		prv_type_map[type->type]->element_type(type, &element_type,
						       err);
		if (err->type != SUBTILIS_ERROR_OK)
			return false;
		if ((type->type == SUBTILIS_TYPE_ARRAY_REC) ||
		    (type->type == SUBTILIS_TYPE_VECTOR_REC))
			retval = subtilis_type_rec_serializable(&element_type);
		else
			retval = subtilis_type_if_is_numeric(&element_type);
		subtilis_type_free(&element_type);
		return retval;
	}

	return (type->type == SUBTILIS_TYPE_STRING);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49ff0
testb $0x1, %al
jne 0x4a232
movq -0x10(%rbp), %rdi
callq 0x4a040
testb $0x1, %al
jne 0x4a232
jmp 0x4a2c1
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a60f(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x80(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x160(%rbp), %rsi
callq *%rax
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4a26c
movb $0x0, -0x1(%rbp)
jmp 0x4a2d0
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
je 0x4a27e
movq -0x10(%rbp), %rax
cmpl $0x15, (%rax)
jne 0x4a294
leaq -0x160(%rbp), %rdi
callq 0x3f220
andb $0x1, %al
movb %al, -0x161(%rbp)
jmp 0x4a2a8
leaq -0x160(%rbp), %rdi
callq 0x49d10
andb $0x1, %al
movb %al, -0x161(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x3e100
movb -0x161(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4a2d0
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_coerce_type
subtilis_exp_t *subtilis_type_if_coerce_type(subtilis_parser_t *p,
					     subtilis_exp_t *e,
					     const subtilis_type_t *type,
					     subtilis_error_t *err)
{
	subtilis_type_if_coerce_t fn;

	if (subtilis_type_eq(type, &e->type))
		return e;

	fn = prv_type_map[e->type.type]->coerce;
	if (!fn) {
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return fn(p, e, type, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d880
testb $0x1, %al
jne 0x4a30b
jmp 0x4a318
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a3c6
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a529(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x138(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a3ac
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e190
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x45, %esi
leaq 0x61fb5(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x4d3, 0x8(%rsp)       # imm = 0x4D3
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4a3c6
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_swap_reg_reg
void subtilis_type_if_swap_reg_reg(subtilis_parser_t *p,
				   const subtilis_type_t *type, size_t reg1,
				   size_t reg2, subtilis_error_t *err)
{
	subtilis_type_if_swap_t fn;

	fn = prv_type_map[type->type]->swap_reg_reg;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, reg1, reg2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a455(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x228(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a42d
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x61f1c(%rip), %rdx     # 0xac33d
movl $0x4e3, %ecx            # imm = 0x4E3
callq 0x158e0
jmp 0x4a447
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_swap_reg_mem
void subtilis_type_if_swap_reg_mem(subtilis_parser_t *p,
				   const subtilis_type_t *type, size_t reg1,
				   size_t reg2, subtilis_error_t *err)
{
	subtilis_type_if_swap_t fn;

	fn = prv_type_map[type->type]->swap_reg_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, reg1, reg2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a3d5(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x230(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a4ad
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x61e9c(%rip), %rdx     # 0xac33d
movl $0x4f1, %ecx            # imm = 0x4F1
callq 0x158e0
jmp 0x4a4c7
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_swap_mem_mem
void subtilis_type_if_swap_mem_mem(subtilis_parser_t *p,
				   const subtilis_type_t *type, size_t reg1,
				   size_t reg2, subtilis_error_t *err)
{
	subtilis_type_if_swap_t fn;

	fn = prv_type_map[type->type]->swap_mem_mem;
	if (!fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	fn(p, type, reg1, reg2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a355(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x238(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a52d
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x61e1c(%rip), %rdx     # 0xac33d
movl $0x4ff, %ecx            # imm = 0x4FF
callq 0x158e0
jmp 0x4a547
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_destructor
size_t subtilis_type_if_destructor(subtilis_parser_t *p,
				   const subtilis_type_t *type,
				   subtilis_error_t *err)
{
	subtilis_type_if_destruct_t fn;

	fn = prv_type_map[type->type]->destructor;
	if (!fn)
		return SIZE_MAX;

	return fn(p, type, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8a2bd(%rip), %rax     # 0xd4850
movq (%rax,%rcx,8), %rax
movq 0x220(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4a5b3
movq $-0x1, -0x8(%rbp)
jmp 0x4a5c9
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_diag_expected_error
void subtilis_type_diag_expected_error(subtilis_parser_t *p,
				       const char *expected,
				       const subtilis_type_t *t1,
				       const char *subtilis_file,
				       unsigned int subtilis_line,
				       subtilis_error_t *err)
{
	subtilis_error_t err1;
	subtilis_buffer_t buf1;

	subtilis_error_init(&err1);
	subtilis_buffer_init(&buf1, 64);
	subtilis_full_type_name(t1, &buf1, &err1);
	if (err1.type != SUBTILIS_ERROR_OK)
		goto cleanup;
	subtilis_buffer_zero_terminate(&buf1, &err1);
	if (err1.type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_error_set_expected(err, expected,
				    subtilis_buffer_get_string(&buf1),
				    subtilis_file, subtilis_line);
	subtilis_buffer_free(&buf1);

	return;

cleanup:
	subtilis_error_set_expected(err, expected, subtilis_type_name(t1),
				    subtilis_file, subtilis_line);
	subtilis_buffer_free(&buf1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc80, %rsp            # imm = 0xC80
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq -0xc3c(%rbp), %rdi
callq 0x15670
leaq -0xc50(%rbp), %rdi
movl $0x40, %esi
callq 0x15f80
movq -0x18(%rbp), %rdi
leaq -0xc50(%rbp), %rsi
leaq -0xc3c(%rbp), %rdx
callq 0x3e1f0
cmpl $0x0, -0xc3c(%rbp)
je 0x4a645
jmp 0x4a6c9
leaq -0xc50(%rbp), %rdi
leaq -0xc3c(%rbp), %rsi
callq 0x16560
cmpl $0x0, -0xc3c(%rbp)
je 0x4a663
jmp 0x4a6c9
movq -0x30(%rbp), %rax
movq %rax, -0xc60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc58(%rbp)
leaq -0xc50(%rbp), %rdi
callq 0x16760
movq -0xc60(%rbp), %rdi
movq -0xc58(%rbp), %rdx
movq %rax, %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
movl $0x1d, %esi
leaq 0x61c93(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x52c, 0x8(%rsp)       # imm = 0x52C
callq 0x156d0
leaq -0xc50(%rbp), %rdi
callq 0x16650
jmp 0x4a72a
movq -0x30(%rbp), %rax
movq %rax, -0xc70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0xc70(%rbp), %rdi
movq -0xc68(%rbp), %rdx
movq %rax, %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
movl $0x1d, %esi
leaq 0x61c30(%rip), %rax     # 0xac33d
movq %rax, (%rsp)
movl $0x533, 0x8(%rsp)       # imm = 0x533
callq 0x156d0
leaq -0xc50(%rbp), %rdi
callq 0x16650
addq $0xc80, %rsp            # imm = 0xC80
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_custom_diag_error
void subtilis_type_custom_diag_error(subtilis_parser_t *p,
				     const subtilis_type_t *t1,
				     const subtilis_type_t *t2, void *ud,
				     subtilis_type_cmp_diag_fn_t diag_fn,
				     subtilis_error_t *err)
{
	subtilis_error_t err1;
	subtilis_buffer_t buf1;
	subtilis_buffer_t buf2;

	subtilis_error_init(&err1);
	subtilis_buffer_init(&buf1, 64);
	subtilis_buffer_init(&buf2, 64);
	subtilis_full_type_name(t1, &buf1, &err1);
	if (err1.type != SUBTILIS_ERROR_OK)
		goto cleanup;
	subtilis_buffer_zero_terminate(&buf1, &err1);
	if (err1.type != SUBTILIS_ERROR_OK)
		goto cleanup;
	subtilis_full_type_name(t2, &buf2, &err1);
	if (err1.type != SUBTILIS_ERROR_OK)
		goto cleanup;
	subtilis_buffer_zero_terminate(&buf2, &err1);
	if (err1.type != SUBTILIS_ERROR_OK)
		goto cleanup;

	diag_fn(p, subtilis_buffer_get_string(&buf1),
		subtilis_buffer_get_string(&buf2), ud, err);
	subtilis_buffer_free(&buf2);
	subtilis_buffer_free(&buf1);

	return;

cleanup:
	diag_fn(p, subtilis_type_name(t1), subtilis_type_name(t2), ud, err);
	subtilis_buffer_free(&buf2);
	subtilis_buffer_free(&buf1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc90, %rsp            # imm = 0xC90
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0xc3c(%rbp), %rdi
callq 0x15670
leaq -0xc50(%rbp), %rdi
movl $0x40, %esi
callq 0x15f80
leaq -0xc60(%rbp), %rdi
movl $0x40, %esi
callq 0x15f80
movq -0x10(%rbp), %rdi
leaq -0xc50(%rbp), %rsi
leaq -0xc3c(%rbp), %rdx
callq 0x3e1f0
cmpl $0x0, -0xc3c(%rbp)
je 0x4a7b6
jmp 0x4a88b
leaq -0xc50(%rbp), %rdi
leaq -0xc3c(%rbp), %rsi
callq 0x16560
cmpl $0x0, -0xc3c(%rbp)
je 0x4a7d7
jmp 0x4a88b
movq -0x18(%rbp), %rdi
leaq -0xc60(%rbp), %rsi
leaq -0xc3c(%rbp), %rdx
callq 0x3e1f0
cmpl $0x0, -0xc3c(%rbp)
je 0x4a7fc
jmp 0x4a88b
leaq -0xc60(%rbp), %rdi
leaq -0xc3c(%rbp), %rsi
callq 0x16560
cmpl $0x0, -0xc3c(%rbp)
je 0x4a81a
jmp 0x4a88b
movq -0x28(%rbp), %rax
movq %rax, -0xc68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc78(%rbp)
leaq -0xc50(%rbp), %rdi
callq 0x16760
movq %rax, -0xc70(%rbp)
leaq -0xc60(%rbp), %rdi
callq 0x16760
movq -0xc78(%rbp), %rdi
movq -0xc70(%rbp), %rsi
movq %rax, %rdx
movq -0xc68(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
leaq -0xc60(%rbp), %rdi
callq 0x16650
leaq -0xc50(%rbp), %rdi
callq 0x16650
jmp 0x4a8f4
movq -0x28(%rbp), %rax
movq %rax, -0xc80(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e190
movq %rax, -0xc88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq -0xc90(%rbp), %rdi
movq -0xc88(%rbp), %rsi
movq %rax, %rdx
movq -0xc80(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
leaq -0xc60(%rbp), %rdi
callq 0x16650
leaq -0xc50(%rbp), %rdi
callq 0x16650
addq $0xc90, %rsp            # imm = 0xC90
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_exp_to_var_const
static subtilis_exp_t *prv_exp_to_var_const(subtilis_parser_t *p,
					    subtilis_exp_t *e,
					    subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e2;

	reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_REAL, e->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	e2 = subtilis_exp_new_real_var(reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	subtilis_exp_delete(e);

	return e2;

on_error:
	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x1c, %esi
callq 0x38490
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4aae4
jmp 0x4ab15
movq -0x28(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x377d0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4ab02
jmp 0x4ab15
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4ab26
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_assign_to_reg_const
static void prv_assign_to_reg_const(subtilis_parser_t *p, size_t reg,
				    subtilis_exp_t *e, subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	subtilis_ir_operand_t op2;

	op0.reg = reg;
	op2.integer = 0;
	subtilis_ir_section_add_instr_reg(p->current,
					  SUBTILIS_OP_INSTR_MOVI_REAL, op0,
					  e->exp.ir_op, op2, err);
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %rdx
movq 0x148(%rax), %rcx
movq -0x30(%rbp), %r8
movl $0x1c, %esi
callq 0x38360
movq -0x18(%rbp), %rdi
callq 0x36ee0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_assign_to_mem_const
static void prv_assign_to_mem_const(subtilis_parser_t *p, size_t mem_reg,
				    size_t loc, subtilis_exp_t *e,
				    subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;

	op0.reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_REAL, e->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	op1.reg = mem_reg;
	op2.integer = (int32_t)loc;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_REAL, op0, op1, op2, err);

cleanup:
	subtilis_exp_delete(e);
}

// 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 -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x1c, %esi
callq 0x38490
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4ac2c
jmp 0x4ac5d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x18, %esi
callq 0x38360
movq -0x20(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_to_string_const
static subtilis_exp_t *prv_to_string_const(subtilis_parser_t *p,
					   subtilis_exp_t *e,
					   subtilis_error_t *err)
{
	char buf[32];
	size_t len = sprintf(buf, "%.10g", e->exp.ir_op.real) + 1;

	e->type.type = SUBTILIS_TYPE_CONST_STRING;
	subtilis_buffer_init(&e->exp.str, 128);
	subtilis_buffer_append(&e->exp.str, buf, len, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x148(%rax), %xmm0
leaq 0x616fd(%rip), %rsi     # 0xac3f8
movb $0x1, %al
callq 0x12250
addl $0x1, %eax
cltq
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movl $0x80, %esi
callq 0x15f80
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x16200
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4ad62
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4ad6a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_coerce_type_const
static subtilis_exp_t *prv_coerce_type_const(subtilis_parser_t *p,
					     subtilis_exp_t *e,
					     const subtilis_type_t *type,
					     subtilis_error_t *err)
{
	switch (type->type) {
	case SUBTILIS_TYPE_CONST_REAL:
		break;
	case SUBTILIS_TYPE_CONST_INTEGER:
		e->type.type = SUBTILIS_TYPE_CONST_INTEGER;
		e->exp.ir_op.integer = (int32_t)e->exp.ir_op.integer;
		break;
	case SUBTILIS_TYPE_REAL:
		e = subtilis_type_if_exp_to_var(p, e, err);
		break;
	case SUBTILIS_TYPE_INTEGER:
		e = subtilis_type_if_exp_to_var(p, e, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
		e = subtilis_type_if_to_int(p, e, err);
		break;
	case SUBTILIS_TYPE_BYTE:
		e = subtilis_type_if_exp_to_var(p, e, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
		e = subtilis_type_if_to_byte(p, e, err);
		break;
	default:
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x6, %rax
ja 0x4ae89
movq -0x30(%rbp), %rax
leaq 0x615c9(%rip), %rcx     # 0xac380
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x4aef8
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movl 0x148(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x148(%rax)
jmp 0x4aef8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
jmp 0x4aef8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4ae2d
movq $0x0, -0x8(%rbp)
jmp 0x4af00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x18(%rbp)
jmp 0x4aef8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4ae72
movq $0x0, -0x8(%rbp)
jmp 0x4af00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x48980
movq %rax, -0x18(%rbp)
jmp 0x4aef8
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e190
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x45, %esi
leaq 0x6152a(%rip), %rax     # 0xac3fe
movq %rax, (%rsp)
movl $0xc5, 0x8(%rsp)
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4af00
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_add_const
static subtilis_exp_t *prv_add_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, bool swapped,
				     subtilis_error_t *err)
{
	/* a2 must be const */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		a1->exp.ir_op.real =
		    ((double)a2->exp.ir_op.integer) + a1->exp.ir_op.real;
		a1->type.type = SUBTILIS_TYPE_CONST_REAL;
		break;
	case SUBTILIS_TYPE_CONST_REAL:
		a1->exp.ir_op.real += a2->exp.ir_op.real;
		break;
	default:
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		return NULL;
	}

	subtilis_exp_delete(a2);
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
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 -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x4afc8
jmp 0x4af8e
movl -0x34(%rbp), %eax
subl $0x1, %eax
jne 0x4afea
jmp 0x4af98
movq -0x20(%rbp), %rax
cvtsi2sdl 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
addsd 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x148(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x4b036
movq -0x20(%rbp), %rax
movsd 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
addsd 0x148(%rax), %xmm0
movsd %xmm0, 0x148(%rax)
jmp 0x4b036
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x19, %esi
leaq 0x613dd(%rip), %r8      # 0xac3fe
movl $0xe8, %r9d
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x4b047
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_mul_const
static subtilis_exp_t *prv_mul_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/* a2 must be const */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		a1->exp.ir_op.real =
		    ((double)a2->exp.ir_op.integer) * a1->exp.ir_op.real;
		a1->type.type = SUBTILIS_TYPE_CONST_REAL;
		break;
	case SUBTILIS_TYPE_CONST_REAL:
		a1->exp.ir_op.real *= a2->exp.ir_op.real;
		break;
	default:
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		return NULL;
	}

	subtilis_exp_delete(a2);
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x4b0c1
jmp 0x4b087
movl -0x2c(%rbp), %eax
subl $0x1, %eax
jne 0x4b0e3
jmp 0x4b091
movq -0x20(%rbp), %rax
cvtsi2sdl 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x148(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x4b12f
movq -0x20(%rbp), %rax
movsd 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x148(%rax), %xmm0
movsd %xmm0, 0x148(%rax)
jmp 0x4b12f
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x19, %esi
leaq 0x612e4(%rip), %r8      # 0xac3fe
movl $0x102, %r9d            # imm = 0x102
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x4b140
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_and_const
static subtilis_exp_t *prv_and_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/* a2 must be const */

	prv_args_to_int(p, a1, a2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	a1->exp.ir_op.integer &= a2->exp.ir_op.integer;
	subtilis_exp_delete(a2);
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4d6b0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4b190
movq $0x0, -0x8(%rbp)
jmp 0x4b1bb
movq -0x20(%rbp), %rax
movl 0x148(%rax), %ecx
movq -0x18(%rbp), %rax
andl 0x148(%rax), %ecx
movl %ecx, 0x148(%rax)
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)