LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_expr.c
// Function: opp_compile_logic
static Opp_Obj opp_compile_logic(struct Opp_Context* opp, struct Opp_Node* logic)
{
	Opp_Obj obj;
	bool in_parent = false;

	if (!opp->cond_state.in_logic) {
		switch (opp->cond_state.cond_type)
		{
			case LOGIC_COND: {
				opp->cond_state.endloc = opp->info.label_loc++;
				opp->cond_state.locs[0] = opp->info.label_loc++; // True
				opp->cond_state.locs[1] = opp->info.label_loc++; // False

				opp->cond_state.use_op = true;
				opp->cond_state.jloc = opp->cond_state.locs[1];
				opp->cond_state.curr_logic = 0;
				opp->cond_state.hs = 0;
				break;
			}

			case IFWHILE_COND: {
				opp->cond_state.use_op = true;
				opp->cond_state.jloc = opp->cond_state.locs[1];
				opp->cond_state.curr_logic = 0;
				opp->cond_state.hs = 0;
				break;
			}

			case SWITCH_COND: { break; }
		}
		opp->cond_state.in_logic = true;
		in_parent = true;
	}

	obj = opp_compile_logic_assign(opp, logic);

	if (in_parent) {
		opp_compile_logic_end(opp, logic);
		opp->cond_state.in_logic = false;
	}

	return obj;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0x6c(%rax)
jne 0x6b55
movq 0x30(%rsp), %rax
movl 0x68(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x6a85
jmp 0x6a64
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x6b09
jmp 0x6a73
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x6b45
jmp 0x6b47
movq 0x30(%rsp), %rax
movl 0x24(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x24(%rax)
movq 0x30(%rsp), %rax
movl %ecx, 0x78(%rax)
movq 0x30(%rsp), %rax
movl 0x24(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x24(%rax)
movq 0x30(%rsp), %rax
movl %ecx, 0x70(%rax)
movq 0x30(%rsp), %rax
movl 0x24(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x24(%rax)
movq 0x30(%rsp), %rax
movl %ecx, 0x74(%rax)
movq 0x30(%rsp), %rax
movb $0x1, 0x80(%rax)
movq 0x30(%rsp), %rax
movl 0x74(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x84(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x7c(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x88(%rax)
jmp 0x6b47
movq 0x30(%rsp), %rax
movb $0x1, 0x80(%rax)
movq 0x30(%rsp), %rax
movl 0x74(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x84(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x7c(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x88(%rax)
jmp 0x6b47
jmp 0x6b47
movq 0x30(%rsp), %rax
movb $0x1, 0x6c(%rax)
movb $0x1, 0x27(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7440
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
testb $0x1, 0x27(%rsp)
je 0x6ba1
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7ba0
movq 0x30(%rsp), %rax
movb $0x0, 0x6c(%rax)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_stmt.c
// Function: opp_compile_stmt
void opp_compile_stmt(struct Opp_Context* opp, struct Opp_Node* node)
{
	switch (node->type)
	{
		case STMT_VAR:
			opp_compile_var(opp, node);
			break;

		case STMT_BLOCK:
			opp_compile_block(opp, node);
			break;

		case EASSIGN:
			opp_compile_assign(opp, node);
			break;

		case ECALL:
			opp_compile_call(opp, node, false);
			break;

		case STMT_RET:
			opp_compile_ret(opp, node);
			break;

		case STMT_IF:
			opp_compile_if(opp, node);
			break;

		case STMT_WHILE:
			opp_compile_while(opp, node);
			break;

		case STMT_BREAK:
			opp_compile_break(opp, node);
			break;

		default: 
			// temp
			opp_compile_expr(opp, node);
		break;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x1a, %eax
ja 0x7f65
movq (%rsp), %rax
leaq 0xc30a(%rip), %rcx      # 0x141cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7f90
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8100
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8160
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x8390
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8760
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x87e0
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8ab0
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8d20
jmp 0x7f7e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x5d60
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_stmt.c
// Function: opp_compile_var
void opp_compile_var(struct Opp_Context* opp, struct Opp_Node* node)
{
	struct Opp_Stmt_Var* var = &node->var_stmt;

	bool assign = var->var->type == EASSIGN ? 1 : 0;
	bool global = var->bidx->type == TYPE_GLOBAL || var->bidx->type == TYPE_EXTERN;
	unsigned int size = opp_type_to_size(&var->type);

	OPCODE_START();
		OPCODE_TYPE(OPCODE_VAR);
		opp->ir.opcodes[opp->ir.instr_idx].var.global = global;
		opp->ir.opcodes[opp->ir.instr_idx].var.size = size;
		opp->ir.opcodes[opp->ir.instr_idx].var.name = var->bidx->key;
	OPCODE_END();

	if (!global) {
		opp->info.stack_offset -= size;
		var->bidx->offset = opp->info.stack_offset;
	}

	if (assign)
		opp_compile_assign(opp, var->var);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x4, %edx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movb $0x1, %al
cmpl $0x0, 0x8(%rcx)
movb %al, 0x7(%rsp)
je 0x7ff9
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x4, 0x8(%rax)
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5750
movl %eax, 0x8(%rsp)
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 $0x5, (%rax)
movb 0xe(%rsp), %cl
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
testb $0x1, 0xe(%rsp)
jne 0x80d7
movl 0x8(%rsp), %edx
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x28(%rax)
testb $0x1, 0xf(%rsp)
je 0x80f1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x8160
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_stmt.c
// Function: opp_compile_ret
static void opp_compile_ret(struct Opp_Context* opp, struct Opp_Node* node)
{
	Opp_Obj ret = opp_compile_expr(opp, node->ret_stmt.value);

	opp_type_cast(opp, &opp->info.ret_type, &ret);

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

// 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 0x5d60
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
leaq 0x8(%rsp), %rdx
callq 0x5820
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 $0x9, (%rax)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_stmt.c
// Function: opp_compile_break
static void opp_compile_break(struct Opp_Context* opp, struct Opp_Node* node)
{
	OPCODE_START();
		OPCODE_TYPE(OPCODE_JMP);
		opp->ir.opcodes[opp->ir.instr_idx].jmp.type = PURE_JMP;
		opp->ir.opcodes[opp->ir.instr_idx].jmp.loc = opp->cond_state.endloc;
	OPCODE_END();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
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 $0x8, (%rax)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x78(%rax), %ecx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0xc(%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/compile_stmt.c
// Function: opp_compile_ptr_assign
static void opp_compile_ptr_assign(struct Opp_Context* opp, struct Opp_Expr_Assign* assign)
{
	NEED_ADDR();
	Opp_Obj lhs = opp_compile_expr(opp, assign->ident);
	REVERT();

	Opp_Obj rhs = opp_compile_expr(opp, assign->val);

	opp_type_cast(opp, &lhs, &rhs);

	OPCODE_START();
		OPCODE_TYPE(OPCODE_PTR_ASSIGN);
		opp->ir.opcodes[opp->ir.instr_idx].cast.type = opp_type_to_ir(&lhs);
	OPCODE_END();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movb $0x1, 0x40(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5d60
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movb $0x0, 0x40(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x5d60
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x5820
movq 0x30(%rsp), %rdi
callq 0x5600
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0xf, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x5670
movl %eax, %ecx
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_stmt.c
// Function: opp_assign_dot
static void opp_assign_dot(struct Opp_Context* opp, struct Opp_Expr_Assign* assign)
{
	NEED_ADDR();
	Opp_Obj lhs = opp_compile_expr(opp, assign->ident);
	REVERT();

	Opp_Obj rhs = opp_compile_expr(opp, assign->val);
	
	opp_type_cast(opp, &lhs, &rhs);

	OPCODE_START();
		if (opp->info.dot.inptr) {
			OPCODE_TYPE(OPCODE_PTR_ASSIGN);
			opp->ir.opcodes[opp->ir.instr_idx].cast.type = opp_type_to_ir(&lhs);
		}
		else {
			OPCODE_TYPE(OPCODE_ASSIGN);
			opp->ir.opcodes[opp->ir.instr_idx].set.loc_type = opp_type_to_ir(&lhs);
			opp->ir.opcodes[opp->ir.instr_idx].set.val.type = IMM_I32;
			opp->ir.opcodes[opp->ir.instr_idx].set.val.imm_i32 = 
				(int32_t)opp->info.dot.offset;
		}
	OPCODE_END();		
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movb $0x1, 0x40(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5d60
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movb $0x0, 0x40(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x5d60
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x5820
movq 0x30(%rsp), %rdi
callq 0x5600
movq 0x30(%rsp), %rax
testb $0x1, 0x3c(%rax)
je 0x8f46
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0xf, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x5670
movl %eax, %ecx
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0x8fc5
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0x10, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x5670
movl %eax, %ecx
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0x8, 0x8(%rax)
movq 0x30(%rsp), %rax
movl 0x38(%rax), %ecx
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x30(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/compiler/compile_stmt.c
// Function: opp_compile_inifite
static void opp_compile_inifite(struct Opp_Context* opp, struct Opp_Node* node)
{ // might not work with break
	unsigned int start = opp->info.label_loc++;

	OPCODE_START();
		OPCODE_TYPE(OPCODE_LABEL);
		opp->ir.opcodes[opp->ir.instr_idx].constant.val.imm_i32 = start;
	OPCODE_END();

	opp_compile_stmt(opp, node->while_stmt.then);

	OPCODE_START();
		OPCODE_TYPE(OPCODE_JMP);
		opp->ir.opcodes[opp->ir.instr_idx].jmp.type = PURE_JMP;
		opp->ir.opcodes[opp->ir.instr_idx].jmp.loc = start;
	OPCODE_END();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movl 0x24(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x24(%rcx)
movl %eax, 0x4(%rsp)
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 $0xa, (%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%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 $0x8, (%rax)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x28, 0x48(%rcx), %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdx
imulq $0x28, 0x48(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_free
void oppir_free(struct OppIr* ir)
{
	free(ir->code.bytes);
	free(ir->data_seg.data);
	free(ir->offsets.offset_table);
	free(ir->offsets.jmp_table);
	free(ir->regalloc.spills);
	free(ir->reg_stack.stack);
	free(ir);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: dump_bytes
void dump_bytes(struct OppIr* ir, OppIO* io)
{
	if (io == NULL) {
		for (size_t i = 0; i < ir->code.idx; i++) { 
			if ((i+1) % 16 == 0) printf("\n");
			else printf("%X ", ir->code.bytes[i]);
		}
		printf("\n");
	}
	else {
		fwrite(ir->code.bytes, sizeof(unsigned char), ir->code.idx, io->file);
		fclose(io->file);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x943d
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x942d
movq (%rsp), %rax
addq $0x1, %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x93ff
leaq 0xbe55(%rip), %rdi      # 0x1524b
movb $0x0, %al
callq 0x10c0
jmp 0x941d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0xafed(%rip), %rdi      # 0x14403
movb $0x0, %al
callq 0x10c0
jmp 0x941f
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x93ce
leaq 0xbe17(%rip), %rdi      # 0x1524b
movb $0x0, %al
callq 0x10c0
jmp 0x946f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x1200
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1080
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval
void oppir_eval(struct OppIr* ir)
{
	#ifdef LINUX64
		init_strtab();
		init_elf_syms();
		init_reloc();
	#endif

	for (size_t index = 0; index < ir->instr->instr_idx; index++)
		oppir_eval_opcode(ir, &ir->instr->opcodes[index]);

	#ifdef LINUX64
		init_elf_header(DEFAULT_SECT);
		init_text_sect(ir);
		init_data_sect(ir);
		init_symtab_sect();
		init_shstrtab_sect();
		init_strtab_sect();
		init_rela_text_sect();
		elf_offsets(ir);
	#endif

	// dump_data(ir);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, %al
callq 0xd730
movb $0x0, %al
callq 0xd7f0
movb $0x0, %al
callq 0xd790
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x58(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x951a
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rsi
imulq $0x28, 0x8(%rsp), %rax
addq %rax, %rsi
callq 0x9570
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x94d7
movl $0x7, %edi
movb $0x0, %al
callq 0xd8c0
movq 0x10(%rsp), %rdi
callq 0xd9c0
movq 0x10(%rsp), %rdi
callq 0xdaa0
movb $0x0, %al
callq 0xdc30
movb $0x0, %al
callq 0xdba0
movb $0x0, %al
callq 0xdcd0
movb $0x0, %al
callq 0xdd70
movq 0x10(%rsp), %rdi
callq 0xde10
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_opcode
void oppir_eval_opcode(struct OppIr* ir, struct OppIr_Opcode* op) 
{
	switch (op->type)
	{
		case OPCODE_CONST:
			oppir_eval_const(ir, &op->constant);
			break;
		
		case OPCODE_ASSIGN:
			oppir_eval_set(ir, &op->set);
			break;

		case OPCODE_FUNC:
			oppir_eval_func(ir, &op->func);
			break;

		case OPCODE_ARG:
			oppir_eval_arg(ir, &op->arg);
			break;

		case OPCODE_END:
			oppir_eval_end(ir);
			break;

		case OPCODE_CAST:
			oppir_eval_cast(ir, &op->cast);
			break;

		case OPCODE_ADDR:
			oppir_eval_addr(ir, &op->constant);
			break;

		case OPCODE_DEREF:
			oppir_eval_deref(ir, &op->cast);
			break;

		case OPCODE_PTR_ASSIGN:
			oppir_eval_ptr_assign(ir, &op->cast);
			break;

		case OPCODE_CALL:
			oppir_eval_call(ir, &op->call);
			break;

		case OPCODE_MOV_ARG:
			oppir_eval_mov_arg(ir, &op->arg);
			break;

		case OPCODE_LABEL:
			oppir_eval_label(ir, &op->constant);
			break;

		case OPCODE_JMP:
			oppir_eval_jmp(ir, &op->jmp);
			break;

		case OPCODE_CMP:
			oppir_eval_cmp(ir, &op->cmp);
			break;

		case OPCODE_VAR:
			oppir_eval_var(ir, &op->var);
			break;

		case OPCODE_RET:
			oppir_eval_ret(ir);
			break;

		case OPCODE_ARITH:
			oppir_eval_arith(ir, &op->arith);
			break;

		default: break;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq %rax, (%rsp)
subq $0x11, %rax
ja 0x9718
movq (%rsp), %rax
leaq 0xad2a(%rip), %rcx      # 0x142c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x9880
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x9ae0
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x9b60
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x9c50
jmp 0x971a
movq 0x10(%rsp), %rdi
callq 0x9ee0
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x9fe0
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xa070
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xa190
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xa5a0
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xa7e0
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xaa60
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xad10
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xad70
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xafd0
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xb130
jmp 0x971a
movq 0x10(%rsp), %rdi
callq 0xb1d0
jmp 0x971a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0xb390
jmp 0x971a
jmp 0x971a
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_check_realloc
void oppir_check_realloc(struct OppIr* ir, unsigned int bytes)
{
	if ((ir->code.idx + bytes) >= ir->code.allocated) {

		ir->code.bytes = (unsigned char*)
				realloc(ir->code.bytes, (64+ir->code.allocated));

		if (ir->code.bytes == NULL)
			INTERNAL_ERROR("Malloc Fail");

		ir->code.allocated += 64;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x97cc
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
addq $0x40, %rsi
callq 0x1180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x97bb
leaq 0x9e59(%rip), %rdi      # 0x13608
leaq 0xac51(%rip), %rsi      # 0x14407
callq 0x114a0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_check_data
void oppir_check_data(struct OppIr* ir, unsigned int bytes)
{
	if ((ir->data_seg.idx + bytes) >= ir->data_seg.allocated) {

		ir->data_seg.data = (unsigned char*)
				realloc(ir->data_seg.data, (64+ir->data_seg.allocated));

		if (ir->data_seg.data == NULL)
			INTERNAL_ERROR("Malloc Fail");

		ir->data_seg.allocated += 64;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rax
movl 0xc(%rsp), %ecx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jb 0x9877
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
addq $0x40, %rsi
callq 0x1180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x9860
leaq 0x9db4(%rip), %rdi      # 0x13608
leaq 0xabc0(%rip), %rsi      # 0x1441b
callq 0x114a0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x80(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_set
static void oppir_eval_set(struct OppIr* ir, struct OppIr_Set* set)
{
	if (set->global) {
		struct OppIr_Cast c = {.type = set->loc_type};
		oppir_eval_ptr_assign(ir, &c);
		return;
	}

	struct Register reg_type = oppir_pop_reg(ir);
	bool small = set->val.imm_i32 > -128;

	oppir_save_reg(ir, reg_type.reg, set);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x14(%rax)
je 0x9b16
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0xa5a0
jmp 0x9b4f
movq 0x20(%rsp), %rdi
callq 0xc780
movq %rax, 0x4(%rsp)
movq %rdx, 0xc(%rsp)
movq 0x18(%rsp), %rax
cmpl $-0x80, 0x8(%rax)
setg %al
andb $0x1, %al
movb %al, 0x3(%rsp)
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xc4b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_func
static void oppir_eval_func(struct OppIr* ir, struct OppIr_Func* fn)
{
	if (fn->ext) {
		make_extern(fn->fn_name);
		return;
	}

	oppir_check_realloc(ir, 11);

	// Reset local func info
	ir->local_stack.size = 0;
	ir->local_stack.pos = 0;
	ir->offsets.jmp_idx = 0;
	ir->regalloc.amount = 0;
	ir->reg_stack.top = ir->reg_stack.stack;

	for (unsigned int i = 0; i < ir->regalloc.allocated; i++) {
		ir->regalloc.spills[i].made = 0;
		ir->regalloc.spills[i].use = 0;
	}

	#ifdef LINUX64
	make_fn_sym(fn->fn_name, ir->code.idx);
	#endif

	oppir_emit_frame(ir);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x9(%rax)
je 0x9b8b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xd350
jmp 0x9c44
movq 0x10(%rsp), %rdi
movl $0xb, %esi
callq 0x9750
movq 0x10(%rsp), %rax
movl $0x0, 0x48(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x4c(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x68(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x9c24
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
movb $0x0, 0x1(%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
movb $0x0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x9be5
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xd430
movq 0x10(%rsp), %rdi
callq 0xc920
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_end
static void oppir_eval_end(struct OppIr* ir)
{
	struct OppIr_Value stack_size = {
		.type = IMM_I32,
		.imm_i32 = ir->local_stack.size
	};

	size_t temp = ir->code.idx;
	ir->code.idx = ir->local_stack.frame_ptr;

	while ((stack_size.imm_i32 % 16) != 0)
		stack_size.imm_i32 += 1;

	oppir_write_const(ir, &stack_size);

	ir->code.idx = temp;

	struct OppIr_Const ret = { .val.imm_i32 = 0 };
	oppir_eval_label(ir, &ret);

	IR_EMIT(0xc9); 
	IR_EMIT(0xc3);

	oppir_set_offsets(ir);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x8, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x28(%rsp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x9f3b
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x9f1d
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xbfe0
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0xa481(%rip), %rax      # 0x143e0
movq %rax, (%rsp)
movq 0xa47e(%rip), %rax      # 0x143e8
movq %rax, 0x8(%rsp)
movq 0xa47a(%rip), %rax      # 0x143f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0xad10
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0x37, (%rax,%rcx)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0x3d, (%rax,%rcx)
movq 0x30(%rsp), %rdi
callq 0xca50
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_cast
static void oppir_eval_cast(struct OppIr* ir, struct OppIr_Cast* cast)
{
	struct Register reg = oppir_pop_reg(ir);

	switch (cast->type)
	{
		case IMM_F32:
			oppir_cast_to_f32(ir, reg.reg);
			break;

		case IMM_F64:
			oppir_cast_to_f64(ir, reg.reg);
			break;

		default:
			assert(false);
			break;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc780
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0xb, %eax
je 0xa01f
jmp 0xa014
movl 0x4(%rsp), %eax
subl $0xc, %eax
je 0xa02f
jmp 0xa03f
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0xcb40
jmp 0xa05e
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0xcd00
jmp 0xa05e
leaq 0x9d11(%rip), %rdi      # 0x13d57
leaq 0xa43d(%rip), %rsi      # 0x1448a
movl $0x3a1, %edx            # imm = 0x3A1
leaq 0xa43d(%rip), %rcx      # 0x14496
callq 0x10e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_addr
static void oppir_eval_addr(struct OppIr* ir, struct OppIr_Const* addr)
{
	enum Regs reg = oppir_push_reg(ir, IMM_U64);

	oppir_check_realloc(ir, 7);

	bool small = addr->val.imm_i32 > -128;
	if (small)
		addr->val.type = IMM_I8;
	else
		addr->val.type = IMM_I32;

	IR_EMIT(0x48);
	IR_EMIT(0x8d);

	if (small)
		IR_EMIT(0x45 + (reg*8));
	else 
		IR_EMIT(0x85 + (reg*8));

	oppir_write_const(ir, &addr->val);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x9, %esi
callq 0xb8b0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x7, %esi
callq 0x9750
movq 0x8(%rsp), %rax
cmpl $-0x80, 0x8(%rax)
setg %al
andb $0x1, %al
movb %al, 0x3(%rsp)
testb $0x1, 0x3(%rsp)
je 0xa0c6
movq 0x8(%rsp), %rax
movl $0x4, (%rax)
jmp 0xa0d1
movq 0x8(%rsp), %rax
movl $0x8, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0x48, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0x73, (%rax,%rcx)
testb $0x1, 0x3(%rsp)
je 0xa145
movl 0x4(%rsp), %eax
shll $0x3, %eax
addl $0x45, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xa172
movl 0x4(%rsp), %eax
shll $0x3, %eax
addl $0x85, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xbfe0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_cmp
static void oppir_eval_cmp(struct OppIr* ir, struct OppIr_Cmp* cmp)
{
	struct Register rhs = oppir_pop_reg(ir);
	BLOCK_REG(rhs.reg);
	struct Register lhs = oppir_pop_reg(ir);
	UNBLOCK_REG(rhs.reg);

	oppir_check_realloc(ir, 3);
	// add floating and unsigned compares
	
	IR_EMIT(0x48); IR_EMIT(0x39);

	switch (lhs.reg)
	{
		case REG_RAX:
			IR_EMIT(0xc0 + (rhs.reg*8));
			break;

		case REG_RCX:
			IR_EMIT(0xc1 + (rhs.reg*8));
			break;

		case REG_RDX:
			IR_EMIT(0xc2 + (rhs.reg*8));
			break;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc780
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x28(%rsp), %eax
shlq $0x4, %rax
leaq 0xe15f(%rip), %rcx      # 0x19160
movq %rcx, 0x8(%rsp)
movb $0x1, 0xc(%rax,%rcx)
movq 0x40(%rsp), %rdi
callq 0xc780
movq 0x8(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x28(%rsp), %eax
shlq $0x4, %rax
movb $0x0, 0xc(%rax,%rcx)
movq 0x40(%rsp), %rdi
movl $0x3, %esi
callq 0x9750
movq 0x40(%rsp), %rdx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
incq %rsi
movq %rsi, 0x8(%rdx)
movb $0x48, (%rax,%rcx)
movq 0x40(%rsp), %rdx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
incq %rsi
movq %rsi, 0x8(%rdx)
movb $0x39, (%rax,%rcx)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0xb09b
jmp 0xb082
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0xb0ca
jmp 0xb08d
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0xb0f9
jmp 0xb126
movl 0x28(%rsp), %eax
shll $0x3, %eax
addl $0xc0, %eax
movb %al, %dl
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xb126
movl 0x28(%rsp), %eax
shll $0x3, %eax
addl $0xc1, %eax
movb %al, %dl
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xb126
movl 0x28(%rsp), %eax
shll $0x3, %eax
addl $0xc2, %eax
movb %al, %dl
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_var
static void oppir_eval_var(struct OppIr* ir, struct OppIr_Var* var)
{
	if (var->global) {
		make_global_sym(var->name, ir->data_seg.idx, 0);
		oppir_check_data(ir, var->size);
		ir->data_seg.idx += var->size;
	}
	else {
		ir->local_stack.size += var->size;
		ir->local_stack.pos -= var->size;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xb195
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rsi
xorl %edx, %edx
callq 0xd510
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x97e0
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
jmp 0xb1bd
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x10(%rsp), %rax
addl 0x48(%rax), %ecx
movl %ecx, 0x48(%rax)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
movq 0x10(%rsp), %rax
movl 0x4c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4c(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_ret
static void oppir_eval_ret(struct OppIr* ir)
{
	struct Register reg = oppir_pop_reg(ir);

	if (reg.reg != REG_RAX && reg.reg != REG_XMM0) {

		switch (reg.reg)
		{
			case REG_RCX:
			case REG_RDX:
				oppir_check_realloc(ir, 3);
				IR_EMIT(0x48);
				IR_EMIT(0x89);
				IR_EMIT(0xc0 + (reg.reg*8));
				break;

			default:
				oppir_check_realloc(ir, 4);
				if (reg.type == IMM_F32)
					IR_EMIT(0xf3);
				else
					IR_EMIT(0xf2);
				IR_EMIT(0x0f);
				IR_EMIT(0x10);
				IR_EMIT(0xc1 + (reg.reg-4));
				break;
		}
	}

	struct OppIr_Jmp jmp = {
		.type = PURE_JMP,
		.loc = 0
	};

	oppir_eval_jmp(ir, &jmp);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc780
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0xb35c
cmpl $0x3, 0x10(%rsp)
je 0xb35c
movl 0x10(%rsp), %eax
decl %eax
subl $0x1, %eax
ja 0xb295
jmp 0xb214
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x9750
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0x48, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0x77, (%rax,%rcx)
movl 0x10(%rsp), %eax
shll $0x3, %eax
addl $0xc0, %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xb35a
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x9750
cmpl $0xb, 0x14(%rsp)
jne 0xb2cd
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0xd, (%rax,%rcx)
jmp 0xb2ed
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0xe, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0xf, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0x10, (%rax,%rcx)
movl 0x10(%rsp), %eax
subl $0x4, %eax
addl $0xc1, %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xb35c
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10f0
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xad70
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_push_reg
static enum Regs oppir_push_reg(struct OppIr* ir, enum OppIr_Const_Type type)
{
	int i = (type == IMM_F32 || type == IMM_F64) ? 3 : 0;
	const int max = (i == 3) ? 6 : 3;

	for (i; i < max; i++) {
		if (!regs[i].used) {
			regs[i].used = 1;
			oppir_check_regstack(ir);
			ir->reg_stack.top->reg = regs[i].reg;
			ir->reg_stack.top->type = type;
			ir->reg_stack.top->used = 1;
			ir->reg_stack.top->loc = 0; 
			ir->reg_stack.top->spilled = 0;
			ir->reg_stack.top++;
			return regs[i].reg;
		}
	}

	return oppir_reg_alloc(ir);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movb $0x1, %al
cmpl $0xb, 0x14(%rsp)
movb %al, 0xb(%rsp)
je 0xb8d6
cmpl $0xc, 0x14(%rsp)
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %dl
xorl %eax, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edx
movl $0x3, %eax
movl $0x6, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xb9e7
movslq 0x10(%rsp), %rcx
leaq 0xd843(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
testb $0x1, 0xc(%rax)
jne 0xb9d5
movslq 0x10(%rsp), %rcx
leaq 0xd826(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0xc(%rax)
movq 0x18(%rsp), %rdi
callq 0xc190
movslq 0x10(%rsp), %rcx
leaq 0xd805(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movb $0x1, 0xc(%rax)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movl $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movb $0x0, 0xd(%rax)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x40(%rax)
movslq 0x10(%rsp), %rcx
leaq 0xd79a(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xb9f5
jmp 0xb9d7
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xb903
movq 0x18(%rsp), %rdi
callq 0xc210
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_sym
static void oppir_eval_sym(struct OppIr* ir, enum Regs reg, struct OppIr_Const* imm)
{
	oppir_check_realloc(ir, 3);
	IR_EMIT(0x48); IR_EMIT(0x8b);
	IR_EMIT(0x05 + (reg*8));
	
	make_reloc(ir->code.idx, imm->val.imm_sym, 9);
	imm->val.type = IMM_I32;
	imm->val.imm_i32 = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x9750
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0x48, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0x75, (%rax,%rcx)
movl 0xc(%rsp), %eax
shll $0x3, %eax
addl $0x5, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, %edi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movl $0x9, %edx
callq 0xd620
movq (%rsp), %rax
movl $0x8, (%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_eval_float
static void oppir_eval_float(struct OppIr* ir, enum Regs reg, struct OppIr_Const* imm)
{
	oppir_check_realloc(ir, 8);

	unsigned int len = 0;
	union {
		unsigned char l[8];
		float f32;
		double f64;
	} data;

	if (imm->val.type == IMM_F64) {
		IR_EMIT(0xf2);
		data.f64 = imm->val.imm_f64;
		len = 7;
	}
	else {
		IR_EMIT(0xf3);
		data.f32 = (float)imm->val.imm_f64;
		len = 3;
	}

	IR_EMIT(0x0f); IR_EMIT(0x10);
	IR_EMIT(0x05 + (reg-3));

	oppir_gen_label();
	make_global_sym((char*)a_label, ir->data_seg.idx, 0);
	make_reloc(ir->code.idx, (char*)a_label, 2);
	oppir_write_data(ir, len, (unsigned char*)data.l);

	imm->val.type = IMM_I32;
	imm->val.imm_i32 = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x9750
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xc, (%rax)
jne 0xbb3c
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0xe, (%rax,%rcx)
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movl $0x7, 0xc(%rsp)
jmp 0xbb77
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $-0xd, (%rax,%rcx)
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
movl $0x3, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0xf, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb $0x10, (%rax,%rcx)
movl 0x1c(%rsp), %eax
subl $0x3, %eax
addl $0x5, %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
callq 0xc750
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rsi
leaq 0xd60e(%rip), %rdi      # 0x19208
xorl %edx, %edx
callq 0xd510
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, %edi
leaq 0xd5f5(%rip), %rsi      # 0x19208
movl $0x2, %edx
callq 0xd620
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rsp, %rdx
callq 0xbf60
movq 0x10(%rsp), %rax
movl $0x8, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_write_const
static void oppir_write_const(struct OppIr* ir, struct OppIr_Value* imm)
{
	switch (imm->type)
	{
		case IMM_U64:
		case IMM_I64: 
		{
			oppir_check_realloc(ir, 8); 
			ir->code.bytes[ir->code.idx++] = imm->imm_i64 & 0xFF;
			for (int i = 8; i <= 56; i += 8) 
				ir->code.bytes[ir->code.idx++] = (imm->imm_i64 >> i) & 0xFF;
			break;
		}

		case IMM_I32: {
			oppir_check_realloc(ir, 4); 
			ir->code.bytes[ir->code.idx++] = imm->imm_i32 & 0xFF;
			for (int i = 8; i <= 24; i += 8) 
				ir->code.bytes[ir->code.idx++] = (imm->imm_i32 >> i) & 0xFF;
			break;
		}

		case IMM_I8: {
			oppir_check_realloc(ir, 1);
			ir->code.bytes[ir->code.idx++] = imm->imm_i8;
			break;
		}

		default: break;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x4, %eax
je 0xc14b
jmp 0xc004
movl 0xc(%rsp), %eax
subl $0x8, %eax
je 0xc0bc
jmp 0xc013
movl 0xc(%rsp), %eax
addl $-0x9, %eax
subl $0x1, %eax
ja 0xc183
jmp 0xc025
movq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x9750
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
andq $0xff, %rax
movb %al, %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movl $0x8, 0x14(%rsp)
cmpl $0x38, 0x14(%rsp)
jg 0xc0b7
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rsp), %ecx
sarq %cl, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0xc06c
jmp 0xc185
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x9750
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movl $0x8, 0x10(%rsp)
cmpl $0x18, 0x10(%rsp)
jg 0xc149
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl 0x10(%rsp), %ecx
sarl %cl, %eax
andl $0xff, %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x10(%rsp)
jmp 0xc101
jmp 0xc185
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x9750
movq 0x18(%rsp), %rax
movb 0x8(%rax), %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xc185
jmp 0xc185
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_check_regstack
static void oppir_check_regstack(struct OppIr* ir)
{
	if (ir->reg_stack.top >= (ir->reg_stack.stack + ir->reg_stack.allocated)) {
		ir->reg_stack.stack = (struct Register*)
				realloc(ir->reg_stack.stack, (16+ir->reg_stack.allocated));

		if (ir->reg_stack.stack == NULL)
			INTERNAL_ERROR("Malloc fail");

		ir->reg_stack.allocated += 16;
	}
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x40(%rax), %rax
movq (%rsp), %rcx
movq 0x38(%rcx), %rcx
movq (%rsp), %rdx
movq 0x30(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0xc20b
movq (%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rsp), %rax
movq 0x30(%rax), %rsi
addq $0x10, %rsi
callq 0x1180
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xc1fb
leaq 0x6e38(%rip), %rdi      # 0x13027
leaq 0x8236(%rip), %rsi      # 0x1442c
callq 0x114a0
movq (%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x30(%rax)
popq %rax
retq
nopl (%rax)