LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_ret
static void opp_analize_ret(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	// Returning value from void
	if ((ctx->debug.ret_type.decl->t_type == TYPE_VOID && ctx->debug.ret_type.depth == 0) 
		&& node->ret_stmt.value != NULL)
		opp_semantics_error(ctx, node, "Attempting to return value from 'void' function");

	// Return without value but expected
	if (ctx->debug.ret_type.decl->t_type != TYPE_VOID && node->ret_stmt.value == NULL) {
		ctx->debug.ret = 1;
		opp_warning(ctx, node, "No return value in function which expects value");
		return;
	}

	if (ctx->debug.ret_type.decl->t_type != TYPE_VOID) {
		Opp_Obj type = opp_analize_expr(ctx, node->ret_stmt.value);

		if (type.depth != ctx->debug.ret_type.depth)
			opp_warning(ctx, node, "Returning different pointer depth");
	}

	ctx->debug.ret = 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x307f
movq 0x20(%rsp), %rax
movzwl 0x38(%rax), %eax
cmpl $0x0, %eax
jne 0x307f
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x307f
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x1070d(%rip), %rdx     # 0x13785
movb $0x0, %al
callq 0x2b10
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x8(%rax)
je 0x30bd
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x30bd
movq 0x20(%rsp), %rax
movb $0x1, 0x28(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x10701(%rip), %rdx     # 0x137b5
movb $0x0, %al
callq 0x2e80
jmp 0x311e
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x8(%rax)
je 0x3115
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movzwl 0x10(%rsp), %eax
movq 0x20(%rsp), %rcx
movzwl 0x38(%rcx), %ecx
cmpl %ecx, %eax
je 0x3113
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x106d9(%rip), %rdx     # 0x137e5
movb $0x0, %al
callq 0x2e80
jmp 0x3115
movq 0x20(%rsp), %rax
movb $0x1, 0x28(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_if
static void opp_analize_if(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	opp_analize_time_eval(ctx, node->if_stmt.cond);

	opp_analize_expr(ctx, node->if_stmt.cond);

	if (node->if_stmt.cond->type != ELOGIC && node->if_stmt.cond->type != EUNARY)
		opp_semantics_error(ctx, node, "If statement requires condition");

	opp_analize_stmt(ctx, node->if_stmt.then);

	if (node->if_stmt.other != NULL)
		opp_analize_stmt(ctx, node->if_stmt.other);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3910
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
je 0x3602
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, (%rax)
je 0x3602
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x1042b(%rip), %rdx     # 0x13a26
movb $0x0, %al
callq 0x2b10
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2d70
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3634
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x2d70
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_while
static void opp_analize_while(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	opp_analize_time_eval(ctx, node->while_stmt.cond);

	opp_analize_expr(ctx, node->while_stmt.cond);

	if (node->while_stmt.cond->type != ELOGIC && node->while_stmt.cond->type != EUNARY)
		opp_semantics_error(ctx, node, "While statement requires condition");

	opp_analize_stmt(ctx, node->while_stmt.then);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3910
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
je 0x36b2
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, (%rax)
je 0x36b2
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x103e9(%rip), %rdx     # 0x13a94
movb $0x0, %al
callq 0x2b10
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2d70
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_block
static void opp_analize_block(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	struct Opp_Namespace* temp = ctx->curr_ns;
	node->block_stmt.ns = init_namespace(temp, (void*)alloc);
	ctx->curr_ns = node->block_stmt.ns;

	for (unsigned int i = 0; i < node->block_stmt.len; i++)
		opp_analize_stmt(ctx, node->block_stmt.stmts[i]);

	ctx->curr_ns = temp;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xaa98(%rip), %rsi      # 0xe190
callq 0x12990
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x3759
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x2d70
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3723
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_expr
static Opp_Obj opp_analize_expr(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	switch (node->type)
	{
		case ECALL:
			return opp_analize_call(ctx, node);

		case EBIN:
			return opp_analize_bin(ctx, node);

		case EUNARY:
			return opp_analize_unary(ctx, node);

		case EDOT:
			return opp_analize_dot(ctx, node);

		case EDEREF:
			return opp_analize_deref(ctx, node);

		case EELEMENT:
			return opp_analize_elem(ctx, node);

		case EADDR:
			return opp_analize_addr(ctx, node);

		case ELOGIC:
			return opp_analize_logic(ctx, node);

		case ESUB:
			return opp_analize_sub(ctx, node);

		case EADJUST:
			return opp_analize_adjust(ctx, node);

		case ESIZEOF:
			return opp_analize_sizeof(ctx, node);

		default:
			opp_semantics_error(ctx, node, "Use of unsupported expr");
			break;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xc, %eax
ja 0x38e8
movq (%rsp), %rax
leaq 0xfd8b(%rip), %rcx      # 0x1352c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3300
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4870
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4b60
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4ce0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4df0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4ee0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4fa0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5030
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5180
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x51f0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5210
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x3900
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x101be(%rip), %rdx     # 0x13ab7
movb $0x0, %al
callq 0x2b10
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_unary
static Opp_Obj opp_analize_unary(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	Opp_Obj type;

	switch (node->unary_expr.type)
	{
		case TINTEGER:
			type.decl = int_type;
			type.depth = 0;
			type.size = 0;
			type.unsign = 0;
			break;

		case TSTR:
			type.decl = char_type;
			type.depth = 1;
			type.size = 0;
			type.unsign = 0;
			break;
		

		case TFLOAT:
			type.decl = float_type;
			type.depth = 0;
			type.size = 0;
			type.unsign = 0;
			break;
		
		case TIDENT: {
			struct Opp_Bucket* bucket = env_get_item(ctx->curr_ns, node->unary_expr.val.strval);

			if (bucket == NULL)
				opp_semantics_error(ctx, node, "Use of undeclared variable '%s'",
					node->unary_expr.val.strval);

			if (bucket->type == TYPE_LABEL)
				opp_semantics_error(ctx, node, "Invalid use of label '%s'",
					bucket->key);
			
			node->unary_expr.bidx = bucket;
			ctx->debug.res_name = bucket->key;

			return bucket->sym_type;
		}
		default: break;
	}
	return type;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4, %eax
ja 0x4cba
movq 0x8(%rsp), %rax
leaq 0xea18(%rip), %rcx      # 0x135ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1471c(%rip), %rax     # 0x192c0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movw $0x0, 0x20(%rsp)
movw $0x0, 0x22(%rsp)
movb $0x0, 0x24(%rsp)
jmp 0x4cbc
leaq 0x146ed(%rip), %rax     # 0x192b8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movw $0x1, 0x20(%rsp)
movw $0x0, 0x22(%rsp)
movb $0x0, 0x24(%rsp)
jmp 0x4cbc
leaq 0x146de(%rip), %rax     # 0x192d0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movw $0x0, 0x20(%rsp)
movw $0x0, 0x22(%rsp)
movb $0x0, 0x24(%rsp)
jmp 0x4cbc
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x12c10
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c57
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rcx
leaq 0xef1d(%rip), %rdx      # 0x13b6d
movb $0x0, %al
callq 0x2b10
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x4c82
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rcx
leaq 0xef12(%rip), %rdx      # 0x13b8d
movb $0x0, %al
callq 0x2b10
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x4cd0
jmp 0x4cbc
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_dot
static Opp_Obj opp_analize_dot(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	Opp_Obj lhs = opp_analize_expr(ctx, node->dot_expr.left);

	// Error if attempint dot access on non struct
	if (lhs.decl->t_type != TYPE_STRUCT || lhs.depth > 0)
		opp_semantics_error(ctx, node, "Attempting to access element on a non object type '%s'",
			ctx->debug.res_name);

	const char* left = ctx->debug.res_name;

	// Error if no identifier memeber
	if (node->dot_expr.right->type != EUNARY || node->dot_expr.right->unary_expr.type != TIDENT)
		opp_semantics_error(ctx, node, "Expected element on right side of '%s' dot expr", left);

	// TODO: Rethink if better strategy
	// Switch to struct namespace
	struct Opp_Namespace* temp = ctx->curr_ns;
	ctx->curr_ns = lhs.decl->s_elems->ns;

	Opp_Obj rhs = opp_analize_expr(ctx, node->dot_expr.right);
	
	ctx->curr_ns = temp;

	return rhs;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x4d20
movzwl 0x20(%rsp), %eax
cmpl $0x0, %eax
jle 0x4d41
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rcx
leaq 0xee6d(%rip), %rdx      # 0x13ba7
movb $0x0, %al
callq 0x2b10
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x5, (%rax)
jne 0x4d6c
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0x4d89
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0xee5c(%rip), %rdx      # 0x13bde
movb $0x0, %al
callq 0x2b10
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x3770
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_deref
static Opp_Obj opp_analize_deref(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	// Error if lhs of deref is invalid
	if ((node->deref_expr.deref->type != EUNARY || node->deref_expr.deref->unary_expr.type != TIDENT)
		&& (node->deref_expr.deref->type != EBIN) && (node->deref_expr.deref->type != EADDR)
		&& (node->deref_expr.deref->type != EDEREF) && (node->deref_expr.deref->type != EDOT
		&& (node->deref_expr.deref->type != EELEMENT)))
			opp_semantics_error(ctx, node, "Attempt to dereference invalid expression");

	Opp_Obj lhs = opp_analize_expr(ctx, node->deref_expr.deref);

	if (lhs.depth == 0)
		opp_semantics_error(ctx, node, 
			"Attempting to dereference a non pointer type '%s'", ctx->debug.res_name);

	lhs.depth--;

	return lhs;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, (%rax)
jne 0x4e1b
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0x4e79
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
je 0x4e79
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0xa, (%rax)
je 0x4e79
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x8, (%rax)
je 0x4e79
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0xd, (%rax)
je 0x4e79
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x7, (%rax)
je 0x4e79
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xed9c(%rip), %rdx      # 0x13c0e
movb $0x0, %al
callq 0x2b10
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movzwl 0x20(%rsp), %eax
cmpl $0x0, %eax
jne 0x4ec1
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
leaq 0xed7e(%rip), %rdx      # 0x13c38
movb $0x0, %al
callq 0x2b10
movw 0x20(%rsp), %ax
decw %ax
movw %ax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_elem
static Opp_Obj opp_analize_elem(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	Opp_Obj lhs = opp_analize_expr(ctx, node->elem_expr.name);

	if (node->elem_expr.name->type == EELEMENT)
		return lhs;

	Opp_Obj rhs = opp_analize_expr(ctx, node->elem_expr.loc);

	if (lhs.depth == 0 && rhs.depth == 0)
		opp_semantics_error(ctx, node, "Attemping to get element of non pointer / array type '%s'",
			ctx->debug.res_name);

	lhs.size = 0;
	if (lhs.depth > 0)
		lhs.depth--;

	return lhs;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x7, (%rax)
jne 0x4f1b
jmp 0x4f8e
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x3770
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movzwl 0x30(%rsp), %eax
cmpl $0x0, %eax
jne 0x4f6d
movzwl 0x10(%rsp), %eax
cmpl $0x0, %eax
jne 0x4f6d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
leaq 0xed04(%rip), %rdx      # 0x13c6a
movb $0x0, %al
callq 0x2b10
movw $0x0, 0x32(%rsp)
movzwl 0x30(%rsp), %eax
cmpl $0x0, %eax
jle 0x4f8c
movw 0x30(%rsp), %ax
addw $-0x1, %ax
movw %ax, 0x30(%rsp)
jmp 0x4f8e
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_addr
static Opp_Obj opp_analize_addr(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	if (node->addr_expr.addr->type == EUNARY 
		&& (node->addr_expr.addr->unary_expr.type == TINTEGER 
			|| node->addr_expr.addr->unary_expr.type == TFLOAT))
		opp_semantics_error(ctx, node, "Got unexpected rhs value in '&'");

	Opp_Obj lhs = opp_analize_expr(ctx, node->addr_expr.addr);
	lhs.depth++;

	return lhs;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, (%rax)
jne 0x4ff2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, 0x10(%rax)
je 0x4fda
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x3, 0x10(%rax)
jne 0x4ff2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xecb9(%rip), %rdx      # 0x13ca4
movb $0x0, %al
callq 0x2b10
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movw 0x20(%rsp), %ax
incw %ax
movw %ax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_logic
static Opp_Obj opp_analize_logic(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	opp_analize_time_eval(ctx, node);

	if (node->type == EUNARY) return opp_analize_unary(ctx, node);

	Opp_Obj lhs = opp_analize_expr(ctx, node->logic_expr.left);
	Opp_Obj rhs = opp_analize_expr(ctx, node->logic_expr.right);

	// Warning different pointer depths compare
	if (lhs.depth != rhs.depth)
		opp_warning(ctx, node, "Preforming compare operation mixing with ptr '%s' '%s'",
			lhs.decl->id, rhs.decl->id);

	// Warn different type pointer compare
	if ((lhs.depth > 0 && rhs.depth > 0) && lhs.decl->t_type != rhs.decl->t_type)
		opp_warning(ctx, node, "Preforming logic on different point types");

	// Mixing struct in compare error
	if ((rhs.decl->t_type == TYPE_STRUCT && rhs.depth == 0) 
		|| 
		(lhs.decl->t_type == TYPE_STRUCT && lhs.depth == 0))
		opp_semantics_error(ctx, node, "Not allowed to mix struct type in logic operation");

	return lhs;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3910
movq 0x18(%rsp), %rax
cmpl $0x5, (%rax)
jne 0x5075
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4b60
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x5167
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x3770
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x3770
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movzwl 0x30(%rsp), %eax
movzwl 0x10(%rsp), %ecx
cmpl %ecx, %eax
je 0x50e5
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq (%rax), %r8
leaq 0xebe6(%rip), %rdx      # 0x13cc4
movb $0x0, %al
callq 0x2e80
movzwl 0x30(%rsp), %eax
cmpl $0x0, %eax
jle 0x5123
movzwl 0x10(%rsp), %eax
cmpl $0x0, %eax
jle 0x5123
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x5123
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0xebdf(%rip), %rdx      # 0x13cfb
movb $0x0, %al
callq 0x2e80
movq 0x8(%rsp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x5138
movzwl 0x10(%rsp), %eax
cmpl $0x0, %eax
je 0x514d
movq 0x28(%rsp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x5165
movzwl 0x30(%rsp), %eax
cmpl $0x0, %eax
jne 0x5165
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0xebc7(%rip), %rdx      # 0x13d25
movb $0x0, %al
callq 0x2b10
jmp 0x5167
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_sub
static Opp_Obj opp_analize_sub(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	opp_analize_time_eval(ctx, node);

	if (node->type == EUNARY)
		return opp_analize_unary(ctx, node);

	assert(false);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3910
movq 0x8(%rsp), %rax
cmpl $0x5, (%rax)
jne 0x51cf
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4b60
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
leaq 0xeb81(%rip), %rdi      # 0x13d57
leaq 0xeb80(%rip), %rsi      # 0x13d5d
movl $0x422, %edx            # imm = 0x422
leaq 0xeb8c(%rip), %rcx      # 0x13d75
callq 0x10e0
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_analize_sizeof
static Opp_Obj opp_analize_sizeof(struct Opp_Analize* ctx, struct Opp_Node* node)
{
	Opp_Obj val = opp_analize_expr(ctx, node->sizeof_expr.expr);

	struct Opp_Debug temp = node->debug;
	memset(node, 0, sizeof(struct Opp_Node));
	node->type = EUNARY;
	node->debug = temp;
	node->unary_expr.type = TINTEGER;
	node->unary_expr.val.i64val = get_type_size(&val);

	val.decl = int_type;
	val.depth = 0;
	val.size = 0;
	val.unsign = 0;

	return val;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3770
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x4(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movl $0x5, (%rax)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl $0x2, 0x10(%rax)
leaq 0x18(%rsp), %rdi
callq 0x52e0
movl %eax, %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
leaq 0x14017(%rip), %rax     # 0x192c0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movw $0x0, 0x20(%rsp)
movw $0x0, 0x22(%rsp)
movb $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: get_type_size
static unsigned int get_type_size(struct Opp_Type_Decl* type)
{
	if (type->depth > 0 && type->size == 0)
		return 8;

	// TODO: IS THIS NEEDED????
	// if (type->size > 0)
	// 	return type->size;

	switch (type->decl->t_type)
	{
		case TYPE_VOID:   return 0;
		case TYPE_I8:     return 1;
		case TYPE_I16:    return 2;
		case TYPE_I32:    return 4;
		case TYPE_I64:    return 8;
		case TYPE_FLOAT:  return 4;
		case TYPE_DOUBLE: return 8;
		case TYPE_STRUCT: return type->decl->size;
		default: break;
	}

	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jle 0x530e
movq -0x10(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x530e
movl $0x8, -0x4(%rsp)
jmp 0x539a
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movq %rax, -0x18(%rsp)
subq $0x8, %rax
ja 0x5390
movq -0x18(%rsp), %rax
leaq 0xe290(%rip), %rcx      # 0x135c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rsp)
jmp 0x539a
movl $0x1, -0x4(%rsp)
jmp 0x539a
movl $0x2, -0x4(%rsp)
jmp 0x539a
movl $0x4, -0x4(%rsp)
jmp 0x539a
movl $0x8, -0x4(%rsp)
jmp 0x539a
movl $0x4, -0x4(%rsp)
jmp 0x539a
movl $0x8, -0x4(%rsp)
jmp 0x539a
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x539a
jmp 0x5392
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_get_plain_size
static unsigned int opp_get_plain_size(struct Opp_Type_Decl* type)
{
	if (type->depth > 0 && type->size == 0)
		return 8;
	
	switch (type->decl->t_type)
	{
		case TYPE_VOID:   return 0;
		case TYPE_I8:     return 1;
		case TYPE_I16:    return 2;
		case TYPE_I32:    return 4;
		case TYPE_I64:    return 8;
		case TYPE_FLOAT:  return 4;
		case TYPE_DOUBLE: return 8;
		case TYPE_STRUCT: return type->decl->l_mem;
		default: break;
	}

	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jle 0x53ce
movq -0x10(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x53ce
movl $0x8, -0x4(%rsp)
jmp 0x545a
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movq %rax, -0x18(%rsp)
subq $0x8, %rax
ja 0x5450
movq -0x18(%rsp), %rax
leaq 0xe1f4(%rip), %rcx      # 0x135e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rsp)
jmp 0x545a
movl $0x1, -0x4(%rsp)
jmp 0x545a
movl $0x2, -0x4(%rsp)
jmp 0x545a
movl $0x4, -0x4(%rsp)
jmp 0x545a
movl $0x8, -0x4(%rsp)
jmp 0x545a
movl $0x4, -0x4(%rsp)
jmp 0x545a
movl $0x8, -0x4(%rsp)
jmp 0x545a
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x545a
jmp 0x5452
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/analysis/analysis.c
// Function: opp_add_to_struct
static void opp_add_to_struct(struct Opp_Analize* ctx, struct Opp_Node* var, unsigned int off)
{
	if (var->var_stmt.var->type != EUNARY)
		opp_semantics_error(ctx, var, "Variables inside struct can only be declared");

	struct Opp_Bucket* bucket = env_get_item(ctx->curr_ns, var->var_stmt.var->unary_expr.val.strval);

	bucket->offset = (int32_t)off;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
cmpl $0x5, (%rax)
je 0x5498
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0xeb1a(%rip), %rdx      # 0x13fab
movb $0x0, %al
callq 0x2b10
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x12c10
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_init_compile
struct Opp_Context* opp_init_compile(struct Opp_Parser* parser, 
									struct Opp_Options* opts)
{
	struct Opp_Context* opp = (struct Opp_Context*)
		malloc(sizeof(struct Opp_Context));

	if (opp == NULL)
		goto err;

	opp->parser = parser;
	opp->opts = opts;
	opp->oppir = NULL;

	// Info
	memset(&opp->info, 0, sizeof(struct Opp_Info));

	// Cond
	memset(&opp->cond_state, 0, sizeof(struct Opp_Cond));

	// Ir
	opp->ir.instr_idx = 0;
	opp->ir.allocated = DEFAULT_OPCODE_SIZE;
	opp->ir.opcodes = (struct OppIr_Opcode*)
		malloc(sizeof(struct OppIr_Opcode)*DEFAULT_OPCODE_SIZE);

	if (opp->ir.opcodes == NULL)
		goto err;

	memset(opp->ir.opcodes, 0, sizeof(struct OppIr_Opcode)*DEFAULT_OPCODE_SIZE);

	// Tables
	// opp->env.global_ns = parser->scope;
	// opp->env.curr_ns = opp->env.global_ns;

	return opp;

err:
	INTERNAL_ERROR("Malloc Fail");
	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x90, %edi
callq 0x1160
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x54fa
jmp 0x55ab
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10f0
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
xorl %esi, %esi
movl $0x24, %edx
callq 0x10f0
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq $0x40, 0x50(%rax)
movl $0xa00, %edi            # imm = 0xA00
callq 0x1160
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x558a
jmp 0x55ab
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
xorl %esi, %esi
movl $0xa00, %edx            # imm = 0xA00
callq 0x10f0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x55c7
leaq 0xe056(%rip), %rdi      # 0x13608
leaq 0xea57(%rip), %rsi      # 0x14010
callq 0x114a0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_realloc_instrs
void opp_realloc_instrs(struct Opp_Context* opp)
{
	if (opp->ir.instr_idx >= opp->ir.allocated) {
		opp->ir.allocated += 64;
		opp->ir.opcodes = (struct OppIr_Opcode*)realloc(opp->ir.opcodes, 
			(opp->ir.allocated) * sizeof(struct OppIr_Opcode));

		if (opp->ir.opcodes == NULL)
			INTERNAL_ERROR("Realloc Fail");
	}
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x48(%rax), %rax
movq (%rsp), %rcx
cmpq 0x50(%rcx), %rax
jb 0x5668
movq (%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x50(%rax)
movq (%rsp), %rax
movq 0x58(%rax), %rdi
movq (%rsp), %rax
imulq $0x28, 0x50(%rax), %rsi
callq 0x1180
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x58(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x5666
leaq 0xe9c7(%rip), %rdi      # 0x14021
leaq 0xe9cd(%rip), %rsi      # 0x1402e
callq 0x114a0
jmp 0x5668
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_type_to_ir
enum OppIr_Const_Type opp_type_to_ir(Opp_Obj* type)
{
	int t = 0;
	if (type->depth > 0 || 
		type->decl->t_type == TYPE_STRUCT ||
		type->size > 0)
		return IMM_U64;

	switch (type->decl->t_type)
	{
		case TYPE_I8:
			t = IMM_I8;
			break;

		case TYPE_I16:    
			t = IMM_I16;
			break;

		case TYPE_I32:    
			t = IMM_I32;
			break;

		case TYPE_I64:    
			t = IMM_I64;
			break;

		case TYPE_FLOAT:  
			t = IMM_F32;
			break;

		case TYPE_DOUBLE: 
			t = IMM_F64;
			break;
			
		default: break;
	}

	if (type->unsign)
		t--;

	return t;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jg 0x56a7
movq -0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x8, 0x8(%rax)
je 0x56a7
movq -0x10(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x0, %eax
jle 0x56b4
movl $0x9, -0x4(%rsp)
jmp 0x573e
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0x5, %eax
ja 0x571e
movq -0x20(%rsp), %rax
leaq 0xe8ff(%rip), %rcx      # 0x13fd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, -0x14(%rsp)
jmp 0x5720
movl $0x6, -0x14(%rsp)
jmp 0x5720
movl $0x8, -0x14(%rsp)
jmp 0x5720
movl $0xa, -0x14(%rsp)
jmp 0x5720
movl $0xb, -0x14(%rsp)
jmp 0x5720
movl $0xc, -0x14(%rsp)
jmp 0x5720
jmp 0x5720
movq -0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
je 0x5736
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_type_to_size
unsigned int opp_type_to_size(Opp_Obj* type)
{
	if (type->depth > 0 && type->size == 0)
		return 8;

	if (type->size > 0)
		return type->size;

	unsigned int size = 0;
	switch (type->decl->t_type)
	{
		case TYPE_I8:
			size = 1;
			break;
		
		case TYPE_I16:
			size = 2;
			break;

		case TYPE_FLOAT:
		case TYPE_I32: 
			size = 4;
			break;

		case TYPE_DOUBLE:
		case TYPE_I64:
			size = 8;
			break;

		case TYPE_STRUCT:
			size = type->decl->size;
			break;

		default: break;
	}
	return size;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jle 0x577e
movq -0x10(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x577e
movl $0x8, -0x4(%rsp)
jmp 0x5814
movq -0x10(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x0, %eax
jle 0x579b
movq -0x10(%rsp), %rax
movzwl 0xa(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x5814
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0x7, %eax
ja 0x580a
movq -0x20(%rsp), %rax
leaq 0xe828(%rip), %rcx      # 0x13ff0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x14(%rsp)
jmp 0x580c
movl $0x2, -0x14(%rsp)
jmp 0x580c
movl $0x4, -0x14(%rsp)
jmp 0x580c
movl $0x8, -0x14(%rsp)
jmp 0x580c
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x580c
jmp 0x580c
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_type_cast
void opp_type_cast(struct Opp_Context* opp, Opp_Obj* lhs, Opp_Obj* rhs)
{
	/* Cast rules
		1) Always cast based on lhs
		Ex: 
			double a;
			int b;
			b = a; # Cast a to int

		2) Only create a cast if
			- Lhs and Rhs are different floating points
			- Lhs and Rhs are different types 
				not including integer types.
	*/
	enum OppIr_Const_Type lt = opp_type_to_ir(lhs);
	enum OppIr_Const_Type rt = opp_type_to_ir(rhs);

	if (
		((lt == IMM_F64 || lt == IMM_F32) && (rt != IMM_F32 && rt != IMM_F64))
		||
		((lt != IMM_F64 && lt != IMM_F32) && (rt == IMM_F64 || rt == IMM_F32))
		||
		((lt == IMM_F64 && rt == IMM_F32) || (lt == IMM_F32 && rt == IMM_F64))
		) 
	{
		printf("CASTING\n");
		OPCODE_START();
			OPCODE_TYPE(OPCODE_CAST);
			opp->ir.opcodes[opp->ir.instr_idx].cast.type = lt;
		OPCODE_END();
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5670
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5670
movl %eax, 0x8(%rsp)
cmpl $0xc, 0xc(%rsp)
je 0x585d
cmpl $0xb, 0xc(%rsp)
jne 0x586b
cmpl $0xb, 0x8(%rsp)
je 0x586b
cmpl $0xc, 0x8(%rsp)
jne 0x58a3
cmpl $0xc, 0xc(%rsp)
je 0x5887
cmpl $0xb, 0xc(%rsp)
je 0x5887
cmpl $0xc, 0x8(%rsp)
je 0x58a3
cmpl $0xb, 0x8(%rsp)
je 0x58a3
cmpl $0xc, 0xc(%rsp)
jne 0x5895
cmpl $0xb, 0x8(%rsp)
je 0x58a3
cmpl $0xb, 0xc(%rsp)
jne 0x5905
cmpl $0xc, 0x8(%rsp)
jne 0x5905
leaq 0xe797(%rip), %rdi      # 0x14041
movb $0x0, %al
callq 0x10c0
movq 0x20(%rsp), %rdi
callq 0x5600
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0xb, (%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_compile
void opp_compile(struct Opp_Context* opp)
{
	for (unsigned int stmt = 0; stmt < opp->parser->nstmts; stmt++) {
		switch (opp->parser->statments[stmt]->type)
		{
			case STMT_FUNC:
				opp_compile_func(opp, opp->parser->statments[stmt]);
				break;

			case STMT_EXTERN:
				opp_compile_extern(opp, opp->parser->statments[stmt]);
				break;

			case STMT_VAR:
				opp_compile_var(opp, opp->parser->statments[stmt]);
				break;

			default: break;
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x18(%rcx), %eax
jae 0x59e1
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
subl $0x13, %eax
je 0x59ad
jmp 0x5957
movl 0x8(%rsp), %eax
subl $0x16, %eax
je 0x596d
jmp 0x5962
movl 0x8(%rsp), %eax
subl $0x18, %eax
je 0x598d
jmp 0x59cd
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x59f0
jmp 0x59cf
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x5b20
jmp 0x59cf
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x7f90
jmp 0x59cf
jmp 0x59cf
jmp 0x59d1
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5921
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_compile_func
static void opp_compile_func(struct Opp_Context* opp, struct Opp_Node* node)
{
	struct Opp_Stmt_Func* func = &node->fn_stmt;

	// Resets
	opp->info.stack_offset = 0;
	opp->info.label_loc    = 1;
	opp->info.ret_type = func->type;

	OPCODE_START();
		OPCODE_TYPE(OPCODE_FUNC);
		opp->ir.opcodes[opp->ir.instr_idx].func.fn_name = func->bidx->key;
		opp->ir.opcodes[opp->ir.instr_idx].func.ext = 0;
	OPCODE_END();

	if (func->body == NULL)
		return;

	opp_compile_args(opp, node);

	opp_compile_stmt(opp, func->body);

	OPCODE_START();
		OPCODE_TYPE(OPCODE_END);
	OPCODE_END();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
callq 0x5600
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0x2, (%rax)
movq (%rsp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movb $0x0, 0x11(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5abe
jmp 0x5b16
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5bf0
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x7e90
movq 0x10(%rsp), %rdi
callq 0x5600
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0x11, (%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_compile_extern
static void opp_compile_extern(struct Opp_Context* opp, struct Opp_Node* node)
{
	assert(node->extrn_stmt.stmt->type == STMT_FUNC);

	OPCODE_START();
		if (node->extrn_stmt.stmt->type == STMT_FUNC) {
			OPCODE_TYPE(OPCODE_FUNC);
			opp->ir.opcodes[opp->ir.instr_idx].func.fn_name = 
				node->extrn_stmt.stmt->fn_stmt.name->unary_expr.val.strval;
			opp->ir.opcodes[opp->ir.instr_idx].func.ext = 1;
		}
	OPCODE_END();

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x16, (%rax)
jne 0x5b3e
jmp 0x5b5d
leaq 0xe505(%rip), %rdi      # 0x1404a
leaq 0xe527(%rip), %rsi      # 0x14073
movl $0x11b, %edx            # imm = 0x11B
leaq 0xe533(%rip), %rcx      # 0x1408b
callq 0x10e0
movq 0x10(%rsp), %rdi
callq 0x5600
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x16, (%rax)
jne 0x5bd6
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0x2, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movb $0x1, 0x11(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compiler.c
// Function: opp_compile_args
static void opp_compile_args(struct Opp_Context* opp, struct Opp_Node* node)
{
	unsigned int Fidx = 0, Iidx = 0;

	for (unsigned int i = 0; i < node->fn_stmt.len; i++)
	{
		OPCODE_START();
			OPCODE_TYPE(OPCODE_ARG);
			opp->ir.opcodes[opp->ir.instr_idx].arg.type = 
				opp_type_to_ir(&node->fn_stmt.args[i].var_stmt.type);

			switch (opp->ir.opcodes[opp->ir.instr_idx].arg.type)
			{
				case IMM_U8...IMM_I64: 
					opp->ir.opcodes[opp->ir.instr_idx].arg.idx = Iidx;
					Iidx++;
					break;

				case IMM_F32...IMM_F64:
					opp->ir.opcodes[opp->ir.instr_idx].arg.idx = Fidx;
					Fidx++;
					break;

				default: break;
			}

		OPCODE_END();

		opp->info.stack_offset -= 8;
		node->fn_stmt.args[i].var_stmt.bidx->offset = opp->info.stack_offset; 
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jae 0x5d55
movq 0x20(%rsp), %rdi
callq 0x5600
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x58(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movl $0x3, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
leaq (%rcx,%rcx,8), %rcx
leaq 0x10(%rax,%rcx,8), %rdi
callq 0x5670
movl %eax, %edx
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x58(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movl %edx, 0x8(%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x58(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movl 0x8(%rax,%rcx,8), %eax
movl %eax, 0x8(%rsp)
addl $-0x3, %eax
subl $0x8, %eax
jb 0x5cad
jmp 0x5c9f
movl 0x8(%rsp), %eax
addl $-0xb, %eax
subl $0x2, %eax
jb 0x5cd7
jmp 0x5d01
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5d03
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5d03
jmp 0x5d03
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x20(%rax)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %edx
imulq $0x48, %rdx, %rdx
addq %rdx, %rax
movq 0x28(%rax), %rax
movl %ecx, 0x28(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5c16
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_expr.c
// Function: opp_compile_expr
Opp_Obj opp_compile_expr(struct Opp_Context* opp, struct Opp_Node* expr)
{
	switch (expr->type)
	{
		case EUNARY:
			return opp_compile_unary(opp, expr);

		case EDOT:
			return opp_compile_dot(opp, expr);

		case EADDR:
			return opp_compile_addr(opp, expr);

		case EDEREF:
			return opp_compile_deref(opp, expr);

		case EBIN:
			return opp_compile_bin(opp, expr);

		case ECALL:
			return opp_compile_call(opp, expr, true);

		case ELOGIC:
			return opp_compile_logic(opp, expr);

		case EELEMENT:
			return opp_compile_elem(opp, expr);

		default: break;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xc, %eax
ja 0x5e80
movq (%rsp), %rax
leaq 0xe33b(%rip), %rcx      # 0x140cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5ea0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x60b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x63e0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6690
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x67f0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x8390
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6a30
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6bb0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x5e82
jmp 0x5e82
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_expr.c
// Function: opp_compile_deref
static Opp_Obj opp_compile_deref(struct Opp_Context* opp, struct Opp_Node* expr)
{
	bool outer = false;
	if (!opp->info.in_deref) {
		outer = true;
		opp->info.in_deref = true;
	}

	Opp_Obj t = opp_compile_expr(opp, expr->deref_expr.deref);

	t.depth--;

	if (!opp->info.need_addr && t.decl->t_type != TYPE_STRUCT) {
		OPCODE_START();
			OPCODE_TYPE(OPCODE_DEREF);
			opp->ir.opcodes[opp->ir.instr_idx].cast.type = opp_type_to_ir(&t);
		OPCODE_END();
	}

	if (!outer && opp->info.need_addr && t.depth != 0) {
		OPCODE_START();
			OPCODE_TYPE(OPCODE_DEREF);
			opp->ir.opcodes[opp->ir.instr_idx].cast.type = opp_type_to_ir(&t);
		OPCODE_END();
	}

	if (outer)
		opp->info.in_deref = false;

	return t;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x41(%rax)
jne 0x66bc
movb $0x1, 0x7(%rsp)
movq 0x10(%rsp), %rax
movb $0x1, 0x41(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5d60
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movw 0x20(%rsp), %ax
addw $-0x1, %ax
movw %ax, 0x20(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x40(%rax)
jne 0x6759
movq 0x18(%rsp), %rax
cmpl $0x8, 0x8(%rax)
je 0x6759
movq 0x10(%rsp), %rdi
callq 0x5600
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0xc, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x5670
movl %eax, %ecx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
testb $0x1, 0x7(%rsp)
jne 0x67d1
movq 0x10(%rsp), %rax
testb $0x1, 0x40(%rax)
je 0x67d1
movzwl 0x20(%rsp), %eax
cmpl $0x0, %eax
je 0x67d1
movq 0x10(%rsp), %rdi
callq 0x5600
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0xc, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x5670
movl %eax, %ecx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
testb $0x1, 0x7(%rsp)
je 0x67e1
movq 0x10(%rsp), %rax
movb $0x0, 0x41(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq