LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_abs
static subtilis_exp_t *prv_abs(subtilis_parser_t *p, subtilis_exp_t *e,
			       subtilis_error_t *err)
{
	size_t reg;
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;

	op2.integer = 31;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_ASRI_I32, e->exp.ir_op, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	op2.reg = reg;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_ADD_I32, e->exp.ir_op, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	op1.reg = reg;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_EOR_I32, op1, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	e->exp.ir_op.reg = reg;

	return e;

cleanup:

	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1f, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %r8
movq 0x148(%rax), %rdx
movq -0x38(%rbp), %rcx
movl $0x50, %esi
callq 0x38230
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50712
jmp 0x50799
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %r8
movq 0x148(%rax), %rdx
movq -0x38(%rbp), %rcx
xorl %esi, %esi
callq 0x38230
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5074b
jmp 0x50799
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %r8
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x28, %esi
callq 0x38230
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50780
jmp 0x50799
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x507aa
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -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/int32_type.c
// Function: prv_call
static subtilis_exp_t *prv_call(subtilis_parser_t *p,
				const subtilis_type_t *type,
				subtilis_ir_arg_t *args, size_t num_args,
				subtilis_error_t *err)
{
	size_t reg;

	reg = subtilis_ir_section_add_i32_call(p->current, num_args, args, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_exp_new_var(type, 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)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x39d80
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x509bc
movq $0x0, -0x8(%rbp)
jmp 0x509d3
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %esi
movq -0x30(%rbp), %rdx
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/int32_type.c
// Function: prv_call_ptr
static subtilis_exp_t *prv_call_ptr(subtilis_parser_t *p,
				    const subtilis_type_t *type,
				    subtilis_ir_arg_t *args, size_t num_args,
				    size_t ptr, subtilis_error_t *err)
{
	size_t reg;

	reg = subtilis_ir_section_add_i32_call_ptr(p->current, num_args, args,
						   ptr, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_exp_new_var(type, 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)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x39fa0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50a34
movq $0x0, -0x8(%rbp)
jmp 0x50a4b
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %esi
movq -0x38(%rbp), %rdx
callq 0x37590
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/int32_type.c
// Function: prv_print
static void prv_print(subtilis_parser_t *p, subtilis_exp_t *e,
		      subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	subtilis_exp_t *sizee;
	size_t ptr;
	size_t size_reg;
	subtilis_ir_operand_t op0;
	subtilis_ir_operand_t op1;

	s = subtilis_symbol_table_create_named_local_buf(
	    p->local_st, "32_int_print_buf", 16, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	op0.reg = ptr;
	if (p->backend.caps & SUBTILIS_BACKEND_HAVE_I32_TO_DEC) {
		size_reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_I32TODEC, e->exp.ir_op, op0,
		    err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	} else {
		sizee = subtilis_builtin_ir_call_dec_to_str(p, e->exp.ir_op.reg,
							    op0.reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		size_reg = sizee->exp.ir_op.reg;
		subtilis_exp_delete(sizee);
	}

	op1.reg = size_reg;
	subtilis_ir_section_add_instr_no_reg2(
	    p->current, SUBTILIS_OP_INSTR_PRINT_STR, op0, op1, err);

cleanup:

	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 -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rcx
leaq 0x5b9f4(%rip), %rsi     # 0xac4bb
movl $0x10, %edx
callq 0x3c890
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50ae3
jmp 0x50bc4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x2, %esi
callq 0x6d920
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50b0e
jmp 0x50bc4
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50b5b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %r8
movq 0x148(%rax), %rdx
movq -0x40(%rbp), %rcx
movl $0x84, %esi
callq 0x38230
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50b59
jmp 0x50bc4
jmp 0x50b9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x41860
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50b86
jmp 0x50bc4
movq -0x28(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x1f, %esi
callq 0x385a0
movq -0x10(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_swap_reg_mem
static void prv_swap_reg_mem(subtilis_parser_t *p, const subtilis_type_t *type,
			     size_t reg1, size_t reg2, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;
	subtilis_ir_operand_t zero;
	subtilis_ir_operand_t tmp;

	op1.reg = reg1;
	op2.reg = reg2;
	zero.integer = 0;

	tmp.reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOV, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I32, op1, op2, zero, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_I32, tmp, op2, zero, 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 -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movl $0x1d, %esi
callq 0x38490
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50cec
jmp 0x50d3b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x12, %esi
callq 0x38360
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50d19
jmp 0x50d3b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %r9
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x17, %esi
callq 0x38360
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_div_mod_const_var
static void prv_div_mod_const_var(subtilis_parser_t *p, subtilis_exp_t *a1,
				  subtilis_exp_t *a2,
				  subtilis_op_instr_type_t type,
				  subtilis_error_t *err)
{
	a1->type.type = SUBTILIS_TYPE_INTEGER;
	a1->exp.ir_op.reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, a1->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	a1->exp.ir_op.reg =
	    prv_div_mod_vars(p, a1->exp.ir_op, a2->exp.ir_op, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50def
jmp 0x50e2e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq 0x148(%rdx), %rsi
movq 0x148(%rax), %rdx
callq 0x50e40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x50e2e
jmp 0x50e2e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_shift_const_var
static void prv_shift_const_var(subtilis_parser_t *p, subtilis_exp_t *a1,
				subtilis_exp_t *a2,
				subtilis_op_instr_type_t op_type,
				subtilis_error_t *err)
{
	subtilis_ir_operand_t op;
	size_t reg;

	op.reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, a1->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	reg = subtilis_ir_section_add_instr(p->current, op_type, op,
					    a2->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	a1->exp.ir_op.reg = reg;
	a1->type.type = SUBTILIS_TYPE_INTEGER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5116b
jmp 0x511b6
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5119d
jmp 0x511b6
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_commutative_const_real
static void prv_commutative_const_real(subtilis_parser_t *p, subtilis_exp_t *a1,
				       subtilis_exp_t *a2,
				       subtilis_op_instr_type_t real_var_imm,
				       const subtilis_type_t *result_type,
				       subtilis_error_t *err)
{
	size_t reg;

	reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOV_I32_FP, a1->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_type_copy(&a1->type, result_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	a1->exp.ir_op.reg = reg;
	reg = subtilis_ir_section_add_instr(p->current, real_var_imm,
					    a1->exp.ir_op, a2->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	a1->exp.ir_op.reg = reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x51, %esi
callq 0x38490
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x515ef
jmp 0x51662
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3e4f0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5160b
jmp 0x51662
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x51653
jmp 0x51662
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_commutative_real
static void prv_commutative_real(subtilis_parser_t *p, subtilis_exp_t *a1,
				 subtilis_exp_t *a2,
				 subtilis_op_instr_type_t real_var_var,
				 const subtilis_type_t *result_type,
				 subtilis_error_t *err)
{
	size_t reg;

	reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOV_I32_FP, a1->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_type_copy(&a1->type, result_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	a1->exp.ir_op.reg = reg;
	reg = subtilis_ir_section_add_instr(p->current, real_var_var,
					    a1->exp.ir_op, a2->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	a1->exp.ir_op.reg = reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x51, %esi
callq 0x38490
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x516bf
jmp 0x51732
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3e4f0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x516db
jmp 0x51732
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x51723
jmp 0x51732
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_div_by_constant
static size_t prv_div_by_constant(subtilis_parser_t *p, subtilis_ir_operand_t a,
				  subtilis_ir_operand_t b,
				  subtilis_error_t *err)
{
	bool can_optimise;
	subtilis_op_instr_type_t instr;
	size_t reg;
	size_t res = 0;

	if (b.integer == 0) {
		subtilis_error_set_divide_by_zero(err, p->l->stream->name,
						  p->l->line);
		return 0;
	}

	can_optimise = prv_optimise_div(p, a, b, &res, err);
	if ((err->type != SUBTILIS_ERROR_OK) || can_optimise)
		return res;

	if (p->backend.caps & SUBTILIS_BACKEND_HAVE_DIV) {
		instr = SUBTILIS_OP_INSTR_DIVI_I32;
		return subtilis_ir_section_add_instr(p->current, instr, a, b,
						     err);
	}

	reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, b, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;

	b.reg = reg;

	return prv_div_mod_vars(p, a, b, SUBTILIS_OP_INSTR_DIV_I32, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x51983
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x1a, %esi
leaq 0x5ab3a(%rip), %r8      # 0xac4a5
movl $0x65d, %r9d            # imm = 0x65D
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x51a4c
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x51a60
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x519b0
testb $0x1, -0x29(%rbp)
je 0x519bd
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51a4c
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x519f5
movl $0xf, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x30(%rbp), %esi
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x38230
movq %rax, -0x8(%rbp)
jmp 0x51a4c
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x51a26
movq $0x0, -0x8(%rbp)
jmp 0x51a4c
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x6, %ecx
callq 0x50e40
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/int32_type.c
// Function: prv_mod_by_constant
static size_t prv_mod_by_constant(subtilis_parser_t *p, subtilis_ir_operand_t a,
				  subtilis_ir_operand_t b,
				  subtilis_error_t *err)
{
	bool can_optimise;
	size_t reg;
	size_t res = 0;

	if (b.integer == 0) {
		subtilis_error_set_divide_by_zero(err, p->l->stream->name,
						  p->l->line);
		return 0;
	}

	can_optimise = prv_optimise_mod(p, a, b, &res, err);
	if ((err->type != SUBTILIS_ERROR_OK) || can_optimise)
		return res;

	reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, b, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;

	b.reg = reg;

	return prv_div_mod_vars(p, a, b, SUBTILIS_OP_INSTR_MOD_I32, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x51c83
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x1a, %esi
leaq 0x5a83a(%rip), %r8      # 0xac4a5
movl $0x6d9, %r9d            # imm = 0x6D9
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x51d11
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x51d20
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x51cb0
testb $0x1, -0x29(%rbp)
je 0x51cba
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51d11
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x51ceb
movq $0x0, -0x8(%rbp)
jmp 0x51d11
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x7, %ecx
callq 0x50e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_shift
static subtilis_exp_t *prv_shift(subtilis_parser_t *p, subtilis_exp_t *a1,
				 subtilis_exp_t *a2,
				 subtilis_op_instr_type_t op_type,
				 subtilis_op_instr_type_t opi_type,
				 subtilis_error_t *err)
{
	size_t reg;

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		reg = subtilis_ir_section_add_instr(
		    p->current, opi_type, a1->exp.ir_op, a2->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		a1->exp.ir_op.reg = reg;
		break;
	case SUBTILIS_TYPE_BYTE:
		a2->type.type = SUBTILIS_TYPE_INTEGER;
	case SUBTILIS_TYPE_INTEGER:
		reg = subtilis_ir_section_add_instr(
		    p->current, op_type, a1->exp.ir_op, a2->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		a1->exp.ir_op.reg = reg;
		break;
	default:
		subtilis_error_set_assertion_failed(err);
		goto on_error;
	}

	subtilis_exp_delete(a2);
	return a1;

on_error:
	subtilis_exp_delete(a1);
	subtilis_exp_delete(a2);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x51f16
jmp 0x51eff
movl -0x3c(%rbp), %eax
subl $0x5, %eax
je 0x51f6d
jmp 0x51f09
movl -0x3c(%rbp), %eax
subl $0x6, %eax
je 0x51f63
jmp 0x51fb7
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x28(%rbp), %esi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x51f52
jmp 0x51fe6
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
jmp 0x51fd3
movq -0x20(%rbp), %rax
movl $0x5, (%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x51fa6
jmp 0x51fe6
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
jmp 0x51fd3
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x5a4de(%rip), %rdx     # 0xac4a5
movl $0x7c0, %ecx            # imm = 0x7C0
callq 0x158e0
jmp 0x51fe6
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x52000
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -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/byte_type_if.c
// Function: prv_zero
static subtilis_exp_t *prv_zero(subtilis_parser_t *p,
				const subtilis_type_t *type,
				subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	size_t reg_num;

	op1.integer = 0;
	reg_num = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	return subtilis_exp_new_byte_var(reg_num, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5206c
movq $0x0, -0x8(%rbp)
jmp 0x5207f
movq -0x30(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x377a0
movq %rax, -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/byte_type_if.c
// Function: prv_top_bit
static subtilis_exp_t *prv_top_bit(subtilis_parser_t *p, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	size_t reg_num;

	op1.integer = (int32_t)0x80;
	reg_num = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	return subtilis_exp_new_byte_var(reg_num, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x80, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movl $0x1b, %esi
callq 0x38490
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x520d8
movq $0x0, -0x8(%rbp)
jmp 0x520eb
movq -0x28(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x377a0
movq %rax, -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/byte_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)
{
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;
	size_t reg;

	op1.reg = mem_reg;
	op2.integer = (int32_t)loc;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I8, op1, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_exp_new_byte_var(reg, 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 %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl $0x11, %esi
callq 0x38230
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x523c0
movq $0x0, -0x8(%rbp)
jmp 0x523d3
movq -0x48(%rbp), %rax
movl %eax, %edi
movq -0x30(%rbp), %rsi
callq 0x377a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_to_int32
static subtilis_exp_t *prv_to_int32(subtilis_parser_t *p, subtilis_exp_t *e,
				    subtilis_error_t *err)
{
	size_t reg;

	reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_SIGNX_8_TO_32, e->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	e->type.type = SUBTILIS_TYPE_INTEGER;
	e->exp.ir_op.reg = reg;
	return e;

on_error:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x97, %esi
callq 0x38490
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52424
jmp 0x52447
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x52458
movq -0x18(%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/byte_type_if.c
// Function: prv_zerox_from_type
static subtilis_exp_t *prv_zerox_from_type(subtilis_parser_t *p,
					   subtilis_exp_t *e,
					   const subtilis_type_t *type,
					   subtilis_error_t *err)
{
	if (type->type != SUBTILIS_TYPE_INTEGER) {
		subtilis_error_set_bad_zero_extend(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return prv_zerox(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 $0x5, (%rax)
je 0x52500
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 $0x46, %esi
leaq 0x59ff0(%rip), %rax     # 0xac4cc
movq %rax, (%rsp)
movl $0x100, 0x8(%rsp)       # imm = 0x100
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x52515
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x53450
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/byte_type_if.c
// Function: prv_to_float64
static subtilis_exp_t *prv_to_float64(subtilis_parser_t *p, subtilis_exp_t *e,
				      subtilis_error_t *err)
{
	size_t reg;

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

	reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOV_I32_FP, e->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	e->type.type = SUBTILIS_TYPE_REAL;
	e->exp.ir_op.reg = reg;

	return e;

on_error:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5257c
movq $0x0, -0x8(%rbp)
jmp 0x525e0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x148(%rax), %rdx
movl $0x51, %esi
callq 0x38490
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x525ac
jmp 0x525cf
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x525e0
movq -0x18(%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/byte_type_if.c
// Function: prv_to_string
static subtilis_exp_t *prv_to_string(subtilis_parser_t *p, subtilis_exp_t *e,
				     subtilis_error_t *err)
{
	e = prv_to_int32(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	return subtilis_type_if_to_string(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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5262c
movq $0x0, -0x8(%rbp)
jmp 0x52641
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x48c10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_to_hex_string
static subtilis_exp_t *prv_to_hex_string(subtilis_parser_t *p,
					 subtilis_exp_t *e,
					 subtilis_error_t *err)
{
	e = prv_zerox(p, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	return subtilis_type_if_to_hex_string(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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x53450
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5268c
movq $0x0, -0x8(%rbp)
jmp 0x526a1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x48cf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_coerce_type
static subtilis_exp_t *prv_coerce_type(subtilis_parser_t *p, subtilis_exp_t *e,
				       const subtilis_type_t *type,
				       subtilis_error_t *err)
{
	switch (type->type) {
	case SUBTILIS_TYPE_REAL:
		e = prv_to_float64(p, e, err);
		break;
	case SUBTILIS_TYPE_BYTE:
		break;
	case SUBTILIS_TYPE_INTEGER:
		e = prv_to_int32(p, e, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
		break;
	default:
		subtilis_error_set_bad_conversion(
		    err, subtilis_type_name(&e->type), subtilis_type_name(type),
		    p->l->stream->name, p->l->line);
		subtilis_exp_delete(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %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
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x4, %eax
je 0x526ec
jmp 0x526d8
movl -0x2c(%rbp), %eax
subl $0x5, %eax
je 0x5270b
jmp 0x526e2
movl -0x2c(%rbp), %eax
subl $0x6, %eax
je 0x52706
jmp 0x52735
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x52540
movq %rax, -0x18(%rbp)
jmp 0x527a4
jmp 0x527a4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52733
movq $0x0, -0x8(%rbp)
jmp 0x527ac
jmp 0x527a4
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e190
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e190
movq -0x40(%rbp), %rdi
movq -0x38(%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 0x59d4c(%rip), %rax     # 0xac4cc
movq %rax, (%rsp)
movl $0x179, 0x8(%rsp)       # imm = 0x179
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x527ac
movq -0x18(%rbp), %rax
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/byte_type_if.c
// Function: prv_div
static subtilis_exp_t *prv_div(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	return subtilis_type_int32.div(p, a1, a2, err);

on_error:

	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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52bb8
jmp 0x52bde
leaq 0x82419(%rip), %rax     # 0xd4fd8
movq 0x190(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x52bef
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/byte_type_if.c
// Function: prv_mod
static subtilis_exp_t *prv_mod(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	return subtilis_type_int32.mod(p, a1, a2, err);

on_error:

	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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52c38
jmp 0x52c5e
leaq 0x82399(%rip), %rax     # 0xd4fd8
movq 0x198(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x52c6f
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/byte_type_if.c
// Function: prv_lsl
static subtilis_exp_t *prv_lsl(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1->type.type = SUBTILIS_TYPE_INTEGER;
	a1 = subtilis_type_int32.lsl(p, a1, a2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	a1->type.type = SUBTILIS_TYPE_BYTE;
	return a1;
}

// 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 -0x18(%rbp), %rax
movl $0x5, (%rax)
leaq 0x8214f(%rip), %rax     # 0xd4fd8
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52eb9
movq $0x0, -0x8(%rbp)
jmp 0x52ecb
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -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/byte_type_if.c
// Function: prv_lsr
static subtilis_exp_t *prv_lsr(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a1->type.type = SUBTILIS_TYPE_INTEGER;
	a1 = subtilis_type_int32.lsr(p, a1, a2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	a1->type.type = SUBTILIS_TYPE_BYTE;
	return a1;
}

// 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 -0x18(%rbp), %rax
movl $0x5, (%rax)
leaq 0x820cf(%rip), %rax     # 0xd4fd8
movq 0x1d8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52f39
movq $0x0, -0x8(%rbp)
jmp 0x52f4b
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -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/byte_type_if.c
// Function: prv_asr
static subtilis_exp_t *prv_asr(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	/*
	 * This one needs to be sign extended.
	 */

	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a2);
		return NULL;
	}
	a1 = subtilis_type_int32.asr(p, a1, a2, err);
	a1->type.type = SUBTILIS_TYPE_BYTE;
	return a1;
}

// 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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52fa9
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x52fdf
leaq 0x82028(%rip), %rax     # 0xd4fd8
movq 0x1e0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -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/byte_type_if.c
// Function: prv_abs
static subtilis_exp_t *prv_abs(subtilis_parser_t *p, subtilis_exp_t *e,
			       subtilis_error_t *err)
{
	/*
	 * This one needs to be sign extended.
	 */

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

	e = (subtilis_type_int32.abs)(p, e, err);
	e->type.type = SUBTILIS_TYPE_BYTE;
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5302c
movq $0x0, -0x8(%rbp)
jmp 0x5305e
leaq 0x81fa5(%rip), %rax     # 0xd4fd8
movq 0x1e8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_sgn
static subtilis_exp_t *prv_sgn(subtilis_parser_t *p, subtilis_exp_t *e,
			       subtilis_error_t *err)
{
	/*
	 * This one needs to be sign extended.
	 */

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

	return subtilis_type_int32.sgn(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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x530ac
movq $0x0, -0x8(%rbp)
jmp 0x530cc
leaq 0x81f25(%rip), %rax     # 0xd4fd8
movq 0x1f0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
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/byte_type_if.c
// Function: prv_print
static void prv_print(subtilis_parser_t *p, subtilis_exp_t *e,
		      subtilis_error_t *err)
{
	/*
	 * This one needs to be sign extended.
	 */

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

	subtilis_type_int32.print(p, e, 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), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x523e0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53274
jmp 0x53290
leaq 0x81d5d(%rip), %rax     # 0xd4fd8
movq 0x218(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_swap_reg_mem
static void prv_swap_reg_mem(subtilis_parser_t *p, const subtilis_type_t *type,
			     size_t reg1, size_t reg2, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;
	subtilis_ir_operand_t zero;
	subtilis_ir_operand_t tmp;

	op1.reg = reg1;
	op2.reg = reg2;
	zero.integer = 0;

	tmp.reg = subtilis_ir_section_add_instr2(
	    p->current, SUBTILIS_OP_INSTR_MOV, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I8, op1, op2, zero, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_I8, tmp, op2, zero, 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 -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movl $0x1d, %esi
callq 0x38490
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x533ac
jmp 0x533fb
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x11, %esi
callq 0x38360
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x533d9
jmp 0x533fb
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %r9
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x16, %esi
callq 0x38360
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/byte_type_if.c
// Function: prv_zerox
static subtilis_exp_t *prv_zerox(subtilis_parser_t *p, subtilis_exp_t *e,
				 subtilis_error_t *err)
{
	size_t reg;
	subtilis_ir_operand_t op;

	op.integer = 255;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_ANDI_I32, e->exp.ir_op, op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	e->type.type = SUBTILIS_TYPE_INTEGER;
	e->exp.ir_op.reg = reg;
	return e;

on_error:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xff, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %r8
movq 0x148(%rax), %rdx
movq -0x30(%rbp), %rcx
movl $0x25, %esi
callq 0x38230
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5349f
jmp 0x534c2
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x534d3
movq -0x18(%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/byte_type_if.c
// Function: prv_commutative_nc
static subtilis_exp_t *
prv_commutative_nc(subtilis_parser_t *p, subtilis_exp_t *a1, subtilis_exp_t *a2,
		   subtilis_op_instr_type_t in_var_var,
		   subtilis_type_if_binary_nc_t binary_nc_fn, bool swapped,
		   subtilis_error_t *err)
{
	size_t reg;

	if (a2->type.type == SUBTILIS_TYPE_BYTE) {
		reg = subtilis_ir_section_add_instr(
		    p->current, in_var_var, a1->exp.ir_op, a2->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		a1->exp.ir_op.reg = reg;
		subtilis_exp_delete(a2);
		return a1;
	}

	a1 = prv_to_int32(p, a1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	return binary_nc_fn(p, a1, a2, swapped, err);

on_error:
	subtilis_exp_delete(a1);
	subtilis_exp_delete(a2);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x5356b
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rbp), %r8
movq 0x148(%rcx), %rdx
movq 0x148(%rax), %rcx
callq 0x38230
movq %rax, -0x40(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53549
jmp 0x535b0
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x535ca
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x523e0
movq %rax, -0x18(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5358b
jmp 0x535b0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x31(%rbp), %cl
movq 0x10(%rbp), %r8
andb $0x1, %cl
movzbl %cl, %ecx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x535ca
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)