LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3f550
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
imulq $0x148, %rcx, %rcx      # imm = 0x148
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
addl $-0x4, %eax
subl $0x3, %eax
jb 0x3f505
jmp 0x3f4e7
movl -0x34(%rbp), %eax
subl $0x9, %eax
je 0x3f505
jmp 0x3f4f1
movl -0x34(%rbp), %eax
subl $0x16, %eax
je 0x3f507
jmp 0x3f4fb
movl -0x34(%rbp), %eax
subl $0x17, %eax
jne 0x3f531
jmp 0x3f505
jmp 0x3f53d
movq -0x10(%rbp), %rdi
callq 0x3f480
movq %rax, -0x30(%rbp)
cmpq $0x4, -0x30(%rbp)
jb 0x3f523
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3f53d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3f53f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3f4a8
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3f60b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x148, %rcx, %rcx      # imm = 0x148
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x4, %eax
subl $0x3, %eax
jb 0x3f5d9
jmp 0x3f5bb
movl -0x2c(%rbp), %eax
subl $0x9, %eax
je 0x3f5d9
jmp 0x3f5c5
movl -0x2c(%rbp), %eax
subl $0x16, %eax
je 0x3f5db
jmp 0x3f5cf
movl -0x2c(%rbp), %eax
subl $0x17, %eax
jne 0x3f5f2
jmp 0x3f5d9
jmp 0x3f5fa
movq -0x18(%rbp), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x3f5ea
jmp 0x3f5f0
movb $0x1, -0x1(%rbp)
jmp 0x3f60f
jmp 0x3f5f8
movb $0x1, -0x1(%rbp)
jmp 0x3f60f
jmp 0x3f5fa
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f580
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3f6e6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x148, %rcx, %rcx      # imm = 0x148
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0xa, %eax
subl $0x6, %eax
jb 0x3f696
jmp 0x3f67f
movl -0x2c(%rbp), %eax
addl $-0x10, %eax
subl $0x6, %eax
jb 0x3f69c
jmp 0x3f68c
movl -0x2c(%rbp), %eax
subl $0x16, %eax
je 0x3f6ba
jmp 0x3f6d1
movb $0x1, -0x1(%rbp)
jmp 0x3f6ea
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
cmpl $-0x1, 0x10(%rax)
je 0x3f6b8
movb $0x1, -0x1(%rbp)
jmp 0x3f6ea
jmp 0x3f6d3
movq -0x18(%rbp), %rdi
callq 0x3f620
testb $0x1, %al
jne 0x3f6c9
jmp 0x3f6cf
movb $0x1, -0x1(%rbp)
jmp 0x3f6ea
jmp 0x3f6d3
jmp 0x3f6d3
jmp 0x3f6d5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f640
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3f778
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6adcd(%rip), %rsi     # 0xaa4fa
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f740
jmp 0x3f82f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e240
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f762
jmp 0x3f82f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6bb2b(%rip), %rsi     # 0xab29c
callq 0x16310
jmp 0x3f78c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6ca0f(%rip), %rsi     # 0xac196
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f79a
jmp 0x3f82f
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3f81b
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e240
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f7d5
jmp 0x3f82f
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x3f7ec
jmp 0x3f81b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6adae(%rip), %rsi     # 0xaa5a9
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f80b
jmp 0x3f82f
jmp 0x3f80d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f7a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6b327(%rip), %rsi     # 0xaab51
callq 0x16310
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f877
jmp 0x3f988
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6ba16(%rip), %rsi     # 0xab29c
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f899
jmp 0x3f988
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x3f939
jmp 0x3f8b2
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3f937
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x148, -0x20(%rbp), %rax # imm = 0x148
addq %rax, %rdi
callq 0x3e190
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f905
jmp 0x3f988
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6ac95(%rip), %rsi     # 0xaa5a9
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f924
jmp 0x3f988
jmp 0x3f926
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f8b2
jmp 0x3f939
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x148, -0x20(%rbp), %rax # imm = 0x148
addq %rax, %rdi
callq 0x3e190
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x16310
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f974
jmp 0x3f988
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6b1ce(%rip), %rsi     # 0xaab51
callq 0x16310
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x8bd7d(%rip), %rax     # 0xcb730
imulq $0x688, %rcx, %rcx      # imm = 0x688
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
imulq $0x148, 0x158(%rax), %rdi # imm = 0x148
callq 0x121b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3fa07
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x6c7f2(%rip), %rdx     # 0xac1e2
movl $0x3f, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3fb19
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x158(%rcx), %rax
jae 0x3fa43
movq -0x28(%rbp), %rax
imulq $0x148, -0x30(%rbp), %rcx # imm = 0x148
addq %rcx, %rax
movl $0x8, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3fa0f
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x158(%rcx), %rax
jae 0x3faa5
movq -0x28(%rbp), %rdi
imulq $0x148, -0x30(%rbp), %rax # imm = 0x148
addq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x160, %rsi            # imm = 0x160
imulq $0x148, -0x30(%rbp), %rax # imm = 0x148
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3e4f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3fa95
jmp 0x3facd
jmp 0x3fa97
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3fa4b
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rax
movq 0x158(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x3dc00
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x158(%rcx), %rax
jae 0x3fb08
movq -0x28(%rbp), %rdi
imulq $0x148, -0x30(%rbp), %rax # imm = 0x148
addq %rax, %rdi
callq 0x3e100
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3fad5
movq -0x28(%rbp), %rdi
callq 0x12290
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movl $0xb, %edi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3fb88
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x6c69b(%rip), %rdx     # 0xac214
movl $0x23, %ecx
callq 0x158e0
jmp 0x3fc4e
movq -0x38(%rbp), %rdi
leaq 0x6c661(%rip), %rsi     # 0xac1f4
callq 0x12060
movl $0x48, %edi
callq 0x121b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3fbd2
movq -0x38(%rbp), %rdi
callq 0x12290
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x6c64e(%rip), %rdx     # 0xac214
movl $0x2b, %ecx
callq 0x158e0
jmp 0x3fc4e
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %rax
movl $0x1, %edx
xorl %ecx, %ecx
leaq 0x6c074(%rip), %r9      # 0xabca8
movq $0x3, (%rsp)
movl $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x36f50
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movl $0xa, %edi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3fcb8
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x6c56b(%rip), %rdx     # 0xac214
movl $0x44, %ecx
callq 0x158e0
jmp 0x3fd7e
movq -0x38(%rbp), %rdi
leaq 0x6c53c(%rip), %rsi     # 0xac1ff
callq 0x12060
movl $0x48, %edi
callq 0x121b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3fd02
movq -0x38(%rbp), %rdi
callq 0x12290
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x6c51e(%rip), %rdx     # 0xac214
movl $0x4c, %ecx
callq 0x158e0
jmp 0x3fd7e
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %rax
movl $0x5, %edx
xorl %ecx, %ecx
leaq 0x6bf44(%rip), %r9      # 0xabca8
movq $0x3, (%rsp)
movl $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x36f50
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movl $0xb, %edi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3fdec
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0x6c437(%rip), %rdx     # 0xac214
movl $0x65, %ecx
callq 0x158e0
jmp 0x3fecc
movq -0x40(%rbp), %rdi
leaq 0x6c412(%rip), %rsi     # 0xac209
callq 0x12060
movl $0x60, %edi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3fe39
movq -0x40(%rbp), %rdi
callq 0x12290
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0x6c3ea(%rip), %rdx     # 0xac214
movl $0x6d, %ecx
callq 0x158e0
jmp 0x3fecc
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %rax
movl $0x8, %edx
xorl %ecx, %ecx
leaq 0x6bdf6(%rip), %r9      # 0xabca8
movq $0x4, (%rsp)
movl $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x36f50
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3ff1e
jmp 0x3ff82
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3ff3e
jmp 0x3ff82
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6d920
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3ff62
jmp 0x3ff82
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x3fc60
movq -0x30(%rbp), %rdi
callq 0x36ee0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3ffed
jmp 0x400e6
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40010
jmp 0x400e6
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x37800
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4002d
jmp 0x400d4
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40050
jmp 0x400d4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6d920
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40074
jmp 0x400d4
movq -0x20(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x400ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x148(%rax), %rdx
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x3fc60
jmp 0x400d2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x148(%rax), %rdx
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x3fb30
jmp 0x400d4
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movl $0x19660d, %edi         # imm = 0x19660D
callq 0x37800
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x403e0
movq $0x0, -0x8(%rbp)
jmp 0x4048d
movq -0x18(%rbp), %rsi
movl $0x3c6ef35f, %edi       # imm = 0x3C6EF35F
callq 0x37800
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x403fd
jmp 0x4046a
movq -0x10(%rbp), %rdi
leaq 0x94428(%rip), %rax     # 0xd4830
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x47240
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40423
jmp 0x4046a
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x48fb0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4044f
jmp 0x4046a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x37bd0
movq %rax, -0x8(%rbp)
jmp 0x4048d
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9435d(%rip), %rax     # 0xd4830
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x47240
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x404f1
jmp 0x405a7
movq -0x18(%rbp), %rsi
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
callq 0x37800
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40511
jmp 0x405a7
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x47d20
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4052d
jmp 0x405a7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x49090
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40559
jmp 0x405a7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x494b0
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40585
jmp 0x405a7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ce0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4059d
jmp 0x405a7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x405ca
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
xorl %edi, %edi
subl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x37800
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40940
movq $0x0, -0x8(%rbp)
jmp 0x409b5
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x47d20
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4095c
jmp 0x4099b
movq -0x10(%rbp), %rdi
leaq 0x93ec9(%rip), %rax     # 0xd4830
movq (%rax), %rsi
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x6af57(%rip), %rdx     # 0xab8d0
callq 0x47150
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x40991
jmp 0x4099b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x409b5
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_dec_to_str
subtilis_exp_t *subtilis_builtin_ir_call_dec_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_integer;
	ptype[1] = &subtilis_type_integer;

	fn = prv_add_args(p, "_dec_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 {
		prv_builtins_ir_dec_to_str(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x6a051(%rip), %rax     # 0xab8d0
movq %rax, -0x40(%rbp)
leaq 0x6a046(%rip), %rax     # 0xab8d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq 0x6a9d2(%rip), %rsi     # 0xac273
movl $0x2, %edx
leaq 0x6a023(%rip), %r8      # 0xab8d0
callq 0x42960
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x418dd
movq -0x28(%rbp), %rax
cmpl $0x20, (%rax)
je 0x418d2
movq $0x0, -0x8(%rbp)
jmp 0x41941
movq -0x28(%rbp), %rdi
callq 0x15670
jmp 0x41903
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x43050
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x41901
movq $0x0, -0x8(%rbp)
jmp 0x41941
jmp 0x41903
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
leaq 0x6a959(%rip), %rsi     # 0xac273
xorl %r9d, %r9d
leaq 0x69fac(%rip), %r10     # 0xab8d0
movl %r9d, %r8d
movq %r10, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x248d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movl %r8d, %eax
movq %rcx, -0x98(%rbp)
movq %rdx, %rcx
movq -0x98(%rbp), %rdx
movq %rcx, -0x90(%rbp)
movq %rsi, %r8
movq -0x90(%rbp), %rsi
movq 0x20(%rbp), %rcx
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %rcx
movq %r8, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
andb $0x1, %al
movb %al, -0x59(%rbp)
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x39940
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rdi
movb -0x59(%rbp), %r8b
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %rax
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r9
movq -0x68(%rbp), %r15
movq -0x70(%rbp), %r14
movq -0x50(%rbp), %rbx
leaq -0x88(%rbp), %r12
leaq -0x78(%rbp), %r10
andb $0x1, %r8b
movzbl %r8b, %r8d
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x45a60
movq %rax, -0x80(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x41eaf
movq $-0x1, -0x28(%rbp)
jmp 0x41f01
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rdi
movq 0x20(%rbp), %r9
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
movl $0x44, %esi
callq 0x38360
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x41ee4
movq $-0x1, -0x28(%rbp)
jmp 0x41f01
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x70(%rbp), %rsi
movq 0x20(%rbp), %rdx
callq 0x39960
movq -0x80(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: prv_builtins_ir_gen_ref_grow
static void prv_builtins_ir_gen_ref_grow(subtilis_parser_t *p,
					 subtilis_ir_section_t *current,
					 subtilis_error_t *err)
{
	subtilis_ir_section_t *old_current;
	size_t a1_mem_reg;
	size_t a1_size_reg;
	size_t gran_reg;
	size_t a2_size_reg;
	subtilis_ir_operand_t ret_val;
	subtilis_ir_operand_t end_label;

	old_current = p->current;
	p->current = current;

	end_label.label = current->end_label;
	a1_mem_reg = SUBTILIS_IR_REG_TEMP_START;
	a1_size_reg = SUBTILIS_IR_REG_TEMP_START + 1;
	gran_reg = SUBTILIS_IR_REG_TEMP_START + 2;
	a2_size_reg = SUBTILIS_IR_REG_TEMP_START + 3;
	ret_val.reg = current->ret_reg;

	subtilis_reference_type_grow(p, 0, a1_mem_reg, a1_size_reg, gran_reg,
				     a2_size_reg, ret_val.reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_label(current, end_label.label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_ir_section_add_instr_no_reg(
	    p->current, SUBTILIS_OP_INSTR_RET_I32, ret_val, err);

cleanup:
	p->current = old_current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x50(%rbp)
movq $0x4, -0x28(%rbp)
movq $0x5, -0x30(%rbp)
movq $0x6, -0x38(%rbp)
movq $0x7, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r10
movq -0x18(%rbp), %rax
xorl %esi, %esi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x6ed60
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x42f61
jmp 0x42f97
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39960
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x42f7d
jmp 0x42f97
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rdx
movl $0x47, %esi
callq 0x38540
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_hex_to_str
subtilis_exp_t *subtilis_builtin_ir_call_hex_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_integer;
	ptype[1] = &subtilis_type_integer;

	fn = prv_add_args(p, "_hex_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 {
		prv_builtins_ir_hex_to_str(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x680a1(%rip), %rax     # 0xab8d0
movq %rax, -0x40(%rbp)
leaq 0x68096(%rip), %rax     # 0xab8d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq 0x68a2e(%rip), %rsi     # 0xac27f
movl $0x2, %edx
leaq 0x68073(%rip), %r8      # 0xab8d0
callq 0x42960
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4388d
movq -0x28(%rbp), %rax
cmpl $0x20, (%rax)
je 0x43882
movq $0x0, -0x8(%rbp)
jmp 0x438f1
movq -0x28(%rbp), %rdi
callq 0x15670
jmp 0x438b3
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x43900
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x438b1
movq $0x0, -0x8(%rbp)
jmp 0x438f1
jmp 0x438b3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
leaq 0x689b5(%rip), %rsi     # 0xac27f
xorl %r9d, %r9d
leaq 0x67ffc(%rip), %r10     # 0xab8d0
movl %r9d, %r8d
movq %r10, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x248d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x678e9(%rip), %rax     # 0xab788
movq %rax, -0x40(%rbp)
leaq 0x67a26(%rip), %rax     # 0xab8d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq 0x683ca(%rip), %rsi     # 0xac28b
movl $0x2, %edx
leaq 0x67a03(%rip), %r8      # 0xab8d0
callq 0x42960
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x43efd
movq -0x28(%rbp), %rax
cmpl $0x20, (%rax)
je 0x43ef2
movq $0x0, -0x8(%rbp)
jmp 0x43f64
movq -0x28(%rbp), %rdi
callq 0x15670
jmp 0x43f23
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x40f80
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x43f21
movq $0x0, -0x8(%rbp)
jmp 0x43f64
jmp 0x43f23
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
leaq 0x68351(%rip), %rsi     # 0xac28b
movl $0x1, %r8d
xorl %r9d, %r9d
leaq 0x67986(%rip), %r10     # 0xab8d0
movq %r10, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x248d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x67945(%rip), %rax     # 0xab8d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r9
leaq 0x682f4(%rip), %rsi     # 0xac296
movl $0x1, %edx
leaq 0x677da(%rip), %r8      # 0xab788
callq 0x42960
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x43fde
movq -0x20(%rbp), %rax
cmpl $0x20, (%rax)
je 0x43fd3
movq $0x0, -0x8(%rbp)
jmp 0x4403b
movq -0x20(%rbp), %rdi
callq 0x15670
jmp 0x44004
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x41950
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x44002
movq $0x0, -0x8(%rbp)
jmp 0x4403b
jmp 0x44004
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
leaq 0x6827f(%rip), %rsi     # 0xac296
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x67762(%rip), %r9      # 0xab788
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/builtins_ir.c
// Function: subtilis_builtin_ir_call_hexstr_to_int32
subtilis_exp_t *subtilis_builtin_ir_call_hexstr_to_int32(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, "_hexstr_to_int32", 1, 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 {
		prv_builtins_ir_hexstr_to_int32(p, fn, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	}

	return subtilis_parser_call_1_arg_fn(
	    p, "_hexstr_to_int32", str_reg, SUBTILIS_BUILTINS_MAX,
	    SUBTILIS_IR_REG_TYPE_INTEGER, &subtilis_type_integer, true, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x67865(%rip), %rax     # 0xab8d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r9
leaq 0x6821f(%rip), %rsi     # 0xac2a1
movl $0x1, %edx
leaq 0x67842(%rip), %r8      # 0xab8d0
callq 0x42960
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x440be
movq -0x20(%rbp), %rax
cmpl $0x20, (%rax)
je 0x440b3
movq $0x0, -0x8(%rbp)
jmp 0x4411b
movq -0x20(%rbp), %rdi
callq 0x15670
jmp 0x440e4
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x44130
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x440e2
movq $0x0, -0x8(%rbp)
jmp 0x4411b
jmp 0x440e4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
leaq 0x681aa(%rip), %rsi     # 0xac2a1
movl $0x9, %ecx
xorl %r8d, %r8d
leaq 0x677ca(%rip), %r9      # 0xab8d0
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x24790
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)