LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_append
void subtilis_type_if_append(subtilis_parser_t *p, subtilis_exp_t *a1,
			     subtilis_exp_t *a2, subtilis_exp_t *gran,
			     subtilis_error_t *err)
{
	subtilis_type_if_append_t fn;

	fn = prv_type_map[a1->type.type]->append;
	if (!fn) {
		subtilis_error_set_expected(err, "string or 1d array",
					    subtilis_type_name(&a1->type),
					    p->l->stream->name, p->l->line);
		goto cleanup;
	}

	fn(p, a1, a2, gran, err);
	return;

cleanup:
	subtilis_exp_delete(gran);
	subtilis_exp_delete(a2);
	subtilis_exp_delete(a1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movl (%rsi), %eax
leaq 0x6aa39(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0xf8(%rax), %rax
testq %rax, %rax
je 0x36771
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f5ad
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ebc8(%rip), %r10     # 0x75354
leaq 0x3ebe4(%rip), %rdx     # 0x75377
movq %r12, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x2a2                  # imm = 0x2A2
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %r15, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_int
subtilis_exp_t *subtilis_type_if_to_int(subtilis_parser_t *p, subtilis_exp_t *e,
					subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->to_int32) {
		subtilis_error_set_integer_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]->to_int32,
				 err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
leaq 0x6a99a(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x108(%rax), %rax
testq %rax, %rax
je 0x36806
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3eb34(%rip), %r10     # 0x75354
leaq 0x3d5ee(%rip), %rcx     # 0x73e15
movq %r14, %rdi
movl $0x17, %esi
movq %rax, %rdx
pushq $0x2b5                  # imm = 0x2B5
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_to_byte
subtilis_exp_t *subtilis_type_if_to_byte(subtilis_parser_t *p,
					 subtilis_exp_t *e,
					 subtilis_error_t *err)
{
	if (subtilis_type_if_is_const(&e->type)) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	if (!prv_type_map[e->type.type]->to_byte) {
		subtilis_error_set_byte_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]->to_byte,
				 err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %ecx
leaq 0x6a917(%rip), %rax     # 0xa1180
movq (%rax,%rcx,8), %rax
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x36895
cmpb $0x1, (%rax)
jne 0x36895
leaq 0x3ead3(%rip), %rdx     # 0x75354
movq %r14, %rdi
movl $0xf, %esi
movl $0x2c2, %ecx            # imm = 0x2C2
callq 0x145a4
jmp 0x368f5
movq 0x118(%rax), %rax
testq %rax, %rax
je 0x368b1
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3ea89(%rip), %r10     # 0x75354
leaq 0x3d543(%rip), %rcx     # 0x73e15
movq %r14, %rdi
movl $0x18, %esi
movq %rax, %rdx
pushq $0x2c9                  # imm = 0x2C9
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/type_if.c
// Function: subtilis_type_if_zerox
subtilis_exp_t *subtilis_type_if_zerox(subtilis_parser_t *p, subtilis_exp_t *e,
				       const subtilis_type_t *type,
				       subtilis_error_t *err)
{
	if (!prv_type_map[e->type.type]->zerox) {
		subtilis_error_set_bad_zero_extend(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return prv_type_map[e->type.type]->zerox(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
movl (%rsi), %eax
leaq 0x6a82c(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x110(%rax), %rax
testq %rax, %rax
je 0x3697b
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 0x2f5ad
movq %rax, %r13
movq %r12, %rdi
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e9b4(%rip), %r10     # 0x75354
movq %r14, %rdi
movl $0x46, %esi
movq %r13, %rdx
movq %rax, %rcx
pushq $0x2e1                  # imm = 0x2E1
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6a794(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x128(%rax), %rax
testq %rax, %rax
je 0x36a12
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 0x2f5ad
movq %rax, %r12
leaq 0x3e184(%rip), %rdi     # 0x74ba8
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e919(%rip), %r10     # 0x75354
movq %r14, %rdi
movl $0x45, %esi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x2f1                  # imm = 0x2F1
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6a6f7(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x130(%rax), %rax
testq %rax, %rax
je 0x36aaf
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 0x2f5ad
movq %rax, %r12
leaq 0x3e0e7(%rip), %rdi     # 0x74ba8
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3e87c(%rip), %r10     # 0x75354
movq %r14, %rdi
movl $0x45, %esi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x301                  # imm = 0x301
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6a64c(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, (%rax)
jne 0x36b53
movl (%rsi), %eax
movq (%rcx,%rax,8), %rax
cmpb $0x1, (%rax)
jne 0x36b53
movb $0x1, %r8b
movq %rdx, %rax
movq %rsi, %rdx
jmp 0x36b59
xorl %r8d, %r8d
movq %rsi, %rax
movl (%rax), %esi
movq (%rcx,%rsi,8), %rcx
movq 0x148(%rcx), %rcx
movzbl %r8b, %r8d
movq %rax, %rsi
jmp 0x36b6f
// File: /workspace/github_c_makefile_star2_O3/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 0x36b94
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 0x2b166
movq %r14, %rdi
callq 0x2b166
leaq 0x3e7a9(%rip), %rdx     # 0x75354
movq %rbx, %rdi
movl $0xf, %esi
movl $0x78, %ecx
callq 0x145a4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x36c2d
movq %rcx, %rax
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq %rsi, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
leaq 0x3e710(%rip), %rdx     # 0x75354
movq %rbx, %rdi
movl $0xf, %esi
movl $0x6a, %ecx
callq 0x145a4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x367cf
cmpl $0x0, (%rbx)
je 0x36e51
movq %r12, %rdi
jmp 0x36e6a
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x36e7d
movq %r15, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %ecx
leaq 0x6a2f9(%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 0x36c0c
// File: /workspace/github_c_makefile_star2_O3/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 0x367cf
cmpl $0x0, (%rbx)
je 0x36ed1
movq %r12, %rdi
jmp 0x36eea
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x36efd
movq %r15, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %ecx
leaq 0x6a279(%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 0x36c0c
// File: /workspace/github_c_makefile_star2_O3/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 0x6a237(%rip), %r13     # 0xa1180
movq (%r13,%rax,8), %rax
movq 0x120(%rax), %rdx
callq 0x36132
cmpl $0x0, (%rbx)
je 0x36f64
movq %r12, %rdi
jmp 0x36f8d
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 0x36132
cmpl $0x0, (%rbx)
je 0x36f9e
movq %r15, %rdi
callq 0x2b166
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)
jne 0x36fc1
movl (%r15), %ecx
movq (%r13,%rcx,8), %rcx
cmpb $0x1, (%rcx)
jne 0x36fc1
movb $0x1, %dl
movq %rax, %rsi
movq %r15, %rax
jmp 0x36fc6
xorl %edx, %edx
movq %r15, %rsi
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 0x36b6f
// File: /workspace/github_c_makefile_star2_O3/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 0x37076
movq %rcx, %rax
movzbl %r8b, %ecx
movq %r14, %rdx
movq %rbx, %r8
callq *%rax
cmpl $0x0, (%rbx)
jne 0x3709f
movq %rax, %r14
movl (%rax), %eax
cmpl $0x1, %eax
je 0x370a2
cmpl $0x5, %eax
je 0x370a2
cmpl $0x4, %eax
jne 0x370ad
movl $0x5, (%r14)
jmp 0x370a2
movq %rsi, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
leaq 0x3e2c7(%rip), %rdx     # 0x75354
movq %rbx, %rdi
movl $0xf, %esi
movl $0x8b, %ecx
callq 0x145a4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3e2a0(%rip), %rdx     # 0x75354
movq %rbx, %rdi
movl $0xf, %esi
movl $0x97, %ecx
callq 0x145a4
movq %r14, %rdi
callq 0x2b166
jmp 0x3709f
// File: /workspace/github_c_makefile_star2_O3/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 0x37229
leaq 0x69f61(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x37244
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x37241
movq %r14, %rdi
jmp 0x37278
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x37262
leaq 0x69f28(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x3728e
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x3728b
movq %r15, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x69ee8(%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 0x36c0c
// File: /workspace/github_c_makefile_star2_O3/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 0x3730e
leaq 0x69e7c(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x37329
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x37326
movq %r14, %rdi
jmp 0x3735d
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x37347
leaq 0x69e43(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x37373
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x37370
movq %r15, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x69e03(%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 0x36c0c
// File: /workspace/github_c_makefile_star2_O3/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 0x373d5
leaq 0x69db5(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x373f0
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x373ed
movq %r14, %rdi
jmp 0x37424
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x3740e
leaq 0x69d7c(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x3743a
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
je 0x37437
movq %r15, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x69d3c(%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 0x36c0c
// File: /workspace/github_c_makefile_star2_O3/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 0x374e8
leaq 0x69cbc(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x1(%rax)
je 0x374e8
movq 0x1f8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x36132
movq %rbx, %rdi
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3de52(%rip), %r10     # 0x75354
leaq 0x3c90c(%rip), %rcx     # 0x73e15
movq %r14, %rdi
movl $0x2c, %esi
movq %rax, %rdx
pushq $0x420                  # imm = 0x420
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x69c25(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x200(%rax), %rax
testq %rax, %rax
je 0x3756d
jmpq *%rax
pushq %rax
leaq 0x3dddf(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x430, %ecx            # imm = 0x430
callq 0x145a4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x69bec(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x208(%rax), %rax
testq %rax, %rax
je 0x375a6
jmpq *%rax
pushq %rax
leaq 0x3dda6(%rip), %rdx     # 0x75354
movq %r9, %rdi
movl $0xf, %esi
movl $0x440, %ecx            # imm = 0x440
callq 0x145a4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x69bb3(%rip), %rsi     # 0xa1180
movq (%rsi,%rax,8), %rax
movq 0x210(%rax), %rax
testq %rax, %rax
je 0x375e5
movq %rdx, %rsi
movq %rcx, %rdx
jmpq *%rax
leaq 0x3dd68(%rip), %rdx     # 0x75354
movq %rcx, %rdi
movl $0xf, %esi
movl $0x44d, %ecx            # imm = 0x44D
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x69b62(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x218(%rax), %rax
testq %rax, %rax
je 0x37647
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 0x2f5ad
leaq 0x3dd34(%rip), %rdx     # 0x7538a
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 0x3dcd7(%rip), %rax     # 0x75354
leaq 0x3c791(%rip), %rcx     # 0x73e15
movq %r14, %rdi
movl $0x13, %esi
movq %r12, %rdx
pushq $0x45e                  # imm = 0x45E
pushq %rax
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x37730
cmpl $0x7, %eax
sete %bl
jmp 0x377ad
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x69a43(%rip), %r15     # 0xa1180
movq (%r15,%rax,8), %rcx
cmpb $0x0, 0x3(%rcx)
jne 0x3774d
cmpb $0x1, 0x4(%rcx)
jne 0x37728
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x80(%rcx)
cmpl $0x0, (%r14)
je 0x37768
xorl %ebx, %ebx
jmp 0x377ad
movl (%rbx), %eax
cmpl $0x15, %eax
je 0x37774
cmpl $0xf, %eax
jne 0x37782
leaq 0x8(%rsp), %rdi
callq 0x2ff1c
movl %eax, %ebx
jmp 0x377a3
movl 0x8(%rsp), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
jne 0x37794
xorl %ecx, %ecx
jmp 0x3779b
movq (%r15,%rax,8), %rcx
movb 0x1(%rcx), %cl
cmpl $0x9, %eax
sete %bl
orb %cl, %bl
leaq 0x8(%rsp), %rdi
callq 0x2f56e
movl %ebx, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x377dc
cmpl $0x7, %eax
sete %bl
jmp 0x37836
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x69997(%rip), %r15     # 0xa1180
movq (%r15,%rax,8), %rcx
cmpb $0x0, 0x3(%rcx)
jne 0x377f9
cmpb $0x1, 0x4(%rcx)
jne 0x377d4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x80(%rcx)
cmpl $0x0, (%r14)
je 0x37814
xorl %ebx, %ebx
jmp 0x37836
movl (%rbx), %eax
cmpl $0x15, %eax
je 0x37820
cmpl $0xf, %eax
jne 0x37845
leaq 0x8(%rsp), %rdi
callq 0x2ff9c
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2f56e
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 0x37857
xorl %ebx, %ebx
jmp 0x3782c
movq (%r15,%rax,8), %rax
movb 0x1(%rax), %bl
jmp 0x3782c
// File: /workspace/github_c_makefile_star2_O3/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 0x2f0ec
testb %al, %al
jne 0x378fe
movl (%rbx), %eax
leaq 0x698f6(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x138(%rax), %rax
testq %rax, %rax
je 0x378b1
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 0x2f5ad
movq %rax, %r13
movq %r12, %rdi
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3da7e(%rip), %r10     # 0x75354
movq %r14, %rdi
movl $0x45, %esi
movq %r13, %rdx
movq %rax, %rcx
pushq $0x4d3                  # imm = 0x4D3
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6986c(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x228(%rax), %rax
testq %rax, %rax
je 0x37926
jmpq *%rax
leaq 0x3da27(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x4e3, %ecx            # imm = 0x4E3
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x69838(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x230(%rax), %rax
testq %rax, %rax
je 0x3795a
jmpq *%rax
leaq 0x3d9f3(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x4f1, %ecx            # imm = 0x4F1
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x69804(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x238(%rax), %rax
testq %rax, %rax
je 0x3798e
jmpq *%rax
leaq 0x3d9bf(%rip), %rdx     # 0x75354
movq %r8, %rdi
movl $0xf, %esi
movl $0x4ff, %ecx            # imm = 0x4FF
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x143b4
leaq 0x8(%rsp), %rbx
movl $0x40, %esi
movq %rbx, %rdi
callq 0x149f4
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x2f5d7
cmpl $0x0, (%rbp)
jne 0x37a47
leaq 0x8(%rsp), %rdi
leaq 0x1c(%rsp), %rbx
movq %rbx, %rsi
callq 0x14d01
cmpl $0x0, (%rbx)
je 0x37a98
movq %r13, %rdi
callq 0x2f5ad
leaq 0x3d8fe(%rip), %r10     # 0x75354
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 0x143da
addq $0x10, %rsp
leaq 0x8(%rsp), %rdi
callq 0x14d5c
addq $0xc28, %rsp            # imm = 0xC28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
callq 0x14db1
leaq 0x3d8ab(%rip), %r10     # 0x75354
movq %r12, %rdi
movl $0x1d, %esi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
movl 0x4(%rsp), %r9d
pushq $0x52c                  # imm = 0x52C
jmp 0x37a71
// File: /workspace/github_c_makefile_star2_O3/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 0x143b4
leaq 0x28(%rsp), %r14
movl $0x40, %esi
movq %r14, %rdi
callq 0x149f4
leaq 0x18(%rsp), %rdi
movl $0x40, %esi
callq 0x149f4
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f5d7
cmpl $0x0, (%rbx)
jne 0x37b76
leaq 0x28(%rsp), %rdi
leaq 0x3c(%rsp), %rbx
movq %rbx, %rsi
callq 0x14d01
cmpl $0x0, (%rbx)
jne 0x37b76
leaq 0x18(%rsp), %rsi
leaq 0x3c(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rdx
callq 0x2f5d7
cmpl $0x0, (%rbx)
jne 0x37b76
leaq 0x18(%rsp), %rdi
leaq 0x3c(%rsp), %rbx
movq %rbx, %rsi
callq 0x14d01
cmpl $0x0, (%rbx)
je 0x37bc4
movq %rbp, %rdi
callq 0x2f5ad
movq %rax, %rbx
movq %r13, %rdi
callq 0x2f5ad
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
callq *0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x14d5c
leaq 0x28(%rsp), %rdi
callq 0x14d5c
addq $0xc48, %rsp            # imm = 0xC48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x14db1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x14db1
jmp 0x37b89
// File: /workspace/github_c_makefile_star2_O3/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 0x2be09
cmpl $0x0, (%r14)
jne 0x37d21
movl %eax, %edi
movq %r14, %rsi
callq 0x2b77f
cmpl $0x0, (%r14)
je 0x37d35
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x2b166
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x37d24
// File: /workspace/github_c_makefile_star2_O3/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 0x2be09
cmpl $0x0, (%r14)
jne 0x37dc8
movq 0x48(%r13), %rdi
movl %r12d, %r8d
movl $0x18, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %r14, %r9
callq 0x2bd42
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b166
// File: /workspace/github_c_makefile_star2_O3/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 0x3d61a(%rip), %rsi     # 0x75438
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 0x149f4
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x14ae8
cmpl $0x0, (%r14)
je 0x37e64
movq %rbx, %rdi
callq 0x2b166
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_O3/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 0x37ead
leaq 0x3d4ff(%rip), %rcx     # 0x75398
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, (%rbx)
jmp 0x37f52
movq %rbx, %rdi
callq 0x2f5ad
movq %rax, %r13
movq %r12, %rdi
callq 0x2f5ad
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3d56c(%rip), %r10     # 0x7543e
movq %r14, %rdi
movl $0x45, %esi
movq %r13, %rdx
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x143da
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x2b166
jmp 0x37f50
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x36119
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36119
cmpl $0x0, (%r14)
jne 0x37f50
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x367cf
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36119
cmpl $0x0, (%r14)
je 0x37f5f
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 0x36852
// File: /workspace/github_c_makefile_star2_O3/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 0x37fca
cmpl $0x1, %eax
jne 0x37fed
cvtsi2sdl 0x148(%r14), %xmm0
addsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movl $0x0, (%rbx)
jmp 0x37fe3
movsd 0x148(%r14), %xmm0
addsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movq %r14, %rdi
callq 0x2b166
jmp 0x3802a
movq %r8, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3d429(%rip), %r8      # 0x7543e
movq %r15, %rdi
movl $0x19, %esi
movl $0xe8, %r9d
callq 0x145c8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x38073
cmpl $0x1, %eax
jne 0x38096
cvtsi2sdl 0x148(%r14), %xmm0
mulsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movl $0x0, (%rbx)
jmp 0x3808c
movsd 0x148(%r14), %xmm0
mulsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movq %r14, %rdi
callq 0x2b166
jmp 0x380d3
movq %rcx, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x2b166
movq %r14, %rdi
callq 0x2b166
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3d380(%rip), %r8      # 0x7543e
movq %r15, %rdi
movl $0x19, %esi
movl $0x102, %r9d            # imm = 0x102
callq 0x145c8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq