LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type.c
// Function: prv_init_fields
static void prv_init_fields(subtilis_parser_t *p, const subtilis_type_t *type,
			    size_t mem_reg, size_t loc, subtilis_error_t *err)
{
	size_t i;
	const subtilis_type_rec_t *rec;
	const subtilis_type_t *field;
	uint32_t offset;

	rec = &type->params.rec;
	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		offset = subtilis_type_rec_field_offset_id(rec, i);
		subtilis_rec_type_init_field(p, field, &rec->fields[i], mem_reg,
					     offset + loc, false, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// 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 -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x63219
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x148, -0x30(%rbp), %rcx # imm = 0x148
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3efb0
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
imulq $0x18, -0x30(%rbp), %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movl -0x44(%rbp), %eax
movl %eax, %r8d
addq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x61fd0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x63206
jmp 0x63219
jmp 0x63208
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x63190
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type_if.c
// Function: prv_array_of
static void prv_array_of(const subtilis_type_t *el_type, subtilis_type_t *type,
			 subtilis_error_t *err)
{
	subtilis_type_free(type);
	type->type = SUBTILIS_TYPE_ARRAY_REC;
	subtilis_type_init_to_from_rec(&type->params.array.params.rec, el_type,
				       err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e100
movq -0x10(%rbp), %rax
movl $0xf, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3eb60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/rec_type_if.c
// Function: prv_destructor
static size_t prv_destructor(subtilis_parser_t *p, const subtilis_type_t *type,
			     subtilis_error_t *err)
{
	size_t call_index = SIZE_MAX;

	if (!subtilis_type_rec_need_deref(type))
		return SIZE_MAX;

	call_index = subtilis_builtin_ir_rec_deref(p, type, err);

	return call_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x638a3
movq $-0x1, -0x8(%rbp)
jmp 0x638c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x452b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -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/string_type_if.c
// Function: prv_exp_to_var_const
static subtilis_exp_t *prv_exp_to_var_const(subtilis_parser_t *p,
					    subtilis_exp_t *e,
					    subtilis_error_t *err)
{
	size_t reg;
	const subtilis_symbol_t *s;
	subtilis_type_t type;

	subtilis_string_init_type(p, &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto free_e;

	s = subtilis_symbol_table_insert_tmp(p->local_st, &type, NULL, err);
	subtilis_type_free(&type);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_string_type_new_ref(p, &e->type, SUBTILIS_IR_REG_LOCAL, s->loc,
				     e, err);
	e = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	reg = subtilis_reference_get_pointer(p, SUBTILIS_IR_REG_LOCAL, s->loc,
					     err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_exp_new_var(&s->t, reg, err);

cleanup:
	subtilis_type_free(&type);

free_e:

	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x178(%rbp), %rsi
callq 0x65d60
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x63949
jmp 0x63a10
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rcx
leaq -0x178(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3c920
movq %rax, -0x30(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x3e100
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x63983
jmp 0x63a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0x2, %edx
callq 0x66f90
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x639b7
jmp 0x63a04
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x2, %esi
callq 0x6d920
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x639e7
movq $0x0, -0x8(%rbp)
jmp 0x63a21
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x37590
movq %rax, -0x8(%rbp)
jmp 0x63a21
leaq -0x178(%rbp), %rdi
callq 0x3e100
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_dup_const
static void prv_dup_const(subtilis_exp_t *e1, subtilis_exp_t *e2,
			  subtilis_error_t *err)
{
	subtilis_buffer_init(&e2->exp.str, e1->exp.str.granularity);
	subtilis_buffer_append(&e2->exp.str,
			       subtilis_buffer_get_string(&e1->exp.str),
			       subtilis_buffer_get_size(&e1->exp.str), 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
addq $0x148, %rdi            # imm = 0x148
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rsi
callq 0x15f80
movq -0x10(%rbp), %rax
addq $0x148, %rax            # imm = 0x148
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16760
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16270
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x16200
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_coerce_type_const
static subtilis_exp_t *prv_coerce_type_const(subtilis_parser_t *p,
					     subtilis_exp_t *e,
					     const subtilis_type_t *type,
					     subtilis_error_t *err)
{
	if (type->type != SUBTILIS_TYPE_STRING) {
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return prv_exp_to_var_const(p, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
je 0x63b90
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e190
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x45, %esi
leaq 0x48ed1(%rip), %rax     # 0xaca3d
movq %rax, (%rsp)
movl $0x4f, 0x8(%rsp)
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x63ba5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x63910
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_add_const
static subtilis_exp_t *prv_add_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, bool swapped,
				     subtilis_error_t *err)
{
	size_t len;

	len = subtilis_buffer_get_size(&a2->exp.str);
	subtilis_buffer_remove_terminator(&a1->exp.str);
	subtilis_buffer_append(&a1->exp.str, a2->exp.str.buffer->data, len,
			       err);
	subtilis_exp_delete(a2);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16270
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x165d0
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq -0x20(%rbp), %rax
movq 0x150(%rax), %rsi
addq $0x18, %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x16200
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x63c3f
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x63c47
movq -0x18(%rbp), %rax
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/string_type_if.c
// Function: prv_eq_const
static subtilis_exp_t *prv_eq_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				    subtilis_exp_t *a2, subtilis_error_t *err)
{
	int32_t res;

	/* a2 must be const */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_STRING:
		res = strcmp(subtilis_buffer_get_string(&a1->exp.str),
			     subtilis_buffer_get_string(&a2->exp.str)) == 0
			  ? -1
			  : 0;
		subtilis_buffer_free(&a1->exp.str);
		a1->exp.ir_op.integer = res;
		a1->type.type = SUBTILIS_TYPE_CONST_INTEGER;
		break;
	default:
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		return NULL;
	}

	subtilis_exp_delete(a2);
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
subl $0x3, %eax
jne 0x63cf0
jmp 0x63c85
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16760
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16760
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x12140
movl %eax, %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16650
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x148(%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x63d3c
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x19, %esi
leaq 0x48d16(%rip), %r8      # 0xaca3d
movl $0x8f, %r9d
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x63d4d
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_gt_const
static subtilis_exp_t *prv_gt_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				    subtilis_exp_t *a2, bool swapped,
				    subtilis_error_t *err)
{
	int res;

	/* a2 must be const */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_STRING:
		res = strcmp(subtilis_buffer_get_string(&a1->exp.str),
			     subtilis_buffer_get_string(&a2->exp.str)) > 0
			  ? -1
			  : 0;
		subtilis_buffer_free(&a1->exp.str);
		a1->exp.ir_op.integer = res;
		a1->type.type = SUBTILIS_TYPE_CONST_INTEGER;
		break;
	default:
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		return NULL;
	}

	subtilis_exp_delete(a2);
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
subl $0x3, %eax
jne 0x63ef7
jmp 0x63e8c
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16760
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16760
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x12140
movl %eax, %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovgl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16650
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x148(%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x63f43
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x19, %esi
leaq 0x48b0f(%rip), %r8      # 0xaca3d
movl $0xca, %r9d
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x63f54
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_append
static void prv_append(subtilis_parser_t *p, subtilis_exp_t *a1,
		       subtilis_exp_t *a2, subtilis_exp_t *gran,
		       subtilis_error_t *err)
{
	if (gran) {
		subtilis_error_set_too_many_args(err, 3, 2, p->l->stream->name,
						 p->l->line);
		subtilis_exp_delete(gran);
		subtilis_exp_delete(a2);
		subtilis_exp_delete(a1);
		return;
	}
	subtilis_string_type_add_eq(p, a1->exp.ir_op.reg, 0, a2, err);
	subtilis_exp_delete(a1);
}

// 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)
cmpq $0x0, -0x20(%rbp)
je 0x64541
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x29, %esi
movl $0x3, %edx
movl $0x2, %ecx
leaq 0x4852a(%rip), %rax     # 0xaca3d
movq %rax, (%rsp)
movl $0x1c9, 0x8(%rsp)       # imm = 0x1C9
callq 0x157b0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
callq 0x36ee0
jmp 0x6456a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x6b320
movq -0x10(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_load_from_mem
static subtilis_exp_t *prv_load_from_mem(subtilis_parser_t *p,
					 const subtilis_type_t *type,
					 size_t mem_reg, size_t loc,
					 subtilis_error_t *err)
{
	size_t reg;

	if (loc > 0) {
		reg = subtilis_reference_get_pointer(p, mem_reg, loc, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
	} else {
		reg = mem_reg;
	}

	return subtilis_exp_new_var(&subtilis_type_string, reg, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x645c1
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x6d920
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x645bf
movq $0x0, -0x8(%rbp)
jmp 0x645e3
jmp 0x645c9
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %esi
movq -0x30(%rbp), %rdx
leaq 0x47586(%rip), %rdi     # 0xabb60
callq 0x37590
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_eq
static subtilis_exp_t *prv_eq(subtilis_parser_t *p, subtilis_exp_t *a1,
			      subtilis_exp_t *a2, subtilis_error_t *err)
{
	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_STRING:
		return prv_eq_non_const_const(p, a1, a2, err);
	case SUBTILIS_TYPE_STRING:
		return prv_eq_non_const_non_const(p, a1, a2, err);
	default:
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
	}

	subtilis_exp_delete(a1);
	subtilis_exp_delete(a2);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x3, %eax
je 0x64622
jmp 0x64618
movl -0x2c(%rbp), %eax
subl $0x7, %eax
je 0x6463d
jmp 0x64658
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x64a20
movq %rax, -0x8(%rbp)
jmp 0x646a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x64d40
movq %rax, -0x8(%rbp)
jmp 0x646a2
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x19, %esi
leaq 0x483c0(%rip), %r8      # 0xaca3d
movl $0x2f3, %r9d            # imm = 0x2F3
callq 0x15930
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_neq
static subtilis_exp_t *prv_neq(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_STRING:
		return prv_neq_non_const_const(p, a1, a2, err);
	case SUBTILIS_TYPE_STRING:
		return prv_neq_non_const_non_const(p, a1, a2, err);
	default:
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
	}

	subtilis_exp_delete(a1);
	subtilis_exp_delete(a2);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x3, %eax
je 0x646e2
jmp 0x646d8
movl -0x2c(%rbp), %eax
subl $0x7, %eax
je 0x646fd
jmp 0x64718
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x651d0
movq %rax, -0x8(%rbp)
jmp 0x64762
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x654f0
movq %rax, -0x8(%rbp)
jmp 0x64762
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x19, %esi
leaq 0x48300(%rip), %r8      # 0xaca3d
movl $0x3cc, %r9d            # imm = 0x3CC
callq 0x15930
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_compare_fixed_len
static subtilis_exp_t *prv_compare_fixed_len(subtilis_parser_t *p, size_t a1,
					     size_t a2,
					     subtilis_op_instr_type_t iload,
					     subtilis_op_instr_type_t icmp,
					     subtilis_error_t *err)
{
	subtilis_ir_operand_t a1_ptr;
	subtilis_ir_operand_t a2_ptr;
	subtilis_ir_operand_t offset;
	subtilis_ir_operand_t op0;

	offset.integer = 0;
	op0.reg = a1;
	a1_ptr.reg =
	    subtilis_ir_section_add_instr(p->current, iload, op0, offset, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	op0.reg = a2;
	a2_ptr.reg =
	    subtilis_ir_section_add_instr(p->current, iload, op0, offset, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	a1 = subtilis_ir_section_add_instr(p->current, icmp, a1_ptr, a2_ptr,
					   err);
	return subtilis_exp_new_var(&subtilis_type_integer, a1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %r8
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x38230
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65151
movq $0x0, -0x8(%rbp)
jmp 0x651c6
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %r8
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x38230
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6518c
movq $0x0, -0x8(%rbp)
jmp 0x651c6
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x38230
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %esi
movq -0x30(%rbp), %rdx
leaq 0x46713(%rip), %rdi     # 0xab8d0
callq 0x37590
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_compare
static subtilis_exp_t *prv_compare(subtilis_parser_t *p, subtilis_exp_t *a1,
				   subtilis_exp_t *a2, bool swapped,
				   subtilis_op_instr_type_t itype,
				   subtilis_error_t *err)
{
	subtilis_exp_t *zero;
	size_t res;

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_STRING:
		a1 = prv_compare_non_const_const(p, a1, a2, swapped, err);
		break;
	case SUBTILIS_TYPE_STRING:
		a1 = prv_compare_non_const_non_const(p, a1, a2, err);
		break;
	default:
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		subtilis_exp_delete(a1);
		subtilis_exp_delete(a2);
		return NULL;
	}
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	zero = subtilis_exp_new_int32(0, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	res = subtilis_ir_section_add_instr(p->current, itype, a1->exp.ir_op,
					    zero->exp.ir_op, err);
	subtilis_exp_delete(a1);
	subtilis_exp_delete(zero);

	return subtilis_exp_new_int32_var(res, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
subl $0x3, %eax
je 0x658dd
jmp 0x658d3
movl -0x44(%rbp), %eax
subl $0x7, %eax
je 0x65900
jmp 0x6591b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
movq -0x30(%rbp), %r8
andb $0x1, %al
movzbl %al, %ecx
callq 0x65a10
movq %rax, -0x18(%rbp)
jmp 0x6596a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x65bf0
movq %rax, -0x18(%rbp)
jmp 0x6596a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x19, %esi
leaq 0x470fd(%rip), %r8      # 0xaca3d
movl $0x454, %r9d            # imm = 0x454
callq 0x15930
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x659fb
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6597d
movq $0x0, -0x8(%rbp)
jmp 0x659fb
movq -0x30(%rbp), %rsi
xorl %edi, %edi
callq 0x37800
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x659a8
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x659fb
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x28(%rbp), %esi
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq -0x40(%rbp), %rax
movl %eax, %edi
movq -0x30(%rbp), %rsi
callq 0x37770
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type_if.c
// Function: prv_compare_non_const_non_const
static subtilis_exp_t *prv_compare_non_const_non_const(subtilis_parser_t *p,
						       subtilis_exp_t *a1,
						       subtilis_exp_t *a2,
						       subtilis_error_t *err)
{
	size_t a1_ptr;
	size_t a2_ptr;
	subtilis_exp_t *len1 = NULL;
	subtilis_exp_t *len2 = NULL;
	subtilis_exp_t *res = NULL;

	len1 = subtilis_type_if_dup(a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	len1 = subtilis_string_type_len(p, len1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	len2 = subtilis_type_if_dup(a2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	len2 = subtilis_string_type_len(p, len2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	a1_ptr = subtilis_reference_get_data(p, a1->exp.ir_op.reg, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	a2_ptr = subtilis_reference_get_data(p, a2->exp.ir_op.reg, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	res = subtilis_string_type_compare(p, a1_ptr, len1->exp.ir_op.reg,
					   a2_ptr, len2->exp.ir_op.reg, err);

cleanup:

	subtilis_exp_delete(len2);
	subtilis_exp_delete(len1);
	subtilis_exp_delete(a2);
	subtilis_exp_delete(a1);

	return res;
}

// 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 $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x47d20
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65c3f
jmp 0x65d29
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x67350
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65c62
jmp 0x65d29
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x47d20
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65c81
jmp 0x65d29
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x67350
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65ca4
jmp 0x65d29
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x6d1e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65ccf
jmp 0x65d29
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x6d1e0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65cfa
jmp 0x65d29
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rdx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq 0x148(%rax), %r8
movq -0x20(%rbp), %r9
callq 0x67ad0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x10(%rbp), %rdi
callq 0x36ee0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: subtilis_string_type_lca_const
size_t subtilis_string_type_lca_const(subtilis_parser_t *p, const char *str,
				      size_t len, subtilis_error_t *err)
{
	size_t id;
	subtilis_ir_operand_t op1;

	id = prv_add_string_constant(p, str, len, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;

	op1.integer = (int32_t)id;
	return subtilis_ir_section_add_instr2(p->current, SUBTILIS_OP_INSTR_LCA,
					      op1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x65e00
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65dc4
movq $0x0, -0x8(%rbp)
jmp 0x65de9
movq -0x30(%rbp), %rax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rdx
movl $0x7d, %esi
callq 0x38490
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/string_type.c
// Function: prv_add_string_constant
static size_t prv_add_string_constant(subtilis_parser_t *p, const char *str,
				      size_t len, subtilis_error_t *err)
{
	uint8_t *buf;
	size_t id;

	buf = malloc(len);
	if (!buf) {
		subtilis_error_set_oom(err);
		return SIZE_MAX;
	}
	memcpy(buf, str, len);

	id = subtilis_constant_pool_add(p->prog->constant_pool, buf, len, false,
					err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	return id;

cleanup:

	free(buf);
	return SIZE_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x121b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x65e50
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x46c1b(%rip), %rdx     # 0xaca57
movl $0x36, %ecx
callq 0x158e0
movq $-0x1, -0x8(%rbp)
jmp 0x65eaa
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12190
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
xorl %ecx, %ecx
callq 0x3d290
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65e8f
jmp 0x65e99
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x65eaa
movq -0x30(%rbp), %rdi
callq 0x12290
movq $-0x1, -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/string_type.c
// Function: subtilis_string_type_zero_ref
void subtilis_string_type_zero_ref(subtilis_parser_t *p,
				   const subtilis_type_t *type, size_t mem_reg,
				   size_t loc, bool push, subtilis_error_t *err)
{
	subtilis_exp_t *zero = NULL;

	zero = subtilis_exp_new_int32(0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	subtilis_reference_type_set_size(p, mem_reg, loc, zero->exp.ir_op.reg,
					 err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (push)
		subtilis_reference_type_push_reference(p, type, mem_reg, loc,
						       err);

cleanup:

	subtilis_exp_delete(zero);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rsi
xorl %edi, %edi
callq 0x37800
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65f26
jmp 0x65f9b
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x47c10
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65f46
jmp 0x65f92
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x30(%rbp), %r8
callq 0x6dc50
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x65f71
jmp 0x65f92
testb $0x1, -0x21(%rbp)
je 0x65f90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x6d540
jmp 0x65f92
movq -0x38(%rbp), %rdi
callq 0x36ee0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: subtilis_string_init_from_lca
void subtilis_string_init_from_lca(subtilis_parser_t *p, size_t mem_reg,
				   size_t loc, size_t lca_reg, size_t size_reg,
				   bool push, subtilis_error_t *err)

{
	size_t dest_reg;

	dest_reg = subtilis_reference_type_alloc(p, &subtilis_type_string, loc,
						 mem_reg, size_reg, push, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_reference_type_memcpy_dest(p, dest_reg, lca_reg, size_reg,
					    err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %r9b
movq 0x10(%rbp), %rax
leaq 0x459b9(%rip), %rsi     # 0xabb60
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x6e3e0
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x661c7
jmp 0x661e0
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x6dad0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: subtilis_string_type_new_tmp_from_char
subtilis_exp_t *subtilis_string_type_new_tmp_from_char(subtilis_parser_t *p,
						       subtilis_exp_t *e,
						       subtilis_error_t *err)
{
	subtilis_type_t type;
	const subtilis_symbol_t *s;
	size_t reg;
	char *tmp_name = NULL;

	subtilis_string_init_type(p, &type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	s = subtilis_symbol_table_insert_tmp(p->local_st, &type, &tmp_name,
					     err);
	subtilis_type_free(&type);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_string_type_new_ref_from_char(p, SUBTILIS_IR_REG_LOCAL, s->loc,
					       e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	return subtilis_exp_new_tmp_var(&s->t, reg, tmp_name, err);

cleanup:

	free(tmp_name);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x180(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x168(%rbp), %rsi
callq 0x65d60
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66234
jmp 0x662f7
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rcx
leaq -0x168(%rbp), %rsi
leaq -0x180(%rbp), %rdx
callq 0x3c920
movq %rax, -0x170(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x3e100
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66274
jmp 0x662f7
movq -0x10(%rbp), %rdi
movq -0x170(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x2, %esi
callq 0x66330
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6629f
jmp 0x662f7
movq -0x10(%rbp), %rdi
movq -0x170(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x2, %esi
callq 0x6d920
movq %rax, -0x178(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x662cd
jmp 0x662f7
movq -0x170(%rbp), %rdi
addq $0x8, %rdi
movq -0x178(%rbp), %rax
movl %eax, %esi
movq -0x180(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x375f0
movq %rax, -0x8(%rbp)
jmp 0x66314
movq -0x180(%rbp), %rdi
callq 0x12290
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: subtilis_string_type_new_ref_from_char
void subtilis_string_type_new_ref_from_char(subtilis_parser_t *p,
					    size_t mem_reg, size_t loc,
					    subtilis_exp_t *e,
					    subtilis_error_t *err)
{
	size_t dest_reg;
	subtilis_ir_operand_t dest_op;
	subtilis_ir_operand_t zero_op;
	subtilis_exp_t *sizee = NULL;

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

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

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

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

	dest_reg = subtilis_reference_type_alloc(p, &subtilis_type_string, loc,
						 mem_reg, sizee->exp.ir_op.reg,
						 true, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	dest_op.reg = dest_reg;
	zero_op.integer = 0;
	subtilis_ir_section_add_instr_reg(p->current,
					  SUBTILIS_OP_INSTR_STOREO_I8,
					  e->exp.ir_op, dest_op, zero_op, err);

cleanup:

	subtilis_exp_delete(sizee);
	subtilis_exp_delete(e);
}

// 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, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66377
jmp 0x66464
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6639a
jmp 0x66464
movq -0x28(%rbp), %rsi
movl $0x1, %edi
callq 0x37800
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x663ba
jmp 0x66452
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x663da
jmp 0x66452
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x48(%rbp), %rax
movq 0x148(%rax), %r8
movq -0x28(%rbp), %rax
leaq 0x45764(%rip), %rsi     # 0xabb60
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x6e3e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6641a
jmp 0x66452
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %r9
movq 0x148(%rax), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x16, %esi
callq 0x38360
movq -0x48(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: subtilis_string_lca_const_zt
subtilis_exp_t *subtilis_string_lca_const_zt(subtilis_parser_t *p,
					     subtilis_exp_t *e,
					     subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *ret_val = NULL;

	subtilis_buffer_zero_terminate(&e->exp.str, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	reg = subtilis_string_type_lca_const(
	    p, subtilis_buffer_get_string(&e->exp.str),
	    subtilis_buffer_get_size(&e->exp.str), err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	ret_val = subtilis_exp_new_int32_var(reg, err);

cleanup:

	subtilis_exp_delete(e);

	return ret_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq -0x18(%rbp), %rsi
callq 0x16560
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x664ab
jmp 0x6650d
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16760
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16270
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x65d80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x664fa
jmp 0x6650d
movq -0x20(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x37770
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: subtilis_string_zt_non_const
subtilis_exp_t *subtilis_string_zt_non_const(subtilis_parser_t *p,
					     subtilis_exp_t *e,
					     subtilis_error_t *err)
{
	if (e->type.type != SUBTILIS_TYPE_STRING) {
		subtilis_error_set_string_variable_expected(
		    err, p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	if (e->temporary)
		return prv_zt_non_const_tmp(p, e, err);

	/*
	 * We need to create a brand new temporary string and copy
	 * the contents of the old string appending a 0 to the end
	 */

	return prv_zt_non_const(p, e, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
je 0x66a10
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x4b, %esi
leaq 0x46065(%rip), %r8      # 0xaca57
movl $0x279, %r9d            # imm = 0x279
callq 0x15930
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x66a4a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x66a35
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66a60
movq %rax, -0x8(%rbp)
jmp 0x66a4a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66ca0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: prv_zt_non_const
static subtilis_exp_t *prv_zt_non_const(subtilis_parser_t *p, subtilis_exp_t *e,
					subtilis_error_t *err)
{
	subtilis_buffer_t buf;
	size_t reg;
	subtilis_exp_t *null_str = NULL;
	subtilis_exp_t *new_str = NULL;

	subtilis_buffer_init(&buf, 2);

	/*
	 * The string addition code will discard one of the null terminators
	 * so we need two.
	 */

	subtilis_buffer_append(&buf, "\0\0", 2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	null_str = subtilis_exp_new_str(&buf, err);
	subtilis_buffer_free(&buf);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	new_str = subtilis_string_type_add(p, e, null_str, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	reg = subtilis_reference_get_data(p, new_str->exp.ir_op.reg, 0, err);
	subtilis_exp_delete(new_str);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_exp_new_int32_var(reg, err);

cleanup:

	subtilis_exp_delete(null_str);
	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x15f80
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq 0x45d9e(%rip), %rsi     # 0xaca7f
movl $0x2, %edx
callq 0x16200
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66cf9
jmp 0x66d9d
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x37900
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x16650
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66d1e
jmp 0x66d9d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %r8
xorl %ecx, %ecx
callq 0x6ad80
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66d4c
movq $0x0, -0x8(%rbp)
jmp 0x66db7
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x6d1e0
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66d88
movq $0x0, -0x8(%rbp)
jmp 0x66db7
movq -0x38(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x37770
movq %rax, -0x8(%rbp)
jmp 0x66db7
movq -0x40(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/string_type.c
// Function: prv_init_string_from_const
static void prv_init_string_from_const(subtilis_parser_t *p, size_t mem_reg,
				       size_t loc, const subtilis_buffer_t *str,
				       bool push, subtilis_error_t *err)
{
	size_t id;
	size_t src_reg;
	subtilis_ir_operand_t op1;
	subtilis_exp_t *sizee = NULL;
	size_t buf_size = subtilis_buffer_get_size(str);

	if (buf_size == 1) {
		subtilis_string_type_zero_ref(p, &subtilis_type_string, mem_reg,
					      loc, push, err);
		return;
	}

	buf_size--;
	id = prv_add_string_constant(p, subtilis_buffer_get_string(str),
				     buf_size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	sizee = subtilis_exp_new_int32((int32_t)buf_size, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	op1.integer = (int32_t)id;
	src_reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_LCA, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_string_init_from_lca(p, mem_reg, loc, src_reg,
				      sizee->exp.ir_op.reg, push, err);
cleanup:

	subtilis_exp_delete(sizee);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x16270
movq %rax, -0x58(%rbp)
cmpq $0x1, -0x58(%rbp)
jne 0x66e8a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movb -0x21(%rbp), %al
movq -0x30(%rbp), %r9
leaq 0x44ce6(%rip), %rsi     # 0xabb60
andb $0x1, %al
movzbl %al, %r8d
callq 0x65ee0
jmp 0x66f7b
movq -0x58(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x16760
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x58(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x65e00
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66ecd
jmp 0x66f7b
movq -0x58(%rbp), %rax
movl %eax, %edi
movq -0x30(%rbp), %rsi
callq 0x37800
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66eee
jmp 0x66f7b
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x47c10
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66f0e
jmp 0x66f72
movq -0x38(%rbp), %rax
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rdx
movl $0x7d, %esi
callq 0x38490
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x66f3e
jmp 0x66f72
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x50(%rbp), %rax
movq 0x148(%rax), %r8
movb -0x21(%rbp), %r9b
movq -0x30(%rbp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x66160
movq -0x50(%rbp), %rdi
callq 0x36ee0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)