LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x3040e
movq 0x18(%rdi), %r14
xorl %ebx, %ebx
movl $0x800270, %ebp         # imm = 0x800270
movl $0x1, %r12d
movl (%r14), %eax
cmpl $0x17, %eax
ja 0x30409
btl %eax, %ebp
jae 0x303ef
addq $0x148, %r14            # imm = 0x148
decq %r15
jne 0x303d4
jmp 0x30410
cmpl $0x16, %eax
jne 0x30409
movq %r14, %rdi
callq 0x303b2
cmpq $0x4, %rax
cmovaeq %r12, %rax
addq %rax, %rbx
jmp 0x303e1
incq %rbx
jmp 0x303e1
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r15
testq %r15, %r15
setne %bl
je 0x30485
movq 0x18(%rdi), %r14
movq %r15, %r12
negq %r12
movl $0x1, %r13d
movl $0x800270, %ebp         # imm = 0x800270
movl (%r14), %eax
cmpl $0x17, %eax
ja 0x30485
btl %eax, %ebp
jae 0x30474
cmpq %r15, %r13
setb %bl
leaq (%r12,%r13), %rax
incq %rax
incq %r13
addq $0x148, %r14            # imm = 0x148
cmpq $0x1, %rax
jne 0x30448
jmp 0x30485
cmpl $0x16, %eax
jne 0x30485
movq %r14, %rdi
callq 0x3041c
testb %al, %al
je 0x30455
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r12
testq %r12, %r12
setne %bl
je 0x30525
movq 0x18(%rdi), %r15
movq %r12, %r13
negq %r13
movl $0x1, %ebp
movl $0x10, %r14d
movq %rdi, (%rsp)
movl (%r15), %eax
leal -0x10(%rax), %ecx
cmpl $0x6, %ecx
jae 0x30506
movq 0x20(%rdi), %rax
cmpl $-0x1, (%rax,%r14)
jne 0x30525
cmpq %r12, %rbp
setb %bl
leaq 0x1(,%rbp), %rax
addq %r13, %rax
incq %rbp
addq $0x148, %r15            # imm = 0x148
addq $0x18, %r14
cmpq $0x1, %rax
jne 0x304c9
jmp 0x30525
cmpl $0x16, %eax
je 0x30515
addl $-0xa, %eax
cmpl $0x6, %eax
jae 0x304df
jmp 0x30525
movq %r15, %rdi
callq 0x30499
movq (%rsp), %rdi
testb %al, %al
je 0x304df
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30584
leaq 0x42f70(%rip), %rsi     # 0x734c8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14bd4
cmpl $0x0, (%rbx)
jne 0x3059b
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f8da
cmpl $0x0, (%rbx)
jne 0x3059b
leaq 0x43c90(%rip), %rsi     # 0x74212
jmp 0x3058b
leaq 0x44c33(%rip), %rsi     # 0x751be
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14bd4
cmpl $0x0, (%rbx)
je 0x305a5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0x8(%r15)
je 0x305f3
xorl %r13d, %r13d
leaq 0x42fe2(%rip), %r12     # 0x73598
movq 0x10(%r15,%r13,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f8da
cmpl $0x0, (%rbx)
jne 0x3059b
movq 0x8(%r15), %rax
decq %rax
cmpq %rax, %r13
je 0x305f3
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x14bd4
cmpl $0x0, (%rbx)
jne 0x3059b
incq %r13
cmpq 0x8(%r15), %r13
jb 0x305b6
leaq 0x434f3(%rip), %rsi     # 0x73aed
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x14bd4
// File: /workspace/github_c_makefile_star2_O1/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 0x14bd4
cmpl $0x0, (%rbx)
jne 0x3072d
leaq 0x43bd4(%rip), %rsi     # 0x74212
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14bd4
cmpl $0x0, (%rbx)
jne 0x3072d
cmpq $0x0, 0x20(%r15)
je 0x30660
cmpq $0x1, 0x20(%r15)
jne 0x3069c
xorl %r13d, %r13d
movq 0x10(%r15), %rax
imulq $0x148, %r13, %rdx      # imm = 0x148
movl (%rax,%rdx), %ecx
cmpq $0x16, %rcx
jne 0x30680
addq %rdx, %rax
addq $0x10, %rax
jmp 0x30694
cmpl $0x18, %ecx
ja 0x30716
leaq 0x6cf50(%rip), %rax     # 0x9d5e0
leaq (%rax,%rcx,8), %rax
movq (%rax), %rsi
jmp 0x3071d
movl $0x10, %ebp
xorl %r13d, %r13d
leaq 0x42eed(%rip), %r12     # 0x73598
movq 0x10(%r15), %rax
movl -0x10(%rax,%rbp), %ecx
cmpq $0x16, %rcx
jne 0x306be
addq %rbp, %rax
jmp 0x306d5
leaq 0x449f1(%rip), %rsi     # 0x750b6
cmpl $0x18, %ecx
ja 0x306d8
leaq 0x6cf0f(%rip), %rax     # 0x9d5e0
leaq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14bd4
cmpl $0x0, (%rbx)
jne 0x3072d
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x14bd4
cmpl $0x0, (%rbx)
jne 0x3072d
incq %r13
movq 0x20(%r15), %rax
decq %rax
addq $0x148, %rbp            # imm = 0x148
cmpq %rax, %r13
jb 0x306ab
jmp 0x30663
leaq 0x44999(%rip), %rsi     # 0x750b6
movq %r14, %rdi
movq %rbx, %rdx
callq 0x14bd4
cmpl $0x0, (%rbx)
je 0x3073c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x433aa(%rip), %rsi     # 0x73aed
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14bd4
// File: /workspace/github_c_makefile_star2_O1/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, %rbx      # imm = 0x688
leaq 0x6cf33(%rip), %r14     # 0x9d6b0
movq 0x158(%rbx,%r14), %r13
imulq $0x148, %r13, %rdi      # imm = 0x148
callq 0x121d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x3081f
addq %rbx, %r14
movq %r14, 0x10(%rsp)
testq %r13, %r13
je 0x307fc
movq 0x8(%rsp), %r14
movq %r14, %rax
movq %r13, %rcx
movl $0x8, (%rax)
addq $0x148, %rax            # imm = 0x148
decq %rcx
jne 0x307b7
movq 0x10(%rsp), %rax
leaq 0x160(%rax), %rbp
movl $0x148, %r12d           # imm = 0x148
movq %r13, %rbx
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x2fa5f
cmpl $0x0, (%r15)
jne 0x3083d
addq %r12, %rbp
addq %r12, %r14
decq %rbx
jne 0x307dd
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x2f57c
movq %rax, %r15
jmp 0x30845
leaq 0x449e4(%rip), %rdx     # 0x7520a
movq %r15, %rdi
movl $0x1, %esi
movl $0x3f, %ecx
callq 0x145f4
xorl %r15d, %r15d
jmp 0x30869
movq 0x8(%rsp), %rbx
xorl %r15d, %r15d
testq %r13, %r13
je 0x30861
movq %rbx, %r14
movq %r14, %rdi
callq 0x2f843
addq $0x148, %r14            # imm = 0x148
decq %r13
jne 0x3084d
movq %rbx, %rdi
callq 0x122c0
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0xb, %edi
callq 0x121d0
testq %rax, %rax
je 0x30918
movq %rax, %r12
movabsq $0x697465736d656d5f, %rax # imm = 0x697465736D656D5F
movq %rax, (%r12)
movl $0x323369, 0x7(%r12)    # imm = 0x323369
movl $0x48, %edi
callq 0x121d0
testq %rax, %rax
je 0x3092e
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rbp, 0x8(%rax)
movl %ecx, 0x18(%rax)
movq %r13, 0x20(%rax)
movl %ecx, 0x30(%rax)
movq %r15, 0x38(%rax)
subq $0x8, %rsp
leaq 0x443e1(%rip), %r9      # 0x74cd0
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
movq %rax, %r8
pushq %rbx
pushq $0x1
pushq $0x3
callq 0x2b507
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x448fd(%rip), %rdx     # 0x7521c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x23, %ecx
jmp 0x3094a
movq %r12, %rdi
callq 0x122c0
leaq 0x448df(%rip), %rdx     # 0x7521c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2b, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0xa, %edi
callq 0x121d0
testq %rax, %rax
je 0x309f8
movq %rax, %r12
movabsq $0x697465736d656d5f, %rax # imm = 0x697465736D656D5F
movq %rax, (%r12)
movw $0x38, 0x8(%r12)
movl $0x48, %edi
callq 0x121d0
testq %rax, %rax
je 0x30a0e
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rbp, 0x8(%rax)
movl %ecx, 0x18(%rax)
movq %r13, 0x20(%rax)
movl %ecx, 0x30(%rax)
movq %r15, 0x38(%rax)
subq $0x8, %rsp
leaq 0x44301(%rip), %r9      # 0x74cd0
movq %r14, %rdi
movq %r12, %rsi
movl $0x5, %edx
xorl %ecx, %ecx
movq %rax, %r8
pushq %rbx
pushq $0x1
pushq $0x3
callq 0x2b507
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4481d(%rip), %rdx     # 0x7521c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x44, %ecx
jmp 0x30a2a
movq %r12, %rdi
callq 0x122c0
leaq 0x447ff(%rip), %rdx     # 0x7521c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x4c, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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)
movl $0xb, %edi
callq 0x121d0
testq %rax, %rax
je 0x30ae6
movq %rax, %r12
movabsq $0x697465736d656d5f, %rax # imm = 0x697465736D656D5F
movq %rax, (%r12)
movl $0x343669, 0x7(%r12)    # imm = 0x343669
movl $0x60, %edi
callq 0x121d0
testq %rax, %rax
je 0x30afc
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %r14, 0x8(%rax)
movl %ecx, 0x18(%rax)
movq %rbp, 0x20(%rax)
movl %ecx, 0x30(%rax)
movq %r13, 0x38(%rax)
movl %ecx, 0x48(%rax)
movq %r15, 0x50(%rax)
subq $0x8, %rsp
leaq 0x44215(%rip), %r9      # 0x74cd0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movl $0x8, %edx
xorl %ecx, %ecx
movq %rax, %r8
pushq %rbx
pushq $0x1
pushq $0x4
callq 0x2b507
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4472f(%rip), %rdx     # 0x7521c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x65, %ecx
jmp 0x30b18
movq %r12, %rdi
callq 0x122c0
leaq 0x44711(%rip), %rdx     # 0x7521c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x2bb29
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x30b9e
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36269
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x30b9e
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x4d763
cmpl $0x0, (%r14)
jne 0x30b9e
movq 0x148(%rbx), %rcx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %r8
callq 0x3095d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b4c3
// File: /workspace/github_c_makefile_star2_O1/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 0x2bb29
cmpl $0x0, (%r14)
jne 0x30bf3
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x36269
cmpl $0x0, (%r14)
je 0x30c02
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 0x2bb29
cmpl $0x0, (%r14)
jne 0x30c75
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x36269
cmpl $0x0, (%r14)
jne 0x30c75
movq %rax, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x4d763
cmpl $0x0, (%r14)
jne 0x30c71
movq 0x148(%rbx), %rdx
movq (%rsp), %rcx
movq 0x148(%rcx), %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %r8
testb $0x3, %r12b
je 0x30c6c
callq 0x3095d
jmp 0x30c71
callq 0x3087c
movq (%rsp), %rax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b4c3
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2bb29
cmpl $0x0, (%r15)
jne 0x30f1f
movq %rax, %r14
movl $0x3c6ef35f, %edi       # imm = 0x3C6EF35F
movq %r15, %rsi
callq 0x2bb29
movq %rax, %rbx
cmpl $0x0, (%r15)
je 0x30ed2
xorl %eax, %eax
jmp 0x30f07
leaq 0x75297(%rip), %rax     # 0xa6170
movq (%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x35d95
cmpl $0x0, (%r15)
jne 0x30f07
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x36d24
cmpl $0x0, (%r15)
je 0x30f2d
xorl %r14d, %r14d
movq %rax, %rdi
callq 0x2b4c3
movq %r14, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
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 0x2bdbb
// File: /workspace/github_c_makefile_star2_O1/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 0x75211(%rip), %rax     # 0xa6170
movq (%rax), %rsi
movq %r14, %rdx
callq 0x35d95
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x30f78
xorl %r15d, %r15d
jmp 0x30f8e
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2bb29
movq %rax, %r15
cmpl $0x0, (%r14)
je 0x30fb8
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x2b4c3
movq %r15, %rdi
callq 0x2b4c3
movq %r13, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x362d2
movq %rax, %r13
cmpl $0x0, (%r14)
jne 0x30f91
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x36db8
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x30feb
xorl %r15d, %r15d
jmp 0x30f91
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x3706d
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x30f73
movq %r12, %rdi
movq %r14, %rsi
callq 0x2b37c
cmpl $0x0, (%r14)
jne 0x30f73
jmp 0x30fab
// File: /workspace/github_c_makefile_star2_O1/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 0x30e97
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x31041
xorl %r12d, %r12d
jmp 0x31055
movq %rbx, %rdi
movq %r14, %rsi
callq 0x362d2
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x31080
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %r12, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x750e9(%rip), %rax     # 0xa6170
movq (%rax), %rsi
leaq 0x43867(%rip), %rdx     # 0x748f8
movq %r15, %rdi
movq %r12, %rcx
movq %r14, %r8
callq 0x35cc8
cmpl $0x0, (%r14)
jne 0x3103c
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2bb29
cmpl $0x0, (%r14)
je 0x310bd
xorl %r12d, %r12d
jmp 0x31057
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36db8
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x3103c
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2bb29
cmpl $0x0, (%r14)
jne 0x310b8
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x3706d
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x3103c
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b37c
cmpl $0x0, (%r14)
jne 0x3103c
jmp 0x31071
// File: /workspace/github_c_makefile_star2_O1/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 0x30e97
cmpl $0x0, (%r14)
jne 0x3119d
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x362d2
movq %rax, %r12
cmpl $0x0, (%r14)
jne 0x31183
leaq 0x7500e(%rip), %rax     # 0xa6170
movq (%rax), %rsi
leaq 0x4378c(%rip), %rdx     # 0x748f8
movq %r15, %rdi
movq %r12, %rcx
movq %r14, %r8
callq 0x35cc8
cmpl $0x0, (%r14)
je 0x311a8
xorl %r12d, %r12d
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %r12, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %r14, %rsi
callq 0x2bb29
cmpl $0x0, (%r14)
je 0x311c0
xorl %r12d, %r12d
jmp 0x31185
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36db8
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x31180
movl %ebp, %edi
movq %r14, %rsi
callq 0x2bb29
cmpl $0x0, (%r14)
jne 0x31180
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36fed
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x31180
movl $0x1, %edi
movq %r14, %rsi
callq 0x2bb29
cmpl $0x0, (%r14)
jne 0x31180
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2bdbb
// File: /workspace/github_c_makefile_star2_O1/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 0x2bb29
cmpl $0x0, (%r14)
jne 0x312a0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x362d2
cmpl $0x0, (%r14)
jne 0x31290
leaq 0x74f00(%rip), %rcx     # 0xa6170
movq (%rcx), %rsi
leaq 0x4367e(%rip), %rdx     # 0x748f8
movq %r15, %rdi
movq %rax, %rcx
movq %r14, %r8
callq 0x35cc8
cmpl $0x0, (%r14)
je 0x312a2
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d00a
movq %rax, %r12
movq 0x48(%r14), %rdi
callq 0x2d00a
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 0x34ea6
addq $0x30, %rsp
movq $-0x1, %rbp
cmpl $0x0, (%rbx)
jne 0x329e5
movq %rax, %r13
movq 0x48(%r14), %rdi
movq 0x8(%rsp), %rdx
movl $0x44, %esi
movq %r15, %rcx
movq %r12, %r8
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x329e5
movq 0x48(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2d017
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_O1/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 $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x40d51(%rip), %rax     # 0x747b0
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x40e8c(%rip), %r14     # 0x748f8
movq %r14, 0x8(%rcx)
subq $0x8, %rsp
leaq 0x41807(%rip), %rsi     # 0x75282
movl $0x2, %edx
movq %r14, %r8
xorl %r9d, %r9d
pushq %rbx
callq 0x34307
addq $0x10, %rsp
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x33aa5
cmpl $0x20, %ecx
jne 0x33ab8
movq %rbx, %rdi
callq 0x14404
jmp 0x33ac0
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x3180e
cmpl $0x0, (%rbx)
je 0x33ac0
xorl %eax, %eax
addq $0x10, %rsp
jmp 0x33aeb
subq $0x8, %rsp
leaq 0x417b7(%rip), %rsi     # 0x75282
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
pushq %rbx
pushq $0x0
pushq %r14
callq 0x1ea95
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x40dea(%rip), %rax     # 0x748f8
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
subq $0x8, %rsp
leaq 0x4176c(%rip), %rsi     # 0x7528d
leaq 0x40c88(%rip), %r8      # 0x747b0
movl $0x1, %edx
xorl %r9d, %r9d
pushq %rbx
callq 0x34307
addq $0x10, %rsp
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x33b4f
cmpl $0x20, %ecx
jne 0x33b62
movq %rbx, %rdi
callq 0x14404
jmp 0x33b6a
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x325f9
cmpl $0x0, (%rbx)
je 0x33b6a
xorl %eax, %eax
addq $0x10, %rsp
jmp 0x33b92
leaq 0x4171c(%rip), %rsi     # 0x7528d
leaq 0x40c38(%rip), %r9      # 0x747b0
movq %r15, %rdi
movq %r14, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x1
callq 0x1e9b2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
movq 0x60(%rsp), %r12
imulq $0x148, %rdx, %rdi      # imm = 0x148
callq 0x121d0
testq %rax, %rax
je 0x3438d
movq %rax, %r15
movq %r13, 0x10(%rsp)
testq %r14, %r14
je 0x343ad
movq %rbx, 0x8(%rsp)
movq %r15, %rbx
xorl %r13d, %r13d
movq (%rbp,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x2f72e
cmpl $0x0, (%r12)
jne 0x34417
incq %r13
addq $0x148, %rbx            # imm = 0x148
cmpq %r13, %r14
jne 0x34359
movq %r14, %r13
movq 0x8(%rsp), %rbx
jmp 0x343b0
leaq 0x40eb5(%rip), %rdx     # 0x75249
movq %r12, %rdi
movl $0x1, %esi
movl $0xc2c, %ecx            # imm = 0xC2C
callq 0x145f4
xorl %ebp, %ebp
jmp 0x3443d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x2f57c
cmpl $0x0, (%r12)
jne 0x34419
movq 0x18(%rsp), %rcx
movq 0x58(%rcx), %rdi
movl 0xb0(%rcx), %r10d
movl 0xb4(%rcx), %r11d
subq $0x8, %rsp
leaq 0x3f728(%rip), %r9      # 0x73b18
movq 0x18(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
movl $0x9, %r8d
pushq %r12
pushq %rbx
pushq %r11
pushq %r10
pushq $0x0
callq 0x2c522
addq $0x30, %rsp
movq %rax, %rbp
jmp 0x34419
xorl %ebp, %ebp
testq %r13, %r13
je 0x34435
movq %r15, %rbx
movq %rbx, %rdi
callq 0x2f843
addq $0x148, %rbx            # imm = 0x148
decq %r13
jne 0x34421
movq %r15, %rdi
callq 0x122c0
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x344f0
cmpl $0x0, (%rbx)
je 0x344c2
movq $-0x1, %rax
jmp 0x344e4
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x3455b
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_O1/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, %r15
callq 0x2f882
movq %rax, %rbx
movq %rax, %rdi
callq 0x120f0
leaq 0xe(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x34536
movq %rax, %r14
leaq 0x421ea(%rip), %rsi     # 0x7670a
leaq 0x40dc0(%rip), %rdx     # 0x752e7
movq %rax, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x12280
jmp 0x34552
leaq 0x40d0c(%rip), %rdx     # 0x75249
movq %r15, %rdi
movl $0x1, %esi
movl $0xd40, %ecx            # imm = 0xD40
callq 0x145f4
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdx, %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r9
movq $-0x1, (%r9)
leaq 0x40370(%rip), %rdx     # 0x748f8
leaq 0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq %rbx, (%rsp)
leaq 0x40735(%rip), %r8      # 0x74cd0
movl $0x1, %edx
movq %rax, %rsi
callq 0x34307
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x345cb
movq $-0x1, %rax
cmpl $0x20, %ecx
jne 0x3466c
movq %rbx, %rdi
callq 0x14404
jmp 0x34667
movq %rax, %r12
movq 0x48(%r14), %r13
movq %rax, 0x48(%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x37b1b
cmpl $0x0, (%rbx)
jne 0x34663
movq %rax, %rbp
movq 0x48(%r14), %rdi
movl $0x9b, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2c189
cmpl $0x0, (%rbx)
jne 0x34663
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %rcx, %rbp
movq %r15, %rdi
movq %rax, %r15
callq 0x30197
movl %eax, %edx
orq %rbp, %rdx
movq %r12, %rdi
movl $0x1b, %esi
movq %rbx, %rcx
callq 0x2c189
cmpl $0x0, (%rbx)
jne 0x34663
movq %r15, %rcx
movl $0x4, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %r8
callq 0x33030
cmpl $0x0, (%rbx)
jne 0x34663
movq 0x48(%r14), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2c1b7
movq %r13, 0x48(%r14)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x344f0
cmpl $0x0, (%rbx)
je 0x346aa
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x3455b
cmpl $0x0, (%rbx)
jne 0x346e7
leaq 0x40606(%rip), %r9      # 0x74cd0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x9, %ecx
xorl %r8d, %r8d
pushq %rbx
pushq $0x0
callq 0x1e9b2
addq $0x10, %rsp
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x122c0
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_deref
size_t subtilis_builtin_ir_call_deref(subtilis_parser_t *p,
				      subtilis_error_t *err)
{
	subtilis_ir_section_t *fn;
	const subtilis_type_t *ptype[1];
	size_t call_index;
	const char *name = "_call_deref";

	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_call_deref(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return SIZE_MAX;
	}

	return call_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x401e5(%rip), %rax     # 0x748f8
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, (%rsp)
leaq 0x40b9e(%rip), %rsi     # 0x752c4
leaq 0x405a3(%rip), %r8      # 0x74cd0
leaq 0x8(%rsp), %r9
movl $0x1, %edx
callq 0x34307
movl (%rbx), %ecx
movq $-0x1, %r15
testl %ecx, %ecx
je 0x3475f
cmpl $0x20, %ecx
jne 0x34838
movq %rbx, %rdi
callq 0x14404
jmp 0x34833
movq 0x48(%r14), %rbp
movq %rax, 0x48(%r14)
movq %rax, %rdi
callq 0x2d00a
movq %rax, %r13
movq 0x48(%r14), %rdi
callq 0x2d00a
movq %rax, %r12
movq 0x48(%r14), %rdi
movl $0x4, %edx
movl $0x12, %esi
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x3482a
movq 0x48(%r14), %rdi
movl $0x43, %esi
movq %rax, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x3482a
movq 0x48(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x3482a
movq 0x48(%r14), %rdi
movl $0x4, %edx
movl $0x8, %ecx
movl $0x12, %esi
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x3482a
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x4d5af
cmpl $0x0, (%rbx)
jne 0x3482a
movq 0x48(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2d017
cmpl $0x0, (%rbx)
jne 0x3482a
movq 0x48(%r14), %rdi
movl $0x46, %esi
movq %rbx, %rdx
callq 0x2c1b7
movq %rbp, 0x48(%r14)
cmpl $0x0, (%rbx)
jne 0x34838
movq 0x8(%rsp), %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq