LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_string
subtilis_exp_t *subtilis_type_if_to_string(subtilis_parser_t *p,
					   subtilis_exp_t *e,
					   subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->to_string) {
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type),
		    subtilis_type_name(&subtilis_type_string),
		    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]->to_string,
				 err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
leaq 0x6a637(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x128(%rax), %rax
testq %rax, %rax
je 0x36b6f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f882
movq %rax, %r12
leaq 0x3e007(%rip), %rdi     # 0x74b88
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e79c(%rip), %r10     # 0x75334
movq %r14, %rdi
movl $0x45, %esi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x2f1                  # imm = 0x2F1
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_hex_string
subtilis_exp_t *subtilis_type_if_to_hex_string(subtilis_parser_t *p,
					       subtilis_exp_t *e,
					       subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->to_hex_string) {
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type),
		    subtilis_type_name(&subtilis_type_string),
		    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]->to_hex_string, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
leaq 0x6a59a(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x130(%rax), %rax
testq %rax, %rax
je 0x36c0c
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f882
movq %rax, %r12
leaq 0x3df6a(%rip), %rdi     # 0x74b88
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e6ff(%rip), %r10     # 0x75334
movq %r14, %rdi
movl $0x45, %esi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x301                  # imm = 0x301
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_add
subtilis_exp_t *subtilis_type_if_add(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/*
	 * Irritatingly, string addition is not commutative.
	 */

	bool swapped = prv_order_expressions(&a1, &a2);

	return prv_call_binary_nc_fn(
	    p, a1, a2, prv_type_map[a1->type.type]->add, swapped, err);
}

// Assembly:
movq %rcx, %r9
movl (%rdx), %eax
leaq 0x6a4ef(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, (%rax)
je 0x36c9f
xorl %r8d, %r8d
jmp 0x36ca8
movl (%rsi), %eax
movq (%rcx,%rax,8), %rax
movb (%rax), %r8b
testb %r8b, %r8b
movq %rsi, %rax
cmovneq %rdx, %rax
cmovneq %rsi, %rdx
movl (%rax), %esi
movq (%rcx,%rsi,8), %rcx
movq 0x148(%rcx), %rcx
movzbl %r8b, %r8d
movq %rax, %rsi
jmp 0x36ccc
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_call_binary_nc_fn
static subtilis_exp_t *
prv_call_binary_nc_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)
{
	if (!fn) {
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	return fn(p, a1, a2, swapped, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdx, %r14
testq %rcx, %rcx
je 0x36cf1
movq %rcx, %rax
movzbl %r8b, %ecx
movq %r14, %rdx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq %rsi, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
leaq 0x3e62c(%rip), %rdx     # 0x75334
movq %rbx, %rdi
movl $0xf, %esi
movl $0x78, %ecx
callq 0x145f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_call_binary_fn
static subtilis_exp_t *
prv_call_binary_fn(subtilis_parser_t *p, subtilis_exp_t *a1, subtilis_exp_t *a2,
		   subtilis_type_if_binary_t fn, subtilis_error_t *err)
{
	if (!fn) {
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}
	return fn(p, a1, a2, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
testq %rcx, %rcx
je 0x36d85
movq %rcx, %rax
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq %rsi, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
leaq 0x3e598(%rip), %rdx     # 0x75334
movq %rbx, %rdi
movl $0xf, %esi
movl $0x6a, %ecx
callq 0x145f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_div
subtilis_exp_t *subtilis_type_if_div(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]->div,
				  err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
movq %rcx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x36f90
movq %r12, %rdi
jmp 0x36fa9
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x36fbc
movq %r15, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %ecx
leaq 0x6a1ba(%rip), %rdx     # 0xa1180
movq (%rdx,%rcx,8), %rcx
movq 0x190(%rcx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36d64
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
movq %rcx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x37010
movq %r12, %rdi
jmp 0x37029
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x3703c
movq %r15, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %ecx
leaq 0x6a13a(%rip), %rdx     # 0xa1180
movq (%rdx,%rcx,8), %rcx
movq 0x198(%rcx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36d64
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
movl (%rsi), %eax
leaq 0x6a0f8(%rip), %r13     # 0xa1180
movq (%r13,%rax,8), %rax
movq 0x120(%rax), %rdx
callq 0x36282
cmpl $0x0, (%rbx)
je 0x370a3
movq %r12, %rdi
jmp 0x370cc
movq %rax, %r15
movl (%r12), %eax
movq (%r13,%rax,8), %rax
movq 0x120(%rax), %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x36282
cmpl $0x0, (%rbx)
je 0x370dd
movq %r15, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl (%rax), %ecx
movq (%r13,%rcx,8), %rcx
cmpb $0x0, (%rcx)
je 0x370ed
xorl %edx, %edx
jmp 0x370f7
movl (%r15), %ecx
movq (%r13,%rcx,8), %rcx
movb (%rcx), %dl
testb %dl, %dl
movq %r15, %rsi
cmovneq %rax, %rsi
cmovneq %r15, %rax
movl (%rsi), %ecx
movq (%r13,%rcx,8), %rcx
movq 0x1a0(%rcx), %rcx
movzbl %dl, %r8d
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x36ccc
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdx, %r14
testq %rcx, %rcx
je 0x371b4
movq %rcx, %rax
movzbl %r8b, %ecx
movq %r14, %rdx
movq %rbx, %r8
callq *%rax
cmpl $0x0, (%rbx)
jne 0x371dd
movq %rax, %r14
movl (%rax), %eax
cmpl $0x1, %eax
je 0x371e0
cmpl $0x5, %eax
je 0x371e0
cmpl $0x4, %eax
jne 0x371eb
movl $0x5, (%r14)
jmp 0x371e0
movq %rsi, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
leaq 0x3e169(%rip), %rdx     # 0x75334
movq %rbx, %rdi
movl $0xf, %esi
movl $0x8b, %ecx
callq 0x145f4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3e142(%rip), %rdx     # 0x75334
movq %rbx, %rdi
movl $0xf, %esi
movl $0x97, %ecx
callq 0x145f4
movq %r14, %rdi
callq 0x2b4c3
jmp 0x371dd
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x37367
leaq 0x69e23(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x37382
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x3737f
movq %r14, %rdi
jmp 0x373b6
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x373a0
leaq 0x69dea(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x373cc
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x373c9
movq %r15, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x69daa(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x1d0(%rax), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36d64
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x3744c
leaq 0x69d3e(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x37467
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x37464
movq %r14, %rdi
jmp 0x3749b
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x37485
leaq 0x69d05(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x374b1
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x374ae
movq %r15, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x69cc5(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x1d8(%rax), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36d64
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x37513
leaq 0x69c77(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x3752e
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x3752b
movq %r14, %rdi
jmp 0x37562
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x3754c
leaq 0x69c3e(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x37578
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
je 0x37575
movq %r15, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x69bfe(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x1e0(%rax), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36d64
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x3762a
leaq 0x69b7e(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rdx
cmpb $0x0, 0x1(%rdx)
je 0x3762a
movq (%rcx,%rax,8), %rax
movq 0x1f8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x36282
movq %rbx, %rdi
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3dcf0(%rip), %r10     # 0x75334
leaq 0x3c7aa(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x2c, %esi
movq %rax, %rdx
pushq $0x420                  # imm = 0x420
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %eax
leaq 0x69ae3(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x200(%rax), %rax
testq %rax, %rax
je 0x376af
jmpq *%rax
pushq %rax
leaq 0x3dc7d(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x430, %ecx            # imm = 0x430
callq 0x145f4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %eax
leaq 0x69aaa(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x208(%rax), %rax
testq %rax, %rax
je 0x376e8
jmpq *%rax
pushq %rax
leaq 0x3dc44(%rip), %rdx     # 0x75334
movq %r9, %rdi
movl $0xf, %esi
movl $0x440, %ecx            # imm = 0x440
callq 0x145f4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %eax
leaq 0x69a71(%rip), %rsi     # 0xa1180
movq (%rsi,%rax,8), %rax
movq 0x210(%rax), %rax
testq %rax, %rax
je 0x37727
movq %rdx, %rsi
movq %rcx, %rdx
jmpq *%rax
leaq 0x3dc06(%rip), %rdx     # 0x75334
movq %rcx, %rdi
movl $0xf, %esi
movl $0x44d, %ecx            # imm = 0x44D
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
leaq 0x69a20(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x218(%rax), %rax
testq %rax, %rax
je 0x37789
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f882
leaq 0x3dbd2(%rip), %rdx     # 0x7536a
movq %rsp, %r12
movl $0x80, %esi
movq %r12, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x12120
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x3db75(%rip), %rax     # 0x75334
leaq 0x3c62f(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x13, %esi
movq %r12, %rdx
pushq $0x45e                  # imm = 0x45E
pushq %rax
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movl (%rdi), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
jne 0x37875
cmpl $0x7, %eax
sete %bl
jmp 0x37901
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x698fe(%rip), %r15     # 0xa1180
movq (%r15,%rax,8), %rdx
cmpb $0x0, 0x3(%rdx)
je 0x378ab
movq (%r15,%rax,8), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x80(%rax)
cmpl $0x0, (%r14)
je 0x378bc
xorl %ebx, %ebx
jmp 0x37901
cmpl $0x8, %ecx
je 0x3786a
movq (%r15,%rax,8), %rcx
cmpb $0x1, 0x4(%rcx)
jne 0x3786a
jmp 0x3788c
movl (%rbx), %eax
cmpl $0x15, %eax
je 0x378c8
cmpl $0xf, %eax
jne 0x378d6
leaq 0x8(%rsp), %rdi
callq 0x301d0
movl %eax, %ebx
jmp 0x378f7
movl 0x8(%rsp), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
jne 0x378e8
xorl %ecx, %ecx
jmp 0x378ef
movq (%r15,%rax,8), %rcx
movb 0x1(%rcx), %cl
cmpl $0x9, %eax
sete %bl
orb %cl, %bl
leaq 0x8(%rsp), %rdi
callq 0x2f843
movl %ebx, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movl (%rdi), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
jne 0x37930
cmpl $0x7, %eax
sete %bl
jmp 0x37999
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x69843(%rip), %r15     # 0xa1180
movq (%r15,%rax,8), %rdx
cmpb $0x0, 0x3(%rdx)
je 0x37966
movq (%r15,%rax,8), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x80(%rax)
cmpl $0x0, (%r14)
je 0x37977
xorl %ebx, %ebx
jmp 0x37999
cmpl $0x8, %ecx
je 0x37928
movq (%r15,%rax,8), %rcx
cmpb $0x1, 0x4(%rcx)
jne 0x37928
jmp 0x37947
movl (%rbx), %eax
cmpl $0x15, %eax
je 0x37983
cmpl $0xf, %eax
jne 0x379a8
leaq 0x8(%rsp), %rdi
callq 0x3024d
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2f843
movl %ebx, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
movl 0x8(%rsp), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
jne 0x379ba
xorl %ebx, %ebx
jmp 0x3798f
movq (%r15,%rax,8), %rax
movb 0x1(%rax), %bl
jmp 0x3798f
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2f3e4
testb %al, %al
jne 0x37a61
movl (%rbx), %eax
leaq 0x69793(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x138(%rax), %rax
testq %rax, %rax
je 0x37a14
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f882
movq %rax, %r13
movq %r12, %rdi
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3d8fb(%rip), %r10     # 0x75334
movq %r14, %rdi
movl $0x45, %esi
movq %r13, %rdx
movq %rax, %rcx
pushq $0x4d3                  # imm = 0x4D3
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %eax
leaq 0x69709(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x228(%rax), %rax
testq %rax, %rax
je 0x37a89
jmpq *%rax
leaq 0x3d8a4(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x4e3, %ecx            # imm = 0x4E3
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %eax
leaq 0x696d5(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x230(%rax), %rax
testq %rax, %rax
je 0x37abd
jmpq *%rax
leaq 0x3d870(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x4f1, %ecx            # imm = 0x4F1
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %eax
leaq 0x696a1(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x238(%rax), %rax
testq %rax, %rax
je 0x37af1
jmpq *%rax
leaq 0x3d83c(%rip), %rdx     # 0x75334
movq %r8, %rdi
movl $0xf, %esi
movl $0x4ff, %ecx            # imm = 0x4FF
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc28, %rsp            # imm = 0xC28
movq %r9, %r12
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
leaq 0x1c(%rsp), %rbp
movq %rbp, %rdi
callq 0x14404
leaq 0x8(%rsp), %rbx
movl $0x40, %esi
movq %rbx, %rdi
callq 0x14a40
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x2f8ac
cmpl $0x0, (%rbp)
jne 0x37baa
leaq 0x8(%rsp), %rdi
leaq 0x1c(%rsp), %rbx
movq %rbx, %rsi
callq 0x14d4b
cmpl $0x0, (%rbx)
je 0x37bfb
movq %r13, %rdi
callq 0x2f882
leaq 0x3d77b(%rip), %r10     # 0x75334
movq %r12, %rdi
movl $0x1d, %esi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
movl 0x4(%rsp), %r9d
pushq $0x533                  # imm = 0x533
pushq %r10
callq 0x1442a
addq $0x10, %rsp
leaq 0x8(%rsp), %rdi
callq 0x14da6
addq $0xc28, %rsp            # imm = 0xC28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
callq 0x14dfb
leaq 0x3d728(%rip), %r10     # 0x75334
movq %r12, %rdi
movl $0x1d, %esi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
movl 0x4(%rsp), %r9d
pushq $0x52c                  # imm = 0x52C
jmp 0x37bd4
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc48, %rsp            # imm = 0xC48
movq %r9, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
leaq 0x3c(%rsp), %rbx
movq %rbx, %rdi
callq 0x14404
leaq 0x28(%rsp), %r14
movl $0x40, %esi
movq %r14, %rdi
callq 0x14a40
leaq 0x18(%rsp), %rdi
movl $0x40, %esi
callq 0x14a40
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f8ac
cmpl $0x0, (%rbx)
jne 0x37cd9
leaq 0x28(%rsp), %rdi
leaq 0x3c(%rsp), %rbx
movq %rbx, %rsi
callq 0x14d4b
cmpl $0x0, (%rbx)
jne 0x37cd9
leaq 0x18(%rsp), %rsi
leaq 0x3c(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rdx
callq 0x2f8ac
cmpl $0x0, (%rbx)
jne 0x37cd9
leaq 0x18(%rsp), %rdi
leaq 0x3c(%rsp), %rbx
movq %rbx, %rsi
callq 0x14d4b
cmpl $0x0, (%rbx)
je 0x37d27
movq %rbp, %rdi
callq 0x2f882
movq %rax, %rbx
movq %r13, %rdi
callq 0x2f882
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
callq *0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x14da6
leaq 0x28(%rsp), %rdi
callq 0x14da6
addq $0xc48, %rsp            # imm = 0xC48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x14dfb
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x14dfb
jmp 0x37cec
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x48(%rdi), %rdi
movq 0x148(%rsi), %rdx
movl $0x1c, %esi
movq %r14, %rcx
callq 0x2c189
cmpl $0x0, (%r14)
jne 0x37e85
movl %eax, %edi
movq %r14, %rsi
callq 0x2baf9
cmpl $0x0, (%r14)
je 0x37e99
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x2b4c3
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x37e88
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq 0x48(%rdi), %rdi
movq 0x148(%rcx), %rdx
movl $0x1c, %esi
movq %r8, %rcx
callq 0x2c189
cmpl $0x0, (%r14)
jne 0x37f2c
movq 0x48(%r13), %rdi
movl %r12d, %r8d
movl $0x18, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %r14, %r9
callq 0x2c0c2
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x148(%rsi), %r15
movsd 0x148(%rsi), %xmm0
leaq 0x3d496(%rip), %rsi     # 0x75418
movq %rsp, %r12
movq %r12, %rdi
movb $0x1, %al
callq 0x12280
incl %eax
movslq %eax, %r13
movl $0x3, (%rbx)
movl $0x80, %esi
movq %r15, %rdi
callq 0x14a40
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x14b32
cmpl $0x0, (%r14)
je 0x37fc8
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movl (%rdx), %eax
cmpq $0x6, %rax
ja 0x38011
leaq 0x3d37b(%rip), %rcx     # 0x75378
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, (%rbx)
jmp 0x380b6
movq %rbx, %rdi
callq 0x2f882
movq %rax, %r13
movq %r12, %rdi
callq 0x2f882
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3d3e8(%rip), %r10     # 0x7541e
movq %r14, %rdi
movl $0x45, %esi
movq %r13, %rdx
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x1442a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b4c3
jmp 0x380b4
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x36269
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36269
cmpl $0x0, (%r14)
jne 0x380b4
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3691f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36269
cmpl $0x0, (%r14)
je 0x380c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x369a2
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rdx), %eax
testl %eax, %eax
je 0x3812e
cmpl $0x1, %eax
jne 0x38151
cvtsi2sdl 0x148(%r14), %xmm0
addsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movl $0x0, (%rbx)
jmp 0x38147
movsd 0x148(%r14), %xmm0
addsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movq %r14, %rdi
callq 0x2b4c3
jmp 0x3818e
movq %r8, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3d2a5(%rip), %r8      # 0x7541e
movq %r15, %rdi
movl $0x19, %esi
movl $0xe8, %r9d
callq 0x14618
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rdx), %eax
testl %eax, %eax
je 0x381d7
cmpl $0x1, %eax
jne 0x381fa
cvtsi2sdl 0x148(%r14), %xmm0
mulsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movl $0x0, (%rbx)
jmp 0x381f0
movsd 0x148(%r14), %xmm0
mulsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movq %r14, %rdi
callq 0x2b4c3
jmp 0x38237
movq %rcx, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3d1fc(%rip), %r8      # 0x7541e
movq %r15, %rdi
movl $0x19, %esi
movl $0x102, %r9d            # imm = 0x102
callq 0x14618
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
callq 0x396e1
cmpl $0x0, (%r15)
je 0x38263
xorl %ebx, %ebx
jmp 0x38278
movl 0x148(%r14), %eax
andl %eax, 0x148(%rbx)
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_eq_const
static subtilis_exp_t *prv_eq_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.integer =
		    (a1->exp.ir_op.real) == (double)a2->exp.ir_op.integer ? -1
									  : 0;
		a1->type.type = SUBTILIS_TYPE_CONST_INTEGER;
		break;
	case SUBTILIS_TYPE_CONST_REAL:
		a1->exp.ir_op.integer =
		    a1->exp.ir_op.real == a2->exp.ir_op.real ? -1 : 0;
		a1->type.type = SUBTILIS_TYPE_CONST_INTEGER;
		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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rdx), %eax
testl %eax, %eax
je 0x38335
cmpl $0x1, %eax
jne 0x3836a
cvtsi2sdl 0x148(%r14), %xmm0
jmp 0x3833e
movsd 0x148(%r14), %xmm0
cmpeqsd 0x148(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movzbl %al, %eax
negl %eax
movl %eax, 0x148(%rbx)
movl $0x1, (%rbx)
movq %r14, %rdi
callq 0x2b4c3
jmp 0x383a7
movq %rcx, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3d08c(%rip), %r8      # 0x7541e
movq %r15, %rdi
movl $0x19, %esi
movl $0x161, %r9d            # imm = 0x161
callq 0x14618
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_sub_const
static subtilis_exp_t *prv_sub_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 =
		    a1->exp.ir_op.real - ((double)a2->exp.ir_op.integer);
		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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rdx), %eax
testl %eax, %eax
je 0x3848b
cmpl $0x1, %eax
jne 0x384ae
movsd 0x148(%rbx), %xmm0
cvtsi2sdl 0x148(%r14), %xmm1
subsd %xmm1, %xmm0
jmp 0x3849c
movsd 0x148(%rbx), %xmm0
subsd 0x148(%r14), %xmm0
movsd %xmm0, 0x148(%rbx)
movq %r14, %rdi
callq 0x2b4c3
jmp 0x384eb
movq %r8, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3cf48(%rip), %r8      # 0x7541e
movq %r15, %rdi
movl $0x19, %esi
movl $0x198, %r9d            # imm = 0x198
callq 0x14618
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/float64_type.c
// Function: prv_divr_const
static subtilis_exp_t *prv_divr_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				      subtilis_exp_t *a2, bool swapped,
				      subtilis_error_t *err)
{
	/* a2 must be const and a float64*/

	if (a2->exp.ir_op.real == 0) {
		subtilis_error_set_divide_by_zero(err, p->l->stream->name,
						  p->l->line);
		subtilis_exp_delete(a2);
		subtilis_exp_delete(a1);
		return NULL;
	}

	a1->exp.ir_op.real /= a2->exp.ir_op.real;
	subtilis_exp_delete(a2);
	return a1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movsd 0x148(%rdx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3854e
jp 0x3854e
movq (%rdi), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3cef5(%rip), %rax     # 0x7541e
movq %r8, %rdi
movl $0x1a, %esi
movq %rax, %r8
movl $0x1a8, %r9d            # imm = 0x1A8
callq 0x14618
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %r14
xorl %ebx, %ebx
jmp 0x38562
movsd 0x148(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x148(%rbx)
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq