LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x6c994(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x108(%rax), %rax
testq %rax, %rax
je 0x3480c
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3aade(%rip), %r10     # 0x6f304
leaq 0x39598(%rip), %rcx     # 0x6ddc5
pushq $0x17
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
pushq $0x2b5                  # imm = 0x2B5
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c915(%rip), %rax     # 0xa1180
movq (%rax,%rcx,8), %rax
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x34895
cmpb $0x1, (%rax)
jne 0x34895
leaq 0x3aa81(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r14, %rdi
movl $0x2c2, %ecx            # imm = 0x2C2
callq 0x1429e
jmp 0x348f1
movq 0x118(%rax), %rax
testq %rax, %rax
je 0x348b1
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3aa39(%rip), %r10     # 0x6f304
leaq 0x394f3(%rip), %rcx     # 0x6ddc5
pushq $0x18
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
pushq $0x2c9                  # imm = 0x2C9
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c830(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x110(%rax), %rax
testq %rax, %rax
je 0x34977
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 0x2dcbb
movq %rax, %r13
movq %r12, %rdi
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3a968(%rip), %r10     # 0x6f304
pushq $0x46
popq %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rax, %rcx
pushq $0x2e1                  # imm = 0x2E1
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c79c(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x128(%rax), %rax
testq %rax, %rax
je 0x34a0a
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 0x2dcbb
movq %rax, %r12
leaq 0x3a13c(%rip), %rdi     # 0x6eb58
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3a8d1(%rip), %r10     # 0x6f304
pushq $0x45
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x2f1                  # imm = 0x2F1
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c703(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x130(%rax), %rax
testq %rax, %rax
je 0x34aa3
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 0x2dcbb
movq %rax, %r12
leaq 0x3a0a3(%rip), %rdi     # 0x6eb58
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3a838(%rip), %r10     # 0x6f304
pushq $0x45
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
pushq $0x301                  # imm = 0x301
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/type_if.c
// Function: prv_order_expressions
static bool prv_order_expressions(subtilis_exp_t **a1, subtilis_exp_t **a2)
{
	subtilis_exp_t *e1;
	subtilis_exp_t *e2;
	bool swap;

	e1 = *a1;
	e2 = *a2;

	swap = !prv_type_map[e2->type.type]->is_const &&
	       prv_type_map[e1->type.type]->is_const;
	if (swap) {
		*a1 = e2;
		*a2 = e1;
	}

	return swap;
}

// Assembly:
movq (%rsi), %rax
movl (%rax), %ecx
leaq 0x6c5fd(%rip), %rdx     # 0xa1180
movq (%rdx,%rcx,8), %rcx
cmpb $0x0, (%rcx)
jne 0x34ba4
movq (%rdi), %rcx
movl (%rcx), %r8d
movq (%rdx,%r8,8), %rdx
cmpb $0x1, (%rdx)
jne 0x34ba4
movq %rax, (%rdi)
movq %rcx, (%rsi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34bcc
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 0x29d88
movq %r14, %rdi
callq 0x29d88
leaq 0x3a721(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
pushq $0x78
popq %rcx
movq %rbx, %rdi
callq 0x1429e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34c77
movq %rcx, %rax
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq %rsi, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
leaq 0x3a676(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
pushq $0x6a
popq %rcx
movq %rbx, %rdi
callq 0x1429e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x347d5
cmpl $0x0, (%rbx)
je 0x34f1d
movq %r12, %rdi
jmp 0x34f36
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x34f49
movq %r15, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %ecx
leaq 0x6c22d(%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 0x34c56
// File: /workspace/github_c_makefile_star2_O2/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 0x347d5
cmpl $0x0, (%rbx)
je 0x34f9d
movq %r12, %rdi
jmp 0x34fb6
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x34fc9
movq %r15, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %ecx
leaq 0x6c1ad(%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 0x34c56
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
movq %rcx, %rdx
callq 0x34916
movq %rax, 0x10(%rsp)
cmpl $0x0, (%rbx)
je 0x35025
movq %r12, %rdi
jmp 0x35043
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x34916
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rbx)
je 0x35056
movq %r15, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x34b77
movq (%r15), %rsi
movq (%r12), %rdx
movl (%rsi), %ecx
leaq 0x6c105(%rip), %rdi     # 0xa1180
movq (%rdi,%rcx,8), %rcx
movq 0x1a0(%rcx), %rcx
movzbl %al, %r8d
movq %r14, %rdi
movq %rbx, %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x34ba7
// File: /workspace/github_c_makefile_star2_O2/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 0x3513f
movq %rcx, %rax
movzbl %r8b, %ecx
movq %r14, %rdx
movq %rbx, %r8
callq *%rax
cmpl $0x0, (%rbx)
jne 0x35166
movq %rax, %r14
movl (%rax), %eax
cmpl $0x1, %eax
je 0x35169
cmpl $0x5, %eax
je 0x35169
cmpl $0x4, %eax
jne 0x35174
movl $0x5, (%r14)
jmp 0x35169
movq %rsi, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
leaq 0x3a1ae(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x8b, %ecx
callq 0x1429e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3a189(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x97, %ecx
callq 0x1429e
movq %r14, %rdi
callq 0x29d88
jmp 0x35166
// File: /workspace/github_c_makefile_star2_O2/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 0x3534e
leaq 0x6be3c(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x35369
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x35366
movq %r14, %rdi
jmp 0x3539d
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x35387
leaq 0x6be03(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x353b3
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x353b0
movq %r15, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x6bdc3(%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 0x34c56
// File: /workspace/github_c_makefile_star2_O2/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 0x35433
leaq 0x6bd57(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x3544e
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x3544b
movq %r14, %rdi
jmp 0x35482
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x3546c
leaq 0x6bd1e(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x35498
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x35495
movq %r15, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x6bcde(%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 0x34c56
// File: /workspace/github_c_makefile_star2_O2/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 0x354fa
leaq 0x6bc90(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x35515
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x35512
movq %r14, %rdi
jmp 0x35549
movq %rax, %r15
movl (%r14), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
je 0x35533
leaq 0x6bc57(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x2(%rax)
jne 0x3555f
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
je 0x3555c
movq %r15, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl (%r15), %eax
leaq 0x6bc17(%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 0x34c56
// File: /workspace/github_c_makefile_star2_O2/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 0x3560d
leaq 0x6bb97(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
cmpb $0x0, 0x1(%rax)
je 0x3560d
movq 0x1f8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x34178
movq %rbx, %rdi
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x39cdd(%rip), %r10     # 0x6f304
leaq 0x38797(%rip), %rcx     # 0x6ddc5
pushq $0x2c
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
pushq $0x420                  # imm = 0x420
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6bb04(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x200(%rax), %rax
testq %rax, %rax
je 0x3568e
jmpq *%rax
pushq %rax
leaq 0x39c6e(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x430, %ecx            # imm = 0x430
callq 0x1429e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6bacd(%rip), %r10     # 0xa1180
movq (%r10,%rax,8), %rax
movq 0x208(%rax), %rax
testq %rax, %rax
je 0x356c5
jmpq *%rax
pushq %rax
leaq 0x39c37(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r9, %rdi
movl $0x440, %ecx            # imm = 0x440
callq 0x1429e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6ba96(%rip), %rsi     # 0xa1180
movq (%rsi,%rax,8), %rax
movq 0x210(%rax), %rax
testq %rax, %rax
je 0x35702
movq %rdx, %rsi
movq %rcx, %rdx
jmpq *%rax
leaq 0x39bfb(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %rcx, %rdi
movl $0x44d, %ecx            # imm = 0x44D
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x6ba47(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x218(%rax), %rax
testq %rax, %rax
je 0x35762
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 0x2dcbb
leaq 0x39bc9(%rip), %rdx     # 0x6f33a
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 0x39b6c(%rip), %rax     # 0x6f304
leaq 0x38626(%rip), %rcx     # 0x6ddc5
pushq $0x13
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
pushq $0x45e                  # imm = 0x45E
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35847
cmpl $0x7, %eax
sete %bl
jmp 0x358c4
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6b92c(%rip), %r15     # 0xa1180
movq (%r15,%rax,8), %rcx
cmpb $0x0, 0x3(%rcx)
jne 0x35864
cmpb $0x1, 0x4(%rcx)
jne 0x3583f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x80(%rcx)
cmpl $0x0, (%r14)
je 0x3587f
xorl %ebx, %ebx
jmp 0x358c4
movl (%rbx), %eax
cmpl $0x15, %eax
je 0x3588b
cmpl $0xf, %eax
jne 0x35899
leaq 0x8(%rsp), %rdi
callq 0x2e5bf
movl %eax, %ebx
jmp 0x358ba
movl 0x8(%rsp), %eax
movl %eax, %ecx
andl $-0x11, %ecx
cmpl $0x8, %ecx
jne 0x358ab
xorl %ecx, %ecx
jmp 0x358b2
movq (%r15,%rax,8), %rcx
movb 0x1(%rcx), %cl
cmpl $0x9, %eax
sete %bl
orb %cl, %bl
leaq 0x8(%rsp), %rdi
callq 0x2dc7c
movl %ebx, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x358f3
cmpl $0x7, %eax
sete %bl
jmp 0x3594d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6b880(%rip), %r15     # 0xa1180
movq (%r15,%rax,8), %rcx
cmpb $0x0, 0x3(%rcx)
jne 0x35910
cmpb $0x1, 0x4(%rcx)
jne 0x358eb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x80(%rcx)
cmpl $0x0, (%r14)
je 0x3592b
xorl %ebx, %ebx
jmp 0x3594d
movl (%rbx), %eax
cmpl $0x15, %eax
je 0x35937
cmpl $0xf, %eax
jne 0x3595c
leaq 0x8(%rsp), %rdi
callq 0x2e61c
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2dc7c
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 0x3596e
xorl %ebx, %ebx
jmp 0x35943
movq (%r15,%rax,8), %rax
movb 0x1(%rax), %bl
jmp 0x35943
// File: /workspace/github_c_makefile_star2_O2/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 0x2d844
testb %al, %al
jne 0x35a11
movl (%rbx), %eax
leaq 0x6b7df(%rip), %rcx     # 0xa1180
movq (%rcx,%rax,8), %rax
movq 0x138(%rax), %rax
testq %rax, %rax
je 0x359c8
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 0x2dcbb
movq %rax, %r13
movq %r12, %rdi
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x39917(%rip), %r10     # 0x6f304
pushq $0x45
popq %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rax, %rcx
pushq $0x4d3                  # imm = 0x4D3
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6b759(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x228(%rax), %rax
testq %rax, %rax
je 0x35a39
jmpq *%rax
leaq 0x398c4(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x4e3, %ecx            # imm = 0x4E3
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x6b727(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x230(%rax), %rax
testq %rax, %rax
je 0x35a6b
jmpq *%rax
leaq 0x39892(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x4f1, %ecx            # imm = 0x4F1
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x6b6f5(%rip), %r9      # 0xa1180
movq (%r9,%rax,8), %rax
movq 0x238(%rax), %rax
testq %rax, %rax
je 0x35a9d
jmpq *%rax
leaq 0x39860(%rip), %rdx     # 0x6f304
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x4ff, %ecx            # imm = 0x4FF
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 0x140a4
leaq 0x8(%rsp), %rbx
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x146a8
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x2dce5
cmpl $0x0, (%rbp)
jne 0x35b4e
leaq 0x8(%rsp), %rdi
leaq 0x1c(%rsp), %rbx
movq %rbx, %rsi
callq 0x149a8
cmpl $0x0, (%rbx)
je 0x35b9b
movq %r13, %rdi
callq 0x2dcbb
leaq 0x397a7(%rip), %r10     # 0x6f304
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
movl 0x4(%rsp), %r9d
pushq $0x533                  # imm = 0x533
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
leaq 0x8(%rsp), %rdi
callq 0x14a01
addq $0xc28, %rsp            # imm = 0xC28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
callq 0x14a53
leaq 0x39758(%rip), %r10     # 0x6f304
pushq $0x1d
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
movl 0x4(%rsp), %r9d
pushq $0x52c                  # imm = 0x52C
jmp 0x35b76
// File: /workspace/github_c_makefile_star2_O2/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, (%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
leaq 0x3c(%rsp), %rbx
movq %rbx, %rdi
callq 0x140a4
leaq 0x28(%rsp), %r14
pushq $0x40
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x146a8
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x146a8
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2dce5
cmpl $0x0, (%rbx)
jne 0x35c78
leaq 0x28(%rsp), %rdi
leaq 0x3c(%rsp), %rbx
movq %rbx, %rsi
callq 0x149a8
cmpl $0x0, (%rbx)
jne 0x35c78
leaq 0x18(%rsp), %rsi
leaq 0x3c(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rdx
callq 0x2dce5
cmpl $0x0, (%rbx)
jne 0x35c78
leaq 0x18(%rsp), %rdi
leaq 0x3c(%rsp), %rbx
movq %rbx, %rsi
callq 0x149a8
cmpl $0x0, (%rbx)
je 0x35cc7
movq %rbp, %rdi
callq 0x2dcbb
movq %rax, %rbx
movq %r13, %rdi
callq 0x2dcbb
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
callq *0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x14a01
leaq 0x28(%rsp), %rdi
callq 0x14a01
addq $0xc48, %rsp            # imm = 0xC48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x14a53
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x14a53
jmp 0x35c8b
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1c
popq %rsi
movq %r14, %rcx
callq 0x2a981
cmpl $0x0, (%r14)
jne 0x35dd6
movl %eax, %edi
movq %r14, %rsi
callq 0x2a358
cmpl $0x0, (%r14)
je 0x35dea
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x29d88
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x35dd9
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1c
popq %rsi
movq %r8, %rcx
callq 0x2a981
cmpl $0x0, (%r14)
jne 0x35e77
movq 0x48(%r13), %rdi
movl %r12d, %r8d
pushq $0x18
popq %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %r14, %r9
callq 0x2a8c1
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/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 0x3951b(%rip), %rsi     # 0x6f3e8
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 0x146a8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x14795
cmpl $0x0, (%r14)
je 0x35f13
movq %rbx, %rdi
callq 0x29d88
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_O2/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 0x35f5c
leaq 0x39400(%rip), %rcx     # 0x6f348
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, (%rbx)
jmp 0x35ffd
movq %rbx, %rdi
callq 0x2dcbb
movq %rax, %r13
movq %r12, %rdi
callq 0x2dcbb
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x3946d(%rip), %r10     # 0x6f3ee
pushq $0x45
popq %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rax, %rcx
pushq $0xc5
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %rbx, %rdi
callq 0x29d88
jmp 0x35ffb
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3415f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3415f
cmpl $0x0, (%r14)
jne 0x35ffb
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x347d5
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3415f
cmpl $0x0, (%r14)
je 0x3600a
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 0x34854
// File: /workspace/github_c_makefile_star2_O2/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 0x36072
cmpl $0x1, %eax
jne 0x36095
cvtsi2sdl 0x148(%r14), %xmm0
addsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
andl $0x0, (%rbx)
jmp 0x3608b
movsd 0x148(%r14), %xmm0
addsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movq %r14, %rdi
callq 0x29d88
jmp 0x360d0
movq %r8, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x39331(%rip), %r8      # 0x6f3ee
pushq $0x19
popq %rsi
movq %r15, %rdi
movl $0xe8, %r9d
callq 0x142c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x36116
cmpl $0x1, %eax
jne 0x36139
cvtsi2sdl 0x148(%r14), %xmm0
mulsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
andl $0x0, (%rbx)
jmp 0x3612f
movsd 0x148(%r14), %xmm0
mulsd 0x148(%rbx), %xmm0
movsd %xmm0, 0x148(%rbx)
movq %r14, %rdi
callq 0x29d88
jmp 0x36174
movq %rcx, %r15
movq %rdi, %r12
movq %rbx, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x3928d(%rip), %r8      # 0x6f3ee
pushq $0x19
popq %rsi
movq %r15, %rdi
movl $0x102, %r9d            # imm = 0x102
callq 0x142c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3753b
cmpl $0x0, (%r15)
je 0x361a0
xorl %ebx, %ebx
jmp 0x361b5
movl 0x148(%r14), %eax
andl %eax, 0x148(%rbx)
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq