LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_can_zero_fill
bool subtilis_type_rec_can_zero_fill(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_STRING:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
			break;
		case SUBTILIS_TYPE_REC:
			if (!subtilis_type_rec_can_zero_fill(field))
				return false;
			break;
		default:
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2e6c6
movq 0x18(%rbx), %rdi
movl (%rdi,%r15), %eax
leal -0x4(%rax), %ecx
cmpl $0x4, %ecx
jae 0x2e6b0
incq %r12
addq $0x148, %r15            # imm = 0x148
jmp 0x2e68f
cmpl $0x17, %eax
je 0x2e6a4
cmpl $0x16, %eax
jne 0x2e6c6
addq %r15, %rdi
callq 0x2e67a
testb %al, %al
jne 0x2e6a4
cmpq %r14, %r12
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_zero_fill_size
size_t subtilis_type_rec_zero_fill_size(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	size_t size = 0;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_STRING:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
			size += rec->fields[i].size;
			break;
		case SUBTILIS_TYPE_REC:
			size += subtilis_type_rec_zero_fill_size(field);
			break;
		default:
			break;
		}
	}

	return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r15
pushq $0xc
popq %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
subq $0x1, %r15
jb 0x2e736
movq 0x18(%rbx), %rdi
movl (%rdi,%r13), %eax
leal -0x4(%rax), %ecx
cmpl $0x4, %ecx
jae 0x2e720
movq 0x20(%rbx), %rax
movl (%rax,%r12), %eax
addq %rax, %r14
addq $0x18, %r12
addq $0x148, %r13            # imm = 0x148
jmp 0x2e6f2
cmpl $0x16, %eax
je 0x2e72c
cmpl $0x17, %eax
je 0x2e708
jmp 0x2e713
addq %r13, %rdi
callq 0x2e6d8
jmp 0x2e710
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/type.c
// Function: prv_rec_need_ref_count
static size_t prv_rec_need_ref_count(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	const subtilis_type_rec_t *rec = &typ->params.rec;
	size_t num = 0;
	size_t rec_num;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
		case SUBTILIS_TYPE_FN:
			break;
		case SUBTILIS_TYPE_REC:
			rec_num = prv_rec_need_ref_count(field);
			if (rec_num >= 4)
				rec_num = 1;
			num += rec_num;
			break;
		default:
			num++;
			break;
		}
	}

	return num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r15
xorl %r12d, %r12d
movl $0x800270, %ebp         # imm = 0x800270
pushq $0x1
popq %r13
xorl %r14d, %r14d
subq $0x1, %r15
jb 0x2e7b7
movq 0x18(%rbx), %rdi
movl (%rdi,%r12), %eax
cmpl $0x17, %eax
ja 0x2e7b2
btl %eax, %ebp
jae 0x2e794
addq $0x148, %r12            # imm = 0x148
jmp 0x2e773
cmpl $0x16, %eax
jne 0x2e7b2
addq %r12, %rdi
callq 0x2e752
movq %r13, %rcx
cmpq $0x4, %rax
jae 0x2e7ad
movq %rax, %rcx
addq %rcx, %r14
jmp 0x2e78b
incq %r14
jmp 0x2e78b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_need_deref
bool subtilis_type_rec_need_deref(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
		case SUBTILIS_TYPE_FN:
			continue;
		case SUBTILIS_TYPE_REC:
			if (subtilis_type_rec_need_deref(field))
				return true;
			break;
		default:
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
xorl %r15d, %r15d
movl $0x800270, %ebp         # imm = 0x800270
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2e817
movq 0x18(%rbx), %rdi
movl (%rdi,%r15), %eax
cmpl $0x17, %eax
ja 0x2e817
btl %eax, %ebp
jae 0x2e806
incq %r12
addq $0x148, %r15            # imm = 0x148
jmp 0x2e7e3
cmpl $0x16, %eax
jne 0x2e817
addq %r15, %rdi
callq 0x2e7c9
testb %al, %al
je 0x2e7fa
cmpq %r14, %r12
setb %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_need_zero_alloc
bool subtilis_type_rec_need_zero_alloc(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_ARRAY_REAL:
		case SUBTILIS_TYPE_ARRAY_INTEGER:
		case SUBTILIS_TYPE_ARRAY_BYTE:
		case SUBTILIS_TYPE_ARRAY_STRING:
		case SUBTILIS_TYPE_ARRAY_FN:
		case SUBTILIS_TYPE_ARRAY_REC:
			return true;
		case SUBTILIS_TYPE_VECTOR_REAL:
		case SUBTILIS_TYPE_VECTOR_INTEGER:
		case SUBTILIS_TYPE_VECTOR_BYTE:
		case SUBTILIS_TYPE_VECTOR_STRING:
		case SUBTILIS_TYPE_VECTOR_FN:
		case SUBTILIS_TYPE_VECTOR_REC:
			if (rec->fields[i].vec_dim != -1)
				return true;
			break;
		case SUBTILIS_TYPE_REC:
			if (subtilis_type_rec_need_zero_alloc(field))
				return true;
			break;
		default:
			break;
		}
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
pushq $0x10
popq %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x2e88b
movq 0x18(%rbx), %rdi
movl (%rdi,%r12), %eax
leal -0x10(%rax), %ecx
cmpl $0x6, %ecx
jae 0x2e870
movq 0x20(%rbx), %rax
cmpl $-0x1, (%rax,%r15)
jne 0x2e88b
incq %r13
addq $0x18, %r15
addq $0x148, %r12            # imm = 0x148
jmp 0x2e840
cmpl $0x16, %eax
je 0x2e87f
addl $-0xa, %eax
cmpl $0x6, %eax
jae 0x2e860
jmp 0x2e88b
addq %r12, %rdi
callq 0x2e826
testb %al, %al
je 0x2e860
cmpq %r14, %r13
setb %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/type.c
// Function: prv_fn_type_name
static void prv_fn_type_name(const subtilis_type_fn_t *fn_type,
			     subtilis_buffer_t *buf, subtilis_error_t *err)
{
	size_t i;

	if (fn_type->ret_val) {
		subtilis_buffer_append_string(buf, "FN", err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		prv_full_type_name(fn_type->ret_val, buf, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		subtilis_buffer_append_string(buf, "(", err);
	} else {
		subtilis_buffer_append_string(buf, "PROC(", err);
	}
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 0; i < fn_type->num_params; i++) {
		prv_full_type_name(fn_type->params[i], buf, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (i == fn_type->num_params - 1)
			break;
		subtilis_buffer_append_string(buf, ",", err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
	subtilis_buffer_append_string(buf, ")", err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x2e8e6
leaq 0x3ec0b(%rip), %rsi     # 0x6d4c5
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14837
cmpl $0x0, (%rbx)
jne 0x2e8fd
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2dd13
cmpl $0x0, (%rbx)
jne 0x2e8fd
leaq 0x3f8fe(%rip), %rsi     # 0x6e1e2
jmp 0x2e8ed
leaq 0x408a1(%rip), %rsi     # 0x6f18e
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14837
cmpl $0x0, (%rbx)
je 0x2e907
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
leaq 0x3ec81(%rip), %r12     # 0x6d592
cmpq 0x8(%r15), %r13
jae 0x2e94a
movq 0x10(%r15,%r13,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2dd13
cmpl $0x0, (%rbx)
jne 0x2e8fd
incq %r13
cmpq 0x8(%r15), %r13
je 0x2e94a
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x14837
cmpl $0x0, (%rbx)
je 0x2e911
jmp 0x2e8fd
leaq 0x3f16c(%rip), %rsi     # 0x6dabd
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x14837
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/type.c
// Function: prv_rec_type_name
static void prv_rec_type_name(const subtilis_type_rec_t *rec_type,
			      subtilis_buffer_t *buf, subtilis_error_t *err)
{
	size_t i;

	subtilis_buffer_append_string(buf, rec_type->name, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_buffer_append_string(buf, "(", err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	i = 0;
	if (rec_type->num_fields > 0) {
		for (; i < rec_type->num_fields - 1; i++) {
			subtilis_buffer_append_string(
			    buf, subtilis_type_name(&rec_type->field_types[i]),
			    err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
			subtilis_buffer_append_string(buf, ",", err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}
	subtilis_buffer_append_string(
	    buf, subtilis_type_name(&rec_type->field_types[i]), err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_buffer_append_string(buf, ")", err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x14837
cmpl $0x0, (%rbx)
jne 0x2e9a1
leaq 0x3f851(%rip), %rsi     # 0x6e1e2
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14837
cmpl $0x0, (%rbx)
je 0x2e9b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x2ea2e
pushq $0x10
popq %rbp
xorl %r13d, %r13d
leaq 0x3ebcc(%rip), %r12     # 0x6d592
decq %rax
cmpq %rax, %r13
jae 0x2ea31
movq 0x10(%r15), %rax
movl -0x10(%rax,%rbp), %ecx
cmpq $0x16, %rcx
jne 0x2e9e1
addq %rbp, %rax
jmp 0x2e9f8
leaq 0x4069e(%rip), %rsi     # 0x6f086
cmpl $0x18, %ecx
ja 0x2e9fb
leaq 0x6ebec(%rip), %rax     # 0x9d5e0
leaq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14837
cmpl $0x0, (%rbx)
jne 0x2e9a1
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x14837
cmpl $0x0, (%rbx)
jne 0x2e9a1
incq %r13
movq 0x20(%r15), %rax
addq $0x148, %rbp            # imm = 0x148
jmp 0x2e9c6
xorl %r13d, %r13d
movq 0x10(%r15), %rax
imulq $0x148, %r13, %rdx      # imm = 0x148
movl (%rax,%rdx), %ecx
cmpq $0x16, %rcx
jne 0x2ea4e
addq %rdx, %rax
addq $0x10, %rax
jmp 0x2ea5e
cmpl $0x18, %ecx
ja 0x2ea63
leaq 0x6eb86(%rip), %rax     # 0x9d5e0
leaq (%rax,%rcx,8), %rax
movq (%rax), %rsi
jmp 0x2ea6a
leaq 0x4061c(%rip), %rsi     # 0x6f086
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14837
cmpl $0x0, (%rbx)
jne 0x2e9a1
leaq 0x3f038(%rip), %rsi     # 0x6dabd
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14837
nop
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/builtins.c
// Function: subtilis_builtin_ts
subtilis_type_section_t *subtilis_builtin_ts(subtilis_builtin_type_t type,
					     subtilis_error_t *err)
{
	const subtilis_builtin_t *f;
	subtilis_type_t *params;
	size_t i;
	subtilis_type_section_t *ts = NULL;

	f = &subtilis_builtin_list[type];
	params = malloc(sizeof(subtilis_type_t) * f->num_parameters);
	if (!params) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	for (i = 0; i < f->num_parameters; i++)
		params[i].type = SUBTILIS_TYPE_VOID;
	for (i = 0; i < f->num_parameters; i++) {
		subtilis_type_copy(&params[i], &f->arg_types[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}
	ts = subtilis_type_section_new(&f->ret_type, f->num_parameters, params,
				       NULL, err);

cleanup:
	for (i = 0; i < f->num_parameters; i++)
		subtilis_type_free(&params[i]);
	free(params);

	return ts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl %edi, %eax
imulq $0x688, %rax, %r13      # imm = 0x688
leaq 0x6ebef(%rip), %r14     # 0x9d6b0
movq 0x158(%r13,%r14), %rbx
imulq $0x148, %rbx, %rdi      # imm = 0x148
callq 0x121d0
testq %rax, %rax
je 0x2eb43
addq %r13, %r14
movq %rax, %rdx
movq %rbx, %rcx
subq $0x1, %rcx
jb 0x2eaf8
movl $0x8, (%rdx)
addq $0x148, %rdx            # imm = 0x148
jmp 0x2eae3
movq %r14, 0x10(%rsp)
leaq 0x160(%r14), %rsi
movq %rax, %rdi
pushq $-0x1
popq %rbp
movl $0x148, %r13d           # imm = 0x148
movq %rax, 0x8(%rsp)
incq %rbp
cmpq %rbp, %rbx
je 0x2eb5d
leaq (%rdi,%r13), %r14
leaq (%rsi,%r13), %r12
movq %r15, %rdx
callq 0x2de8a
cmpl $0x0, (%r15)
movq %r12, %rsi
movq %r14, %rdi
je 0x2eb15
movq 0x8(%rsp), %r14
xorl %r12d, %r12d
jmp 0x2eb7e
leaq 0x40690(%rip), %rdx     # 0x6f1da
pushq $0x1
popq %rsi
pushq $0x3f
popq %rcx
movq %r15, %rdi
callq 0x1429e
xorl %r12d, %r12d
jmp 0x2eba0
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %r14
movq %r14, %rdx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x2d9c4
movq %rax, %r12
movq %r14, %r15
subq $0x1, %rbx
jb 0x2eb98
movq %r15, %rdi
callq 0x2dc7c
addq $0x148, %r15            # imm = 0x148
jmp 0x2eb81
movq %r14, %rdi
callq 0x122c0
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_helper.c
// Function: subtilis_builtin_memset_i32
void subtilis_builtin_memset_i32(subtilis_parser_t *p, size_t base_reg,
				 size_t size_reg, size_t val_reg,
				 subtilis_error_t *err)
{
	subtilis_ir_arg_t *args;
	char *name = NULL;
	static const char memset[] = "_memseti32";

	name = malloc(sizeof(memset));
	if (!name) {
		subtilis_error_set_oom(err);
		return;
	}
	strcpy(name, memset);

	args = malloc(sizeof(*args) * 3);
	if (!args) {
		free(name);
		subtilis_error_set_oom(err);
		return;
	}

	args[0].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[0].reg = base_reg;
	args[1].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[1].reg = size_reg;
	args[2].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[2].reg = val_reg;

	(void)subtilis_exp_add_call(p, name, SUBTILIS_BUILTINS_MEMSETI32, NULL,
				    args, &subtilis_type_void, 3, true, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
pushq $0xb
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2ec49
movq %rax, %r15
movabsq $0x697465736d656d5f, %rax # imm = 0x697465736D656D5F
movq %rax, (%r15)
movl $0x323369, 0x7(%r15)    # imm = 0x323369
pushq $0x48
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2ec57
andl $0x0, (%rax)
movq %rbp, 0x8(%rax)
andl $0x0, 0x18(%rax)
movq %r13, 0x20(%rax)
andl $0x0, 0x30(%rax)
movq %r12, 0x38(%rax)
subq $0x8, %rsp
leaq 0x4007e(%rip), %r9      # 0x6eca0
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rax, %r8
pushq %rbx
pushq $0x1
pushq $0x3
callq 0x29dcc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4059c(%rip), %rdx     # 0x6f1ec
pushq $0x1
popq %rsi
pushq $0x23
jmp 0x2ec6b
movq %r15, %rdi
callq 0x122c0
leaq 0x40586(%rip), %rdx     # 0x6f1ec
pushq $0x1
popq %rsi
pushq $0x2b
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_helper.c
// Function: subtilis_builtin_memset_i8
void subtilis_builtin_memset_i8(subtilis_parser_t *p, size_t base_reg,
				size_t size_reg, size_t val_reg,
				subtilis_error_t *err)
{
	subtilis_ir_arg_t *args;
	char *name = NULL;
	static const char memset[] = "_memseti8";

	name = malloc(sizeof(memset));
	if (!name) {
		subtilis_error_set_oom(err);
		return;
	}
	strcpy(name, memset);

	args = malloc(sizeof(*args) * 3);
	if (!args) {
		free(name);
		subtilis_error_set_oom(err);
		return;
	}

	args[0].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[0].reg = base_reg;
	args[1].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[1].reg = size_reg;
	args[2].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[2].reg = val_reg;

	(void)subtilis_exp_add_call(p, name, SUBTILIS_BUILTINS_MEMSETI8, NULL,
				    args, &subtilis_type_void, 3, true, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
pushq $0xa
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2ed16
movq %rax, %r15
movabsq $0x697465736d656d5f, %rax # imm = 0x697465736D656D5F
movq %rax, (%r15)
movw $0x38, 0x8(%r15)
pushq $0x48
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2ed24
andl $0x0, (%rax)
movq %rbp, 0x8(%rax)
andl $0x0, 0x18(%rax)
movq %r13, 0x20(%rax)
andl $0x0, 0x30(%rax)
movq %r12, 0x38(%rax)
subq $0x8, %rsp
leaq 0x3ffb1(%rip), %r9      # 0x6eca0
pushq $0x5
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rax, %r8
pushq %rbx
pushq $0x1
pushq $0x3
callq 0x29dcc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x404cf(%rip), %rdx     # 0x6f1ec
pushq $0x1
popq %rsi
pushq $0x44
jmp 0x2ed38
movq %r15, %rdi
callq 0x122c0
leaq 0x404b9(%rip), %rdx     # 0x6f1ec
pushq $0x1
popq %rsi
pushq $0x4c
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_helper.c
// Function: subtilis_builtin_memset_i64
void subtilis_builtin_memset_i64(subtilis_parser_t *p, size_t base_reg,
				 size_t size_reg, size_t val_reg_low,
				 size_t val_reg_high, subtilis_error_t *err)
{
	subtilis_ir_arg_t *args;
	char *name = NULL;
	static const char memset[] = "_memseti64";

	name = malloc(sizeof(memset));
	if (!name) {
		subtilis_error_set_oom(err);
		return;
	}
	strcpy(name, memset);

	args = malloc(sizeof(*args) * 4);
	if (!args) {
		free(name);
		subtilis_error_set_oom(err);
		return;
	}

	args[0].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[0].reg = base_reg;
	args[1].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[1].reg = size_reg;
	args[2].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[2].reg = val_reg_low;
	args[3].type = SUBTILIS_IR_REG_TYPE_INTEGER;
	args[3].reg = val_reg_high;

	(void)subtilis_exp_add_call(p, name, SUBTILIS_BUILTINS_MEMSETI64, NULL,
				    args, &subtilis_type_void, 4, true, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, (%rsp)
pushq $0xb
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2edf4
movq %rax, %r12
movabsq $0x697465736d656d5f, %rax # imm = 0x697465736D656D5F
movq %rax, (%r12)
movl $0x343669, 0x7(%r12)    # imm = 0x343669
pushq $0x60
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2ee02
andl $0x0, (%rax)
movq %r14, 0x8(%rax)
andl $0x0, 0x18(%rax)
movq %rbp, 0x20(%rax)
andl $0x0, 0x30(%rax)
movq %r13, 0x38(%rax)
andl $0x0, 0x48(%rax)
movq %r15, 0x50(%rax)
subq $0x8, %rsp
leaq 0x3fed5(%rip), %r9      # 0x6eca0
pushq $0x8
popq %rdx
movq 0x8(%rsp), %rdi
movq %r12, %rsi
xorl %ecx, %ecx
movq %rax, %r8
pushq %rbx
pushq $0x1
pushq $0x4
callq 0x29dcc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x403f1(%rip), %rdx     # 0x6f1ec
pushq $0x1
popq %rsi
pushq $0x65
jmp 0x2ee16
movq %r12, %rdi
callq 0x122c0
leaq 0x403db(%rip), %rdx     # 0x6f1ec
pushq $0x1
popq %rsi
pushq $0x6d
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_helper.c
// Function: subtilis_builtin_bzero_reg
void subtilis_builtin_bzero_reg(subtilis_parser_t *p, size_t base_reg,
				size_t loc, size_t size_reg,
				subtilis_error_t *err)
{
	subtilis_exp_t *val_exp = NULL;

	val_exp = subtilis_exp_new_int32(0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	val_exp = subtilis_type_if_exp_to_var(p, val_exp, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	base_reg = subtilis_reference_get_pointer(p, base_reg, loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_builtin_memset_i8(p, base_reg, size_reg,
				   val_exp->exp.ir_op.reg, err);

cleanup:

	subtilis_exp_delete(val_exp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
xorl %edi, %edi
movq %r8, %rsi
callq 0x2a369
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2eea0
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3415f
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2eea0
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x4ab28
cmpl $0x0, (%r14)
jne 0x2eea0
movq 0x148(%rbx), %rcx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %r8
callq 0x2ec82
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29d88
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_helper.c
// Function: subtilis_builtin_bzero
void subtilis_builtin_bzero(subtilis_parser_t *p, size_t base_reg, size_t loc,
			    size_t size, subtilis_error_t *err)
{
	subtilis_exp_t *size_exp = NULL;
	subtilis_exp_t *val_exp = NULL;

	size_exp = subtilis_exp_new_int32((int32_t)size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	val_exp = subtilis_exp_new_int32(0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	val_exp = subtilis_type_if_exp_to_var(p, val_exp, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	base_reg = subtilis_reference_get_pointer(p, base_reg, loc, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (size & 3)
		subtilis_builtin_memset_i8(p, base_reg, size_exp->exp.ir_op.reg,
					   val_exp->exp.ir_op.reg, err);
	else
		subtilis_builtin_memset_i32(p, base_reg,
					    size_exp->exp.ir_op.reg,
					    val_exp->exp.ir_op.reg, err);
cleanup:

	subtilis_exp_delete(val_exp);
	subtilis_exp_delete(size_exp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movl %r12d, %edi
movq %r8, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
jne 0x2eef5
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3415f
cmpl $0x0, (%r14)
je 0x2ef04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
xorl %edi, %edi
movq %r14, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
jne 0x2ef77
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3415f
cmpl $0x0, (%r14)
jne 0x2ef77
movq %rax, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x4ab28
cmpl $0x0, (%r14)
jne 0x2ef73
movq 0x148(%rbx), %rdx
movq (%rsp), %rcx
movq 0x148(%rcx), %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %r8
testb $0x3, %r12b
je 0x2ef6e
callq 0x2ec82
jmp 0x2ef73
callq 0x2ebb4
movq (%rsp), %rax
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29d88
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtins_ir_basic_rnd
subtilis_exp_t *subtilis_builtins_ir_basic_rnd(subtilis_parser_t *p,
					       subtilis_error_t *err)
{
	subtilis_exp_t *e = NULL;
	subtilis_exp_t *a = NULL;
	subtilis_exp_t *c = NULL;

	a = subtilis_exp_new_int32(1664525, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	c = subtilis_exp_new_int32(1013904223, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	e = subtilis_type_if_mul(p, a, e, err);
	a = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return subtilis_exp_add(p, e, c, err);

cleanup:

	subtilis_exp_delete(e);
	subtilis_exp_delete(a);
	subtilis_exp_delete(c);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movl $0x19660d, %edi         # imm = 0x19660D
callq 0x2a369
cmpl $0x0, (%r15)
jne 0x2f207
movq %rax, %r14
movl $0x3c6ef35f, %edi       # imm = 0x3C6EF35F
movq %r15, %rsi
callq 0x2a369
movq %rax, %rbx
cmpl $0x0, (%r15)
je 0x2f1ba
xorl %eax, %eax
jmp 0x2f1ef
leaq 0x76faf(%rip), %rax     # 0xa6170
movq (%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x33cb3
cmpl $0x0, (%r15)
jne 0x2f1ef
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x34bfb
cmpl $0x0, (%r15)
je 0x2f215
xorl %r14d, %r14d
movq %rax, %rdi
callq 0x29d88
movq %r14, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a5db
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtins_ir_rnd_0
subtilis_exp_t *subtilis_builtins_ir_rnd_0(subtilis_parser_t *p,
					   subtilis_error_t *err)
{
	subtilis_exp_t *e = NULL;
	subtilis_exp_t *top_bit = NULL;
	subtilis_exp_t *top_bit_dup = NULL;

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

	top_bit = subtilis_exp_new_int32((int32_t)0x7fffffff, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	top_bit_dup = subtilis_type_if_dup(top_bit, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_and(p, e, top_bit, err);
	top_bit = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_divr(p, e, top_bit_dup, err);
	top_bit_dup = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_exp_handle_errors(p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_exp_delete(e);
	subtilis_exp_delete(top_bit);
	subtilis_exp_delete(top_bit_dup);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x76f29(%rip), %rax     # 0xa6170
movq (%rax), %rsi
movq %r14, %rdx
callq 0x33cb3
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x2f260
xorl %r15d, %r15d
jmp 0x2f276
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2a369
movq %rax, %r15
cmpl $0x0, (%r14)
je 0x2f2a0
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x29d88
movq %r15, %rdi
callq 0x29d88
movq %r13, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x341c4
movq %rax, %r13
cmpl $0x0, (%r14)
jne 0x2f279
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x34ca6
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x2f2d3
xorl %r15d, %r15d
jmp 0x2f279
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x34ffa
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2f25b
movq %r12, %rdi
movq %r14, %rsi
callq 0x29c49
cmpl $0x0, (%r14)
jne 0x2f25b
jmp 0x2f293
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtins_ir_rnd_1
subtilis_exp_t *subtilis_builtins_ir_rnd_1(subtilis_parser_t *p,
					   subtilis_error_t *err)
{
	subtilis_exp_t *e;
	subtilis_exp_t *e_dup = NULL;
	subtilis_exp_t *top_bit = NULL;

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

	e_dup = subtilis_type_if_dup(e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_var_assign_hidden(p, subtilis_rnd_hidden_var,
				   &subtilis_type_integer, e_dup, err);
	e_dup = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	top_bit = subtilis_exp_new_int32((int32_t)0x7fffffff, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_and(p, e, top_bit, err);
	top_bit = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	top_bit = subtilis_exp_new_int32((int32_t)0x7fffffff, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_divr(p, e, top_bit, err);
	top_bit = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_exp_handle_errors(p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_exp_delete(top_bit);
	subtilis_exp_delete(e_dup);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x2f17f
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x2f329
xorl %r12d, %r12d
jmp 0x2f33d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x341c4
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x2f368
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %r12, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x76e01(%rip), %rax     # 0xa6170
movq (%rax), %rsi
leaq 0x3f54f(%rip), %rdx     # 0x6e8c8
movq %r15, %rdi
movq %r12, %rcx
movq %r14, %r8
callq 0x33be8
cmpl $0x0, (%r14)
jne 0x2f324
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
je 0x2f3a5
xorl %r12d, %r12d
jmp 0x2f33f
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x34ca6
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2f324
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
jne 0x2f3a0
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x34ffa
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2f324
movq %r15, %rdi
movq %r14, %rsi
callq 0x29c49
cmpl $0x0, (%r14)
jne 0x2f324
jmp 0x2f359
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtins_ir_rnd_pos
subtilis_exp_t *subtilis_builtins_ir_rnd_pos(subtilis_parser_t *p, int32_t val,
					     subtilis_error_t *err)
{
	subtilis_exp_t *e;
	subtilis_exp_t *m;
	subtilis_exp_t *e_dup = NULL;
	subtilis_exp_t *top_bit = NULL;

	e = subtilis_builtins_ir_basic_rnd(p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e_dup = subtilis_type_if_dup(e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_var_assign_hidden(p, subtilis_rnd_hidden_var,
				   &subtilis_type_integer, e_dup, err);
	e_dup = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	top_bit = subtilis_exp_new_int32((int32_t)0x7fffffff, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_and(p, e, top_bit, err);
	top_bit = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	m = subtilis_exp_new_int32(val, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	e = subtilis_type_if_mod(p, e, m, err);
	m = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	m = subtilis_exp_new_int32(1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return subtilis_exp_add(p, e, m, err);

cleanup:

	subtilis_exp_delete(top_bit);
	subtilis_exp_delete(e_dup);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rsi
callq 0x2f17f
cmpl $0x0, (%r14)
jne 0x2f485
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x341c4
movq %rax, %r12
cmpl $0x0, (%r14)
jne 0x2f46b
leaq 0x76d26(%rip), %rax     # 0xa6170
movq (%rax), %rsi
leaq 0x3f474(%rip), %rdx     # 0x6e8c8
movq %r15, %rdi
movq %r12, %rcx
movq %r14, %r8
callq 0x33be8
cmpl $0x0, (%r14)
je 0x2f490
xorl %r12d, %r12d
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %r12, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
je 0x2f4a8
xorl %r12d, %r12d
jmp 0x2f46d
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x34ca6
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2f468
movl %ebp, %edi
movq %r14, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
jne 0x2f468
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x34f7a
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2f468
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
jne 0x2f468
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a5db
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtins_ir_rnd_neg
subtilis_exp_t *subtilis_builtins_ir_rnd_neg(subtilis_parser_t *p, int32_t val,
					     subtilis_error_t *err)
{
	subtilis_exp_t *e;
	subtilis_exp_t *e_dup = NULL;

	e = subtilis_exp_new_int32(-val, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e_dup = subtilis_type_if_dup(e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_var_assign_hidden(p, subtilis_rnd_hidden_var,
				   &subtilis_type_integer, e_dup, err);
	e_dup = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return e;

cleanup:

	subtilis_exp_delete(e_dup);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
negl %esi
movl %esi, %edi
movq %rdx, %rsi
callq 0x2a369
cmpl $0x0, (%r14)
jne 0x2f586
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x341c4
cmpl $0x0, (%r14)
jne 0x2f576
leaq 0x76c1a(%rip), %rcx     # 0xa6170
movq (%rcx), %rsi
leaq 0x3f368(%rip), %rdx     # 0x6e8c8
movq %r15, %rdi
movq %rax, %rcx
movq %r14, %r8
callq 0x33be8
cmpl $0x0, (%r14)
je 0x2f588
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_find_first_stop
static size_t
prv_find_first_stop(subtilis_parser_t *p, subtilis_ir_operand_t str_data,
		    subtilis_ir_operand_t str_len,
		    subtilis_ir_operand_t max_digit, bool immediate_digit,
		    subtilis_ir_operand_t end_str,
		    subtilis_ir_operand_t end_label,
		    subtilis_ir_operand_t *minus, subtilis_error_t *err)
{
	subtilis_ir_operand_t skip_sign_label;
	subtilis_ir_operand_t first_end_label;
	subtilis_ir_operand_t condee;
	size_t ptr;
	subtilis_ir_operand_t byte;

	skip_sign_label.label = subtilis_ir_section_new_label(p->current);
	first_end_label.label = subtilis_ir_section_new_label(p->current);

	ptr = prv_find_first_stop_prolog(
	    p, str_data, str_len, max_digit, immediate_digit, end_str, &byte,
	    skip_sign_label, first_end_label, end_label, minus, &condee, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	subtilis_ir_section_add_instr_reg(p->current, SUBTILIS_OP_INSTR_JMPC_NF,
					  condee, first_end_label,
					  skip_sign_label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

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

	return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %rbp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x2b774
movq %rax, %r12
movq 0x48(%r14), %rdi
callq 0x2b774
subq $0x8, %rsp
leaq 0x10(%rsp), %r10
leaq 0x18(%rsp), %r9
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rax, %r15
movl %ebx, %ecx
movq 0x58(%rsp), %rbx
movq %rbp, %r8
pushq %rbx
pushq %r10
pushq 0x18(%rsp)
pushq %rax
pushq %r12
callq 0x33602
addq $0x30, %rsp
pushq $-0x1
popq %rbp
cmpl $0x0, (%rbx)
jne 0x31192
movq %rax, %r13
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rdx
pushq $0x44
popq %rsi
movq %r15, %rcx
movq %r12, %r8
movq %rbx, %r9
callq 0x2a8c1
cmpl $0x0, (%rbx)
jne 0x31192
movq 0x48(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2b781
movq %r13, %rbp
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_fp_to_str
subtilis_exp_t *subtilis_builtin_ir_call_fp_to_str(subtilis_parser_t *p,
						   size_t val_reg,
						   size_t buf_reg,
						   subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;

	const subtilis_type_t *ptype[2];

	ptype[0] = &subtilis_type_real;
	ptype[1] = &subtilis_type_integer;

	fn = prv_add_args(p, "_fp_to_str", 2, ptype, &subtilis_type_integer,
			  err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return NULL;
		subtilis_error_init(err);
	} else {
		subtilis_builtins_ir_fp_to_str(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

	return subtilis_parser_call_2_arg_fn(
	    p, "_fp_to_str", val_reg, buf_reg, SUBTILIS_IR_REG_TYPE_REAL,
	    SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_integer, false, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3cbfd(%rip), %rax     # 0x6e780
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x3cd36(%rip), %r13     # 0x6e8c8
movq %r13, 0x8(%rcx)
leaq 0x3d6b5(%rip), %rsi     # 0x6f252
pushq $0x2
popq %rdx
movq %r13, %r8
movq %r12, %r9
callq 0x314be
movl (%r12), %ecx
testl %ecx, %ecx
je 0x31bc2
cmpl $0x20, %ecx
jne 0x31bd7
movq %r12, %rdi
callq 0x140a4
jmp 0x31bdb
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x2fad0
cmpl $0x0, (%r12)
je 0x31bdb
xorl %eax, %eax
jmp 0x31c05
movq %r12, 0x10(%rsp)
movq %r13, (%rsp)
andl $0x0, 0x8(%rsp)
leaq 0x3d662(%rip), %rsi     # 0x6f252
pushq $0x1
popq %r8
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r9d, %r9d
callq 0x1deea
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_str_to_fp
subtilis_exp_t *subtilis_builtin_ir_call_str_to_fp(subtilis_parser_t *p,
						   size_t str_reg,
						   subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;

	const subtilis_type_t *ptype[1];

	ptype[0] = &subtilis_type_integer;

	fn = prv_add_args(p, "_str_to_fp", 1, ptype, &subtilis_type_real, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return NULL;
		subtilis_error_init(err);
	} else {
		subtilis_builtins_ir_str_to_fp(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

	return subtilis_parser_call_1_arg_fn(
	    p, "_str_to_fp", str_reg, SUBTILIS_BUILTINS_MAX,
	    SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_real, true, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3cc9c(%rip), %rax     # 0x6e8c8
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x3d622(%rip), %rsi     # 0x6f25d
leaq 0x3cb3e(%rip), %r8      # 0x6e780
pushq $0x1
popq %rdx
movq %rbx, %r9
callq 0x314be
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x31c62
cmpl $0x20, %ecx
jne 0x31c75
movq %rbx, %rdi
callq 0x140a4
jmp 0x31c7d
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x30802
cmpl $0x0, (%rbx)
je 0x31c7d
xorl %eax, %eax
addq $0x10, %rsp
jmp 0x31ca3
leaq 0x3d5d9(%rip), %rsi     # 0x6f25d
leaq 0x3caf5(%rip), %r9      # 0x6e780
pushq $0x9
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
pushq %rbx
pushq $0x1
callq 0x1de0d
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_add_args_ci
static subtilis_ir_section_t *prv_add_args_ci(subtilis_parser_t *p,
					      const char *name,
					      size_t arg_count,
					      const subtilis_type_t **ptype,
					      const subtilis_type_t *rtype,
					      size_t *call_index,
					      subtilis_error_t *err)
{
	subtilis_type_section_t *ts;
	subtilis_type_t *params;
	subtilis_ir_section_t *current = NULL;
	size_t j;
	size_t i = 0;

	params = malloc(sizeof(subtilis_type_t) * arg_count);
	if (!params) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	for (; i < arg_count; i++) {
		subtilis_type_init_copy(&params[i], ptype[i], err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}
	ts = subtilis_type_section_new(rtype, arg_count, params, NULL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	current = subtilis_ir_prog_section_new(
	    p->prog, name, 0, ts, SUBTILIS_BUILTINS_MAX, "builtin", 0,
	    p->eflag_offset, p->error_offset, call_index, err);

cleanup:

	for (j = 0; j < i; j++)
		subtilis_type_free(&params[j]);
	free(params);

	return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r15
movq %r8, 0x40(%rsp)
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x38(%rsp)
movq 0x80(%rsp), %rbp
imulq $0x148, %rdx, %rdi      # imm = 0x148
callq 0x121d0
testq %rax, %rax
je 0x32b06
movq %rax, %r13
movq %r15, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %rax, %rbx
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x32b25
movq (%r12,%r15,8), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x2db73
cmpl $0x0, (%rbp)
jne 0x32b96
incq %r15
addq $0x148, %rbx            # imm = 0x148
jmp 0x32adc
leaq 0x3c70c(%rip), %rdx     # 0x6f219
pushq $0x1
popq %rsi
movq %rbp, %rdi
movl $0xc2c, %ecx            # imm = 0xC2C
callq 0x1429e
xorl %r12d, %r12d
jmp 0x32bbb
xorl %r12d, %r12d
movq 0x40(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq %rbp, %r8
callq 0x2d9c4
cmpl $0x0, (%rbp)
jne 0x32b91
movq 0x38(%rsp), %rdx
movq 0x58(%rdx), %rdi
movl 0xb0(%rdx), %ecx
movl 0xb4(%rdx), %edx
movq %rbp, 0x20(%rsp)
movq 0x28(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0x8(%rsp)
andq $0x0, (%rsp)
leaq 0x3af6d(%rip), %r9      # 0x6dae8
pushq $0x9
popq %r8
movq 0x30(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2acef
movq %rax, %r12
movq %r14, %r15
jmp 0x32b99
xorl %r12d, %r12d
movq %r13, %rbx
subq $0x1, %r15
jb 0x32bb3
movq %rbx, %rdi
callq 0x2dc7c
addq $0x148, %rbx            # imm = 0x148
jmp 0x32b9c
movq %r13, %rdi
callq 0x122c0
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_deref_array_recs
size_t subtilis_builtin_ir_deref_array_recs(subtilis_parser_t *p,
					    const subtilis_type_t *el_type,
					    subtilis_error_t *err)
{
	char *name;
	size_t call_index;

	name = prv_get_deref_array_recs_name(el_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	call_index = prv_ir_deref_array_recs_create(p, el_type, name, err);

	free(name);
	return call_index;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x32c73
cmpl $0x0, (%rbx)
je 0x32c45
pushq $-0x1
popq %rax
jmp 0x32c67
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x32cd9
movq %rax, %rbx
movq %r14, %rdi
callq 0x122c0
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/builtins_ir.c
// Function: prv_get_deref_array_recs_name
static char *prv_get_deref_array_recs_name(const subtilis_type_t *el_type,
					   subtilis_error_t *err)
{
	char *name;
	const char *base_name = "_deref_array_";
	const char *el_type_name = subtilis_type_name(el_type);

	name = malloc(strlen(base_name) + strlen(el_type_name) + 1);
	if (!name) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	sprintf(name, "%s%s", base_name, el_type_name);

	return name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x2dcbb
movq %rax, %r15
movq %rax, %rdi
callq 0x120f0
leaq 0xe(%rax), %rdi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x32cb9
leaq 0x3da17(%rip), %rsi     # 0x706ba
leaq 0x3c60d(%rip), %rdx     # 0x6f2b7
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x12280
jmp 0x32cd0
leaq 0x3c559(%rip), %rdx     # 0x6f219
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0xd40, %ecx            # imm = 0xD40
callq 0x1429e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_ir_deref_array_recs_create
static size_t prv_ir_deref_array_recs_create(subtilis_parser_t *p,
					     const subtilis_type_t *el_type,
					     const char *name,
					     subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[2];
	size_t call_index = SIZE_MAX;

	ptype[0] = &subtilis_type_integer;
	fn = prv_add_args_ci(p, name, 1, ptype, &subtilis_type_void,
			     &call_index, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			return SIZE_MAX;
		subtilis_error_init(err);
	} else {
		prv_builtins_ir_deref_array_recs(p, fn, el_type, err);
	}

	return call_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r15
leaq 0x8(%rsp), %r9
orq $-0x1, (%r9)
movq %rdi, %r14
leaq 0x3bbc8(%rip), %rax     # 0x6e8c8
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, (%rsp)
leaq 0x3bf8d(%rip), %r8      # 0x6eca0
pushq $0x1
popq %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x32a8c
movq %rax, %r12
movl (%rbx), %eax
testl %eax, %eax
je 0x32d40
cmpl $0x20, %eax
jne 0x32dda
movq %rbx, %rdi
callq 0x140a4
jmp 0x32dd3
movq 0x48(%r14), %r13
movq %r12, 0x48(%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x35ac5
cmpl $0x0, (%rbx)
jne 0x32dcf
movq %rax, %rbp
movq 0x48(%r14), %rdi
movl $0x9b, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2a981
cmpl $0x0, (%rbx)
jne 0x32dcf
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %rcx, %rbp
movq %r15, %rdi
movq %rax, %r15
callq 0x2e586
movl %eax, %edx
orq %rbp, %rdx
pushq $0x1b
popq %rsi
movq %r12, %rdi
movq %rbx, %rcx
callq 0x2a981
cmpl $0x0, (%rbx)
jne 0x32dcf
movq %r15, %rcx
pushq $0x4
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %r8
callq 0x311a4
cmpl $0x0, (%rbx)
jne 0x32dcf
movq 0x48(%r14), %rdi
pushq $0x46
popq %rsi
movq %rbx, %rdx
callq 0x2a9af
movq %r13, 0x48(%r14)
movq 0x8(%rsp), %rax
jmp 0x32ddd
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_deref_array_recs
void subtilis_builtin_ir_call_deref_array_recs(subtilis_parser_t *p,
					       const subtilis_type_t *el_type,
					       size_t base_reg,
					       subtilis_error_t *err)
{
	char *name;

	name = prv_get_deref_array_recs_name(el_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	(void)prv_ir_deref_array_recs_create(p, el_type, name, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	(void)subtilis_parser_call_1_arg_fn(
		p, name, base_reg, SUBTILIS_BUILTINS_MAX,
		SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_void, false,
		err);

cleanup:
	free(name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x32c73
cmpl $0x0, (%r12)
je 0x32e25
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r12, %rcx
callq 0x32cd9
cmpl $0x0, (%r12)
jne 0x32e64
movq %r12, 0x8(%rsp)
andl $0x0, (%rsp)
leaq 0x3be50(%rip), %r9      # 0x6eca0
pushq $0x9
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x1de0d
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x122c0