LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_to_string_const
static subtilis_exp_t *prv_to_string_const(subtilis_parser_t *p,
					   subtilis_exp_t *e,
					   subtilis_error_t *err)
{
	char buf[32];
	size_t len = sprintf(buf, "%" PRIi32, e->exp.ir_op.integer) + 1;

	e->type.type = SUBTILIS_TYPE_CONST_STRING;
	subtilis_buffer_init(&e->exp.str, 128);
	subtilis_buffer_append(&e->exp.str, buf, len, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		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)
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x148(%rax), %edx
leaq 0x5d11b(%rip), %rsi     # 0xaaee4
movb $0x0, %al
callq 0x12250
addl $0x1, %eax
cltq
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movl $0x80, %esi
callq 0x15f80
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x16200
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4de30
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4de38
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/int32_type.c
// Function: prv_to_hex_string_const
static subtilis_exp_t *prv_to_hex_string_const(subtilis_parser_t *p,
					       subtilis_exp_t *e,
					       subtilis_error_t *err)
{
	char buf[32];
	size_t len = sprintf(buf, "%" PRIX32, e->exp.ir_op.integer) + 1;

	e->type.type = SUBTILIS_TYPE_CONST_STRING;
	subtilis_buffer_init(&e->exp.str, 128);
	subtilis_buffer_append(&e->exp.str, buf, len, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		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)
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x148(%rax), %edx
leaq 0x5e629(%rip), %rsi     # 0xac4a2
movb $0x0, %al
callq 0x12250
addl $0x1, %eax
cltq
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movl $0x80, %esi
callq 0x15f80
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x16200
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4dee0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4dee8
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/int32_type.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)
{
	switch (type->type) {
	case SUBTILIS_TYPE_CONST_REAL:
		e->type.type = SUBTILIS_TYPE_CONST_REAL;
		e->exp.ir_op.real = (double)e->exp.ir_op.integer;
		break;
	case SUBTILIS_TYPE_CONST_INTEGER:
		break;
	case SUBTILIS_TYPE_CONST_BYTE:
		e->type.type = SUBTILIS_TYPE_CONST_BYTE;
		break;
	case SUBTILIS_TYPE_REAL:
		e = subtilis_type_if_exp_to_var(p, e, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
		e = subtilis_type_if_to_float64(p, e, err);
		break;
	case SUBTILIS_TYPE_INTEGER:
		e = subtilis_type_if_exp_to_var(p, e, err);
		break;
	case SUBTILIS_TYPE_BYTE:
		e = subtilis_type_if_exp_to_var(p, e, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return NULL;
		e->type.type = SUBTILIS_TYPE_BYTE;
		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
movq %rax, -0x30(%rbp)
subq $0x6, %rax
ja 0x4e011
movq -0x30(%rbp), %rax
leaq 0x5e4f5(%rip), %rcx     # 0xac42c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
cvtsi2sdl 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x148(%rax)
jmp 0x4e080
jmp 0x4e080
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
jmp 0x4e080
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4dfa6
movq $0x0, -0x8(%rbp)
jmp 0x4e088
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x48ae0
movq %rax, -0x18(%rbp)
jmp 0x4e080
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
jmp 0x4e080
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4e005
movq $0x0, -0x8(%rbp)
jmp 0x4e088
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
jmp 0x4e080
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 0x5e449(%rip), %rax     # 0xac4a5
movq %rax, (%rsp)
movl $0xce, 0x8(%rsp)
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4e088
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/int32_type.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)
{
	/* a2 must be const */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		a1->exp.ir_op.integer += a2->exp.ir_op.integer;
		break;
	case SUBTILIS_TYPE_CONST_REAL:
		a1->exp.ir_op.real =
		    ((double)a1->exp.ir_op.integer) + a2->exp.ir_op.real;
		a1->type.type = SUBTILIS_TYPE_CONST_REAL;
		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
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x4e124
jmp 0x4e0fe
movl -0x34(%rbp), %eax
subl $0x1, %eax
jne 0x4e154
jmp 0x4e108
movq -0x20(%rbp), %rax
movl 0x148(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x148(%rax), %ecx
movl %ecx, 0x148(%rax)
jmp 0x4e1a0
movq -0x18(%rbp), %rax
cvtsi2sdl 0x148(%rax), %xmm0
movq -0x20(%rbp), %rax
addsd 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x148(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x4e1a0
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 0x5e31a(%rip), %r8      # 0xac4a5
movl $0xf1, %r9d
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x4e1b1
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
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_mul_const
static subtilis_exp_t *prv_mul_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/* a2 must be const */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		a1->exp.ir_op.integer *= a2->exp.ir_op.integer;
		break;
	case SUBTILIS_TYPE_CONST_REAL:
		a1->exp.ir_op.real =
		    ((double)a1->exp.ir_op.integer) * a2->exp.ir_op.real;
		a1->type.type = SUBTILIS_TYPE_CONST_REAL;
		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 $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)
testl %eax, %eax
je 0x4e20e
jmp 0x4e1e7
movl -0x2c(%rbp), %eax
subl $0x1, %eax
jne 0x4e23e
jmp 0x4e1f1
movq -0x20(%rbp), %rax
movl 0x148(%rax), %ecx
movq -0x18(%rbp), %rax
imull 0x148(%rax), %ecx
movl %ecx, 0x148(%rax)
jmp 0x4e28a
movq -0x18(%rbp), %rax
cvtsi2sdl 0x148(%rax), %xmm0
movq -0x20(%rbp), %rax
mulsd 0x148(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x148(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x4e28a
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 0x5e230(%rip), %r8      # 0xac4a5
movl $0x10b, %r9d            # imm = 0x10B
callq 0x15930
movq $0x0, -0x8(%rbp)
jmp 0x4e29b
movq -0x20(%rbp), %rdi
callq 0x36ee0
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/int32_type.c
// Function: prv_and_const
static subtilis_exp_t *prv_and_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/* a2 must be const */

	a2 = subtilis_type_if_to_int(p, a2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	a1->exp.ir_op.integer &= a2->exp.ir_op.integer;
	subtilis_exp_delete(a2);
	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 -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4e2f9
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4e324
movq -0x20(%rbp), %rax
movl 0x148(%rax), %ecx
movq -0x18(%rbp), %rax
andl 0x148(%rax), %ecx
movl %ecx, 0x148(%rax)
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_div_const
static subtilis_exp_t *prv_div_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/*
	 * Oddly, a2 may not be const as we don't currently swap operands
	 * for integer division as the ARM backend has no implementation
	 * for rdiv.  Some day we'll have to as some CPUs have native
	 * support for integer division, but for the time being we'll have to
	 * handle the unusual case of having to deal with a variable here.
	 * a2 is at least guaranteed to be an integer.
	 */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		if (a2->exp.ir_op.integer == 0) {
			subtilis_error_set_divide_by_zero(
			    err, p->l->stream->name, p->l->line);
			goto on_error;
		}
		a1->exp.ir_op.integer /= a2->exp.ir_op.integer;
		break;
	case SUBTILIS_TYPE_BYTE:
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	case SUBTILIS_TYPE_INTEGER:
		prv_div_mod_const_var(p, a1, a2, SUBTILIS_OP_INSTR_DIV_I32,
				      err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		break;
	default:
		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)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x4e7b3
jmp 0x4e798
movl -0x2c(%rbp), %eax
subl $0x5, %eax
je 0x4e840
jmp 0x4e7a6
movl -0x2c(%rbp), %eax
subl $0x6, %eax
je 0x4e81e
jmp 0x4e867
movq -0x20(%rbp), %rax
cmpl $0x0, 0x148(%rax)
jne 0x4e7f5
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 $0x1a, %esi
leaq 0x5dcc0(%rip), %r8      # 0xac4a5
movl $0x20d, %r9d            # imm = 0x20D
callq 0x15930
jmp 0x4e87c
movq -0x20(%rbp), %rax
movl 0x148(%rax), %ecx
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x148(%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x148(%rax)
jmp 0x4e869
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4e83e
jmp 0x4e87c
jmp 0x4e840
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0x6, %ecx
callq 0x50d90
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4e865
jmp 0x4e87c
jmp 0x4e869
jmp 0x4e87c
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4e896
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
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_lsl_const
static subtilis_exp_t *prv_lsl_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/* a2 may not be const as we don't order the arguments */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		a1->exp.ir_op.integer = a1->exp.ir_op.integer
					<< (a2->exp.ir_op.integer & 63);
		break;
	case SUBTILIS_TYPE_BYTE:
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	case SUBTILIS_TYPE_INTEGER:
		prv_shift_const_var(p, a1, a2, SUBTILIS_OP_INSTR_LSL_I32, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		break;
	default:
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		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 $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 $0x1, %eax
je 0x4f03c
jmp 0x4f028
movl -0x2c(%rbp), %eax
subl $0x5, %eax
je 0x4f085
jmp 0x4f032
movl -0x2c(%rbp), %eax
subl $0x6, %eax
je 0x4f063
jmp 0x4f0ac
movq -0x18(%rbp), %rax
movl 0x148(%rax), %eax
movq -0x20(%rbp), %rcx
movl 0x148(%rcx), %ecx
andl $0x3f, %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x148(%rax)
jmp 0x4f0de
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f083
jmp 0x4f0f1
jmp 0x4f085
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0x4b, %ecx
callq 0x51120
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f0aa
jmp 0x4f0f1
jmp 0x4f0de
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 0x5d3d4(%rip), %r8      # 0xac4a5
movl $0x320, %r9d            # imm = 0x320
callq 0x15930
jmp 0x4f0f1
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f10b
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_lsr_const
static subtilis_exp_t *prv_lsr_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/* a2 may not be const as we don't order the arguments */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		a1->exp.ir_op.integer =
		    (int32_t)((uint32_t)a1->exp.ir_op.integer >>
			      ((uint32_t)a2->exp.ir_op.integer & 63));
		break;
	case SUBTILIS_TYPE_BYTE:
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	case SUBTILIS_TYPE_INTEGER:
		prv_shift_const_var(p, a1, a2, SUBTILIS_OP_INSTR_LSR_I32, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		break;
	default:
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		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 $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 $0x1, %eax
je 0x4f15c
jmp 0x4f148
movl -0x2c(%rbp), %eax
subl $0x5, %eax
je 0x4f1a5
jmp 0x4f152
movl -0x2c(%rbp), %eax
subl $0x6, %eax
je 0x4f183
jmp 0x4f1cc
movq -0x18(%rbp), %rax
movl 0x148(%rax), %eax
movq -0x20(%rbp), %rcx
movl 0x148(%rcx), %ecx
andl $0x3f, %ecx
shrl %cl, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x148(%rax)
jmp 0x4f1fe
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f1a3
jmp 0x4f211
jmp 0x4f1a5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0x4d, %ecx
callq 0x51120
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f1ca
jmp 0x4f211
jmp 0x4f1fe
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 0x5d2b4(%rip), %r8      # 0xac4a5
movl $0x343, %r9d            # imm = 0x343
callq 0x15930
jmp 0x4f211
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f22b
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_asr_const
static subtilis_exp_t *prv_asr_const(subtilis_parser_t *p, subtilis_exp_t *a1,
				     subtilis_exp_t *a2, subtilis_error_t *err)
{
	/* a2 may not be const as we don't order the arguments */

	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		a1->exp.ir_op.integer =
		    a1->exp.ir_op.integer >> (a2->exp.ir_op.integer & 63);
		break;
	case SUBTILIS_TYPE_BYTE:
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	case SUBTILIS_TYPE_INTEGER:
		prv_shift_const_var(p, a1, a2, SUBTILIS_OP_INSTR_ASR_I32, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		break;
	default:
		subtilis_error_set_bad_expression(err, p->l->stream->name,
						  p->l->line);
		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 $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 $0x1, %eax
je 0x4f27c
jmp 0x4f268
movl -0x2c(%rbp), %eax
subl $0x5, %eax
je 0x4f2c5
jmp 0x4f272
movl -0x2c(%rbp), %eax
subl $0x6, %eax
je 0x4f2a3
jmp 0x4f2ec
movq -0x18(%rbp), %rax
movl 0x148(%rax), %eax
movq -0x20(%rbp), %rcx
movl 0x148(%rcx), %ecx
andl $0x3f, %ecx
sarl %cl, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x148(%rax)
jmp 0x4f31e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f2c3
jmp 0x4f331
jmp 0x4f2c5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0x4f, %ecx
callq 0x51120
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f2ea
jmp 0x4f331
jmp 0x4f31e
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 0x5d194(%rip), %r8      # 0xac4a5
movl $0x365, %r9d            # imm = 0x365
callq 0x15930
jmp 0x4f331
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f34b
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_sgn_const
static subtilis_exp_t *prv_sgn_const(subtilis_parser_t *p, subtilis_exp_t *e,
				     subtilis_error_t *err)
{
	if (e->exp.ir_op.integer < 0)
		e->exp.ir_op.integer = -1;
	else if (e->exp.ir_op.integer > 0)
		e->exp.ir_op.integer = 1;

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x148(%rax)
jge 0x4f3cd
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x148(%rax) # imm = 0xFFFFFFFF
jmp 0x4f3ea
movq -0x10(%rbp), %rax
cmpl $0x0, 0x148(%rax)
jle 0x4f3e8
movq -0x10(%rbp), %rax
movl $0x1, 0x148(%rax)
jmp 0x4f3ea
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.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_int32_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 0x4f46c
movq $0x0, -0x8(%rbp)
jmp 0x4f47f
movq -0x30(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x37770
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/int32_type.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)0x80000000;
	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_int32_var(reg_num, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x80000000, -0x20(%rbp) # imm = 0x80000000
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 0x4f4d8
movq $0x0, -0x8(%rbp)
jmp 0x4f4eb
movq -0x28(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x37770
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/int32_type.c
// Function: prv_zero_reg
static void prv_zero_reg(subtilis_parser_t *p, const subtilis_type_t *type,
			 size_t reg, subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	subtilis_ir_operand_t op1;

	op0.reg = reg;
	op1.integer = 0;
	subtilis_ir_section_add_instr_no_reg2(
	    p->current, SUBTILIS_OP_INSTR_MOVI_I32, op0, op1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x1b, %esi
callq 0x385a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_copy_var
static subtilis_exp_t *prv_copy_var(subtilis_parser_t *p, subtilis_exp_t *e,
				    subtilis_error_t *err)
{
	size_t reg;
	subtilis_exp_t *e2;

	reg = subtilis_ir_section_add_instr2(p->current, SUBTILIS_OP_INSTR_MOV,
					     e->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	e2 = subtilis_exp_new_int32_var(reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	subtilis_exp_delete(e);
	return e2;

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 $0x1d, %esi
callq 0x38490
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f5f4
jmp 0x4f625
movq -0x28(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x37770
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f612
jmp 0x4f625
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f636
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.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_I32, op1, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_exp_new_int32_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 $0x12, %esi
callq 0x38230
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f770
movq $0x0, -0x8(%rbp)
jmp 0x4f783
movq -0x48(%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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.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;

	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), %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 0x4f7f4
jmp 0x4f817
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 0x4f828
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/int32_type.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_CONST_REAL:
		e->type.type = SUBTILIS_TYPE_CONST_INTEGER;
		e->exp.ir_op.integer = (int32_t)e->exp.ir_op.real;
		e = subtilis_type_if_exp_to_var(p, e, err);
		break;
	case SUBTILIS_TYPE_CONST_INTEGER:
		e = subtilis_type_if_exp_to_var(p, e, err);
		break;
	case SUBTILIS_TYPE_REAL:
		e = subtilis_type_if_to_float64(p, e, err);
		break;
	case SUBTILIS_TYPE_BYTE:
		e->type.type = SUBTILIS_TYPE_BYTE;
		break;
	case SUBTILIS_TYPE_INTEGER:
		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
movq %rax, -0x30(%rbp)
subq $0x6, %rax
ja 0x4f999
movq -0x30(%rbp), %rax
leaq 0x5cb31(%rip), %rcx     # 0xac448
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
cvttsd2si 0x148(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x148(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
jmp 0x4fa08
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x47c10
movq %rax, -0x18(%rbp)
jmp 0x4fa08
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x48ae0
movq %rax, -0x18(%rbp)
jmp 0x4fa08
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
jmp 0x4fa08
jmp 0x4fa08
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 0x5cac1(%rip), %rax     # 0xac4a5
movq %rax, (%rsp)
movl $0x4e9, 0x8(%rsp)       # imm = 0x4E9
callq 0x156d0
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4fa10
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_unary_minus
static subtilis_exp_t *prv_unary_minus(subtilis_parser_t *p, subtilis_exp_t *e,
				       subtilis_error_t *err)
{
	size_t reg;
	subtilis_ir_operand_t operand;

	operand.integer = 0;
	reg = subtilis_ir_section_add_instr(p->current,
					    SUBTILIS_OP_INSTR_RSUBI_I32,
					    e->exp.ir_op, operand, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	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 $0x0, -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 $0x21, %esi
callq 0x38230
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4fa6f
jmp 0x4fa88
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fa99
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/int32_type.c
// Function: prv_and
static subtilis_exp_t *prv_and(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a2 = subtilis_type_if_to_int(p, a2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	/* last two parameters are not used. */

	return prv_commutative(
	    p, a1, a2, SUBTILIS_OP_INSTR_ANDI_I32, SUBTILIS_OP_INSTR_AND_I32,
	    SUBTILIS_OP_INSTR_ANDI_I32, SUBTILIS_OP_INSTR_AND_I32, 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 -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4fba9
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4fbdd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl $0x25, %r9d
movl $0x24, %r8d
movl %r9d, %ecx
movl $0x24, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
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/int32_type.c
// Function: prv_or
static subtilis_exp_t *prv_or(subtilis_parser_t *p, subtilis_exp_t *a1,
			      subtilis_exp_t *a2, subtilis_error_t *err)
{
	a2 = subtilis_type_if_to_int(p, a2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	/* last two parameters are not used. */

	return prv_commutative(
	    p, a1, a2, SUBTILIS_OP_INSTR_ORI_I32, SUBTILIS_OP_INSTR_OR_I32,
	    SUBTILIS_OP_INSTR_ORI_I32, SUBTILIS_OP_INSTR_OR_I32, 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 -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4fc39
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4fc6d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl $0x27, %r9d
movl $0x26, %r8d
movl %r9d, %ecx
movl $0x26, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
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/int32_type.c
// Function: prv_not
static subtilis_exp_t *prv_not(subtilis_parser_t *p, subtilis_exp_t *e,
			       subtilis_error_t *err)
{
	size_t reg;
	subtilis_ir_operand_t operand;

	operand.integer = 0;
	reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_NOT_I32, e->exp.ir_op, operand, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	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 $0x0, -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 $0x2a, %esi
callq 0x38230
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4fccf
jmp 0x4fce8
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fcf9
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/int32_type.c
// Function: prv_eor
static subtilis_exp_t *prv_eor(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, subtilis_error_t *err)
{
	a2 = subtilis_type_if_to_int(p, a2, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(a1);
		return NULL;
	}

	/* last two parameters are not used. */

	return prv_commutative(
	    p, a1, a2, SUBTILIS_OP_INSTR_EORI_I32, SUBTILIS_OP_INSTR_EOR_I32,
	    SUBTILIS_OP_INSTR_EORI_I32, SUBTILIS_OP_INSTR_EOR_I32, 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 -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4fd59
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x4fd8d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl $0x29, %r9d
movl $0x28, %r8d
movl %r9d, %ecx
movl $0x28, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
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/int32_type.c
// Function: prv_sub
static subtilis_exp_t *prv_sub(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, bool swapped,
			       subtilis_error_t *err)
{
	subtilis_op_instr_type_t int_var_imm;
	subtilis_op_instr_type_t real_var_imm;

	if (swapped) {
		int_var_imm = SUBTILIS_OP_INSTR_RSUBI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_RSUBI_REAL;
	} else {
		int_var_imm = SUBTILIS_OP_INSTR_SUBI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_SUBI_REAL;
	}

	return prv_commutative(p, a1, a2, int_var_imm,
			       SUBTILIS_OP_INSTR_SUB_I32, real_var_imm,
			       SUBTILIS_OP_INSTR_SUB_REAL, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x4fe75
movl $0x21, -0x2c(%rbp)
movl $0x22, -0x30(%rbp)
jmp 0x4fe83
movl $0xb, -0x2c(%rbp)
movl $0xc, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rax
movl $0x2, %r8d
movl $0x3, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.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)
{
	switch (a2->type.type) {
	case SUBTILIS_TYPE_CONST_INTEGER:
		if (a2->exp.ir_op.integer == 0) {
			subtilis_error_set_divide_by_zero(
			    err, p->l->stream->name, p->l->line);
			break;
		}
		a1->exp.ir_op.reg =
		    prv_div_by_constant(p, a1->exp.ir_op, a2->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		break;
	case SUBTILIS_TYPE_BYTE:
		a2 = subtilis_type_if_to_int(p, a2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	case SUBTILIS_TYPE_INTEGER:
		a1->exp.ir_op.reg =
		    prv_div_mod_vars(p, a1->exp.ir_op, a2->exp.ir_op,
				     SUBTILIS_OP_INSTR_DIV_I32, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
		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 $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 $0x1, %eax
je 0x4ff07
jmp 0x4fee8
movl -0x2c(%rbp), %eax
subl $0x5, %eax
je 0x4ffaf
jmp 0x4fef6
movl -0x2c(%rbp), %eax
subl $0x6, %eax
je 0x4ff8d
jmp 0x4fff2
movq -0x20(%rbp), %rax
cmpl $0x0, 0x148(%rax)
jne 0x4ff49
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 $0x1a, %esi
leaq 0x5c56c(%rip), %r8      # 0xac4a5
movl $0x67c, %r9d            # imm = 0x67C
callq 0x15930
jmp 0x5000e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x148(%rdx), %rsi
movq 0x148(%rax), %rdx
callq 0x51920
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4ff88
jmp 0x50021
jmp 0x5000e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x488b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4ffad
jmp 0x50021
jmp 0x4ffaf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %r8
movq 0x148(%rcx), %rsi
movq 0x148(%rax), %rdx
movl $0x6, %ecx
callq 0x50e40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4fff0
jmp 0x50021
jmp 0x5000e
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x5c4a3(%rip), %rdx     # 0xac4a5
movl $0x690, %ecx            # imm = 0x690
callq 0x158e0
jmp 0x50021
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5003b
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_gt
static subtilis_exp_t *prv_gt(subtilis_parser_t *p, subtilis_exp_t *a1,
			      subtilis_exp_t *a2, bool swapped,
			      subtilis_error_t *err)
{
	subtilis_op_instr_type_t int_var_imm;
	subtilis_op_instr_type_t real_var_imm;

	if (swapped) {
		int_var_imm = SUBTILIS_OP_INSTR_LTI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_LTI_REAL;
	} else {
		int_var_imm = SUBTILIS_OP_INSTR_GTI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_GTI_REAL;
	}

	return prv_commutative(p, a1, a2, int_var_imm, SUBTILIS_OP_INSTR_GT_I32,
			       real_var_imm, SUBTILIS_OP_INSTR_GT_REAL, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x50215
movl $0x3d, -0x2c(%rbp)
movl $0x3e, -0x30(%rbp)
jmp 0x50223
movl $0x35, -0x2c(%rbp)
movl $0x36, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rax
movl $0x33, %r8d
movl $0x34, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_lte
static subtilis_exp_t *prv_lte(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, bool swapped,
			       subtilis_error_t *err)
{
	subtilis_op_instr_type_t int_var_imm;
	subtilis_op_instr_type_t real_var_imm;

	if (swapped) {
		int_var_imm = SUBTILIS_OP_INSTR_GTEI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_GTEI_REAL;
	} else {
		int_var_imm = SUBTILIS_OP_INSTR_LTEI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_LTEI_REAL;
	}

	return prv_commutative(p, a1, a2, int_var_imm,
			       SUBTILIS_OP_INSTR_LTE_I32, real_var_imm,
			       SUBTILIS_OP_INSTR_LTE_REAL, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x50295
movl $0x41, -0x2c(%rbp)
movl $0x42, -0x30(%rbp)
jmp 0x502a3
movl $0x39, -0x2c(%rbp)
movl $0x3a, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rax
movl $0x37, %r8d
movl $0x38, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_lt
static subtilis_exp_t *prv_lt(subtilis_parser_t *p, subtilis_exp_t *a1,
			      subtilis_exp_t *a2, bool swapped,
			      subtilis_error_t *err)
{
	subtilis_op_instr_type_t int_var_imm;
	subtilis_op_instr_type_t real_var_imm;

	if (swapped) {
		int_var_imm = SUBTILIS_OP_INSTR_GTI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_GTI_REAL;
	} else {
		int_var_imm = SUBTILIS_OP_INSTR_LTI_I32;
		;
		real_var_imm = SUBTILIS_OP_INSTR_LTI_REAL;
	}

	return prv_commutative(p, a1, a2, int_var_imm, SUBTILIS_OP_INSTR_LT_I32,
			       real_var_imm, SUBTILIS_OP_INSTR_LT_REAL, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x50315
movl $0x35, -0x2c(%rbp)
movl $0x36, -0x30(%rbp)
jmp 0x50323
movl $0x3d, -0x2c(%rbp)
movl $0x3e, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rax
movl $0x3b, %r8d
movl $0x3c, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/int32_type.c
// Function: prv_gte
static subtilis_exp_t *prv_gte(subtilis_parser_t *p, subtilis_exp_t *a1,
			       subtilis_exp_t *a2, bool swapped,
			       subtilis_error_t *err)
{
	subtilis_op_instr_type_t int_var_imm;
	subtilis_op_instr_type_t real_var_imm;

	if (swapped) {
		int_var_imm = SUBTILIS_OP_INSTR_LTEI_I32;
		real_var_imm = SUBTILIS_OP_INSTR_LTEI_REAL;
	} else {
		int_var_imm = SUBTILIS_OP_INSTR_GTEI_I32;
		;
		real_var_imm = SUBTILIS_OP_INSTR_GTEI_REAL;
	}

	return prv_commutative(p, a1, a2, int_var_imm,
			       SUBTILIS_OP_INSTR_GTE_I32, real_var_imm,
			       SUBTILIS_OP_INSTR_GTE_REAL, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x50395
movl $0x39, -0x2c(%rbp)
movl $0x3a, -0x30(%rbp)
jmp 0x503a3
movl $0x41, -0x2c(%rbp)
movl $0x42, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rax
movl $0x3f, %r8d
movl $0x40, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x513c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)