LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_reg_alloc
static enum Regs oppir_reg_alloc(struct OppIr* ir)
{
	struct Register spill_reg = {0};
	struct OppIr_Set set;

	for (struct Register* i = ir->reg_stack.stack; i < ir->reg_stack.top; i++) {
		if (i->used && !i->spilled) {
			i->spilled = 1;
			i->loc = oppir_get_spill(ir);
			spill_reg.loc = i->loc;
			spill_reg.reg = i->reg;
			spill_reg.type = i->type;

			oppir_check_regstack(ir);
			ir->reg_stack.top->reg = i->reg;
			ir->reg_stack.top->used = 1;
			ir->reg_stack.top->loc = 0;
			ir->reg_stack.top->spilled = 0;
			ir->reg_stack.top->type = i->type;
			ir->reg_stack.top++;
			break;
		}
	}

	if (spill_reg.type != IMM_F64 && spill_reg.type != IMM_F32)
		spill_reg.type = IMM_U64;

	set.val.type = IMM_I32;
	set.val.imm_i32 = spill_reg.loc;
	set.loc_type = spill_reg.type;

	oppir_save_reg(ir, spill_reg.reg, &set);

	return spill_reg.reg;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0xc31f
movq (%rsp), %rax
testb $0x1, 0xc(%rax)
je 0xc30c
movq (%rsp), %rax
testb $0x1, 0xd(%rax)
jne 0xc30c
movq (%rsp), %rax
movb $0x1, 0xd(%rax)
movq 0x30(%rsp), %rdi
callq 0xc370
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, 0x20(%rsp)
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc190
movq (%rsp), %rax
movl (%rax), %ecx
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movb $0x1, 0xc(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movl $0x0, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movb $0x0, 0xd(%rax)
movq (%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movl %ecx, 0x4(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x40(%rax)
jmp 0xc31f
jmp 0xc30e
movq (%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
jmp 0xc237
cmpl $0xc, 0x24(%rsp)
je 0xc335
cmpl $0xb, 0x24(%rsp)
je 0xc335
movl $0x9, 0x24(%rsp)
movl $0x8, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0xc4b0
movl 0x20(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_get_spill
static int32_t oppir_get_spill(struct OppIr* ir)
{
	for (unsigned int i = 0; i < ir->regalloc.allocated; i++) {
		if (!ir->regalloc.spills[i].use && ir->regalloc.spills[i].made) {
			ir->regalloc.spills[i].use = 1;
			return ir->regalloc.spills[i].loc;
		}
	}

	if (ir->regalloc.amount == ir->regalloc.allocated)
		INTERNAL_ERROR("OppIR spill limit met");

	ir->local_stack.size += 8;
	ir->local_stack.pos -= 8;
	
	ir->regalloc.spills[ir->regalloc.amount].loc = ir->local_stack.pos;
	ir->regalloc.spills[ir->regalloc.amount].use = 1;
	ir->regalloc.spills[ir->regalloc.amount].made = 1;
	ir->regalloc.amount++;

	return ir->local_stack.pos;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0xc3f1
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
testb $0x1, (%rax,%rcx,8)
jne 0xc3e2
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
testb $0x1, 0x1(%rax,%rcx,8)
je 0xc3e2
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
movb $0x1, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, 0x14(%rsp)
jmp 0xc49c
jmp 0xc3e4
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc381
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xc418
leaq 0x8035(%rip), %rdi      # 0x14441
leaq 0x8044(%rip), %rsi      # 0x14457
callq 0x114a0
movq 0x8(%rsp), %rax
movl 0x48(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x48(%rax)
movq 0x8(%rsp), %rax
movl 0x4c(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x4c(%rax)
movq 0x8(%rsp), %rax
movl 0x4c(%rax), %edx
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movl %edx, 0x4(%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movb $0x1, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movb $0x1, 0x1(%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl 0x4c(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
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_pop_reg
static struct Register oppir_pop_reg(struct OppIr* ir)
{
	struct Register pop_reg = {0};
	ir->reg_stack.top--;

	if (ir->reg_stack.top < ir->reg_stack.stack || !ir->reg_stack.top->used)
		printf("Error reg_stack pop overflow\n");

	if (ir->reg_stack.top->spilled) {
		ir->reg_stack.top->used = 0;
		ir->reg_stack.top->spilled = 0;
		struct OppIr_Const val = {
			.loc_type = ir->reg_stack.top->type,
			.val.type = IMM_LOC,
			.val.imm_i32 = ir->reg_stack.top->loc
		};
		
		oppir_eval_const(ir, &val);
		pop_reg = oppir_pop_reg(ir);

		for (unsigned int i = 0; i < ir->regalloc.allocated; i++) {
			if (ir->regalloc.spills[i].loc == ir->reg_stack.top->loc) {
				ir->regalloc.spills[i].use = 0;
				break;
			}
		}
	}
	else {
		ir->reg_stack.top->used = 0;
		pop_reg = *ir->reg_stack.top;
		regs[pop_reg.reg].used = 0;
	}

	return pop_reg;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x40(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jb 0xc7ce
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0xc(%rax)
jne 0xc7dc
leaq 0x7c97(%rip), %rdi      # 0x1446c
movb $0x0, %al
callq 0x10c0
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0xd(%rax)
je 0xc8c7
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movb $0x0, 0xc(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movb $0x0, 0xd(%rax)
movl $0x2, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0x28(%rsp)
movb $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9880
movq 0x30(%rsp), %rdi
callq 0xc780
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0xc8c5
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
movl 0x4(%rax,%rcx,8), %eax
movq 0x30(%rsp), %rcx
movq 0x40(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jne 0xc8b6
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x4(%rsp), %ecx
movb $0x0, (%rax,%rcx,8)
jmp 0xc8c5
jmp 0xc8b8
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc875
jmp 0xc906
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movb $0x0, 0xc(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movl 0x38(%rsp), %eax
movl %eax, %ecx
leaq 0xc865(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0xc(%rax)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_emit_frame
static void oppir_emit_frame(struct OppIr* ir) 
{
	struct OppIr_Value frame = {
		.type = IMM_I32,
		.imm_i32 = 0x00000000
	};

	IR_EMIT(0x55); IR_EMIT(0x48); 
	IR_EMIT(0x89); IR_EMIT(0xe5);

	IR_EMIT(0x48); IR_EMIT(0x81); IR_EMIT(0xec);
	ir->local_stack.frame_ptr = ir->code.idx;

	oppir_write_const(ir, &frame);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x7cc0(%rip), %rax      # 0x145f0
movq %rax, (%rsp)
movq 0x7cbd(%rip), %rax      # 0x145f8
movq %rax, 0x8(%rsp)
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 $0x55, (%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 $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 $-0x77, (%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 $-0x1b, (%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 $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 $-0x7f, (%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 $-0x14, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x10(%rsp), %rdi
movq %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_set_offsets
static void oppir_set_offsets(struct OppIr* ir)
{
	struct OppIr_Value val = {
		.type = IMM_I32,
		.imm_i32 = 0
	};

	for (unsigned int i = 0; i < ir->offsets.jmp_idx; i++) {
		size_t temp = ir->code.idx;

		int32_t jmp_loc = ir->offsets.offset_table[ir->offsets.jmp_table[i].table_pos] 
			- (ir->offsets.jmp_table[i].loc + 4);

		ir->code.idx = ir->offsets.jmp_table[i].loc;
		val.imm_i32 = jmp_loc;
		oppir_write_const(ir, &val);

		ir->code.idx = temp;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x7b90(%rip), %rax      # 0x145f0
movq %rax, 0x20(%rsp)
movq 0x7b8c(%rip), %rax      # 0x145f8
movq %rax, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x68(%rcx), %eax
jae 0xcb34
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x70(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x78(%rcx), %rcx
movl 0x1c(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
movslq (%rax,%rcx,4), %rax
movq 0x30(%rsp), %rcx
movq 0x78(%rcx), %rcx
movl 0x1c(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
addq $0x4, %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x78(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xbfe0
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xca79
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_cast_to_f32
static void oppir_cast_to_f32(struct OppIr* ir, enum Regs reg)
{
	enum Regs new_reg = oppir_push_reg(ir, IMM_F32);
	switch (reg)
	{
		case REG_RAX...REG_RDX:
			oppir_check_realloc(ir, 5);

			IR_EMIT(0xf3); IR_EMIT(0x48);
			IR_EMIT(0x0f); IR_EMIT(0x2a);
			IR_EMIT((0xc0 + ((new_reg-3)*8)) + reg);
			break;

		case REG_XMM0...REG_XMM2:
			oppir_check_realloc(ir, 4);

			IR_EMIT(0xf2); IR_EMIT(0x0f);
			IR_EMIT(0x5a);
			IR_EMIT(0xc0 + ((new_reg-3)*8) + (reg-3));
			break;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0xb, %esi
callq 0xb8b0
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x3, %eax
jb 0xcb84
jmp 0xcb6f
movl 0x4(%rsp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0xcc4c
jmp 0xccf4
movq 0x10(%rsp), %rdi
movl $0x5, %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 $-0xd, (%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 $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 $0xf, (%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 $0x2a, (%rax,%rcx)
movl 0x8(%rsp), %eax
subl $0x3, %eax
shll $0x3, %eax
addl $0xc0, %eax
addl 0xc(%rsp), %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 0xccf4
movq 0x10(%rsp), %rdi
movl $0x4, %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 $-0xe, (%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 $0xf, (%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 $0x5a, (%rax,%rcx)
movl 0x8(%rsp), %eax
subl $0x3, %eax
shll $0x3, %eax
addl $0xc0, %eax
movl 0xc(%rsp), %ecx
subl $0x3, %ecx
addl %ecx, %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)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_cast_to_f64
static void oppir_cast_to_f64(struct OppIr* ir, enum Regs reg)
{
	enum Regs new_reg = oppir_push_reg(ir, IMM_F64);
	switch (reg)
	{
		case REG_RAX...REG_RDX:
			oppir_check_realloc(ir, 5);

			IR_EMIT(0xf2); IR_EMIT(0x48);
			IR_EMIT(0x0f); IR_EMIT(0x2a);

			IR_EMIT((0xc0 + ((new_reg-3)*8)) + (reg));
			break;

		case REG_XMM0...REG_XMM2:
			oppir_check_realloc(ir, 4);

			IR_EMIT(0xf3); IR_EMIT(0x0f);
			IR_EMIT(0x5a);
			IR_EMIT(0xc0 + ((new_reg-3)*8) + (reg-3));
			break;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0xc, %esi
callq 0xb8b0
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x3, %eax
jb 0xcd44
jmp 0xcd2f
movl 0x4(%rsp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0xce0c
jmp 0xceb4
movq 0x10(%rsp), %rdi
movl $0x5, %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 $-0xe, (%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 $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 $0xf, (%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 $0x2a, (%rax,%rcx)
movl 0x8(%rsp), %eax
subl $0x3, %eax
shll $0x3, %eax
addl $0xc0, %eax
addl 0xc(%rsp), %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 0xceb4
movq 0x10(%rsp), %rdi
movl $0x4, %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 $-0xd, (%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 $0xf, (%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 $0x5a, (%rax,%rcx)
movl 0x8(%rsp), %eax
subl $0x3, %eax
shll $0x3, %eax
addl $0xc0, %eax
movl 0xc(%rsp), %ecx
subl $0x3, %ecx
addl %ecx, %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)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_emit_reg_comb
static void oppir_emit_reg_comb(struct OppIr* ir, enum Regs lhs, enum Regs rhs)
{
	switch (lhs)
	{
		case REG_RAX: IR_EMIT(0xc0 + (rhs*8)); break;
		case REG_RCX: IR_EMIT(0xc1 + (rhs*8)); break;
		case REG_RDX: IR_EMIT(0xc2 + (rhs*8)); break;
		default: break;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x14(%rsp)
testl %eax, %eax
je 0xcf04
jmp 0xceeb
movl -0x14(%rsp), %eax
subl $0x1, %eax
je 0xcf33
jmp 0xcef6
movl -0x14(%rsp), %eax
subl $0x2, %eax
je 0xcf62
jmp 0xcf91
movl -0x10(%rsp), %eax
shll $0x3, %eax
addl $0xc0, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xcf93
movl -0x10(%rsp), %eax
shll $0x3, %eax
addl $0xc1, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xcf93
movl -0x10(%rsp), %eax
shll $0x3, %eax
addl $0xc2, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xcf93
jmp 0xcf93
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_push
static void oppir_push(struct OppIr* ir, struct Register reg)
{
	if (regs[reg.reg].used == 0) {
		regs[reg.reg].used = 1;
		oppir_check_regstack(ir);
		*ir->reg_stack.top = reg;
		ir->reg_stack.top->used = 1;
		ir->reg_stack.top->loc = 0;
		ir->reg_stack.top->spilled = 0;
		ir->reg_stack.top++;
	}
	else
		printf("Internal error oppir_push\n"), exit(1);
}

// Assembly:
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, (%rsp)
movl 0x8(%rsp), %eax
movl %eax, %ecx
leaq 0xc1a1(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd046
movl 0x8(%rsp), %eax
movl %eax, %ecx
leaq 0xc180(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0xc(%rax)
movq (%rsp), %rdi
callq 0xc190
movq (%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rax
movb $0x1, 0xc(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rax
movb $0x0, 0xd(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x40(%rax)
jmp 0xd05e
leaq 0x74c8(%rip), %rdi      # 0x14515
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x11f0
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_spill_all
static void oppir_spill_all(struct OppIr* ir)
{
	for (struct Register* i = ir->reg_stack.stack; i < ir->reg_stack.top; i++) {
		if (i->used && !i->spilled) {
			struct Register spill_reg = {0};
			struct OppIr_Set set;
			i->spilled = 1;
			i->loc = oppir_get_spill(ir);
			spill_reg.loc = i->loc;
			spill_reg.reg = i->reg;
			spill_reg.type = i->type;

			if (spill_reg.type != IMM_F64 && spill_reg.type != IMM_F32)
				spill_reg.type = IMM_U64;

			regs[spill_reg.reg].used = false;

			set.val.type = IMM_I32;
			set.val.imm_i32 = spill_reg.loc;
			set.loc_type = spill_reg.type;

			oppir_save_reg(ir, spill_reg.reg, &set);
		}
	}

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0xd175
movq 0x28(%rsp), %rax
testb $0x1, 0xc(%rax)
je 0xd160
movq 0x28(%rsp), %rax
testb $0x1, 0xd(%rax)
jne 0xd160
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
movq 0x28(%rsp), %rax
movb $0x1, 0xd(%rax)
movq 0x30(%rsp), %rdi
callq 0xc370
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0xc, 0x1c(%rsp)
je 0xd120
cmpl $0xb, 0x1c(%rsp)
je 0xd120
movl $0x9, 0x1c(%rsp)
movl 0x18(%rsp), %eax
movl %eax, %ecx
leaq 0xc033(%rip), %rax      # 0x19160
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0xc(%rax)
movl $0x8, (%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %esi
movq %rsp, %rdx
callq 0xc4b0
jmp 0xd162
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
jmp 0xd087
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: dump_data
void dump_data(struct OppIr* ir)
{
	printf("Data Dump\n");
	printf("A: %ld S: %ld\n", ir->data_seg.allocated, ir->data_seg.idx);
	for (unsigned int i = 0; i < ir->data_seg.idx; i++) {
		if ((i+1) % 16 == 0) printf("\n");
		else printf("%d ", ir->data_seg.data[i]);
	}
	printf("\n");

	printf("Reloc Dump\n");
	printf("A: %ld S: %u\n", elf_info.r_allocated, elf_info.r_idx);
	printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x7440(%rip), %rdi      # 0x14600
movb $0x0, %al
callq 0x10c0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdx
leaq 0x7425(%rip), %rdi      # 0x1460b
movb $0x0, %al
callq 0x10c0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpq 0x88(%rcx), %rax
jae 0xd257
movl 0xc(%rsp), %eax
addl $0x1, %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0xd226
leaq 0x802e(%rip), %rdi      # 0x1524b
movb $0x0, %al
callq 0x10c0
jmp 0xd248
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %esi
leaq 0x7fdd(%rip), %rdi      # 0x1521e
movb $0x0, %al
callq 0x10c0
jmp 0xd24a
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd1f5
leaq 0x7fed(%rip), %rdi      # 0x1524b
movb $0x0, %al
callq 0x10c0
leaq 0x73ae(%rip), %rdi      # 0x1461a
movb $0x0, %al
callq 0x10c0
movq 0xc02e(%rip), %rsi      # 0x192a8
movl 0xc020(%rip), %edx      # 0x192a0
leaq 0x739f(%rip), %rdi      # 0x14626
movb $0x0, %al
callq 0x10c0
leaq 0x7fb6(%rip), %rdi      # 0x1524b
movb $0x0, %al
callq 0x10c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: strtable_write
void strtable_write(unsigned int len, char* bytes)
{
	if ((elf_info.strtable.str_idx + (len+2)) >= elf_info.strtable.allocated) {
		printf("REALLOC STRTABLE\n");
	}
	elf_info.strtable.str[elf_info.strtable.str_idx++] = 0x0;
	for (unsigned int i = 0; i < len; i++)
		elf_info.strtable.str[elf_info.strtable.str_idx++] = bytes[i];
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movl 0xbfb5(%rip), %eax      # 0x19278
movl 0x14(%rsp), %ecx
addl $0x2, %ecx
addl %ecx, %eax
movl %eax, %eax
cmpq 0xbf93(%rip), %rax      # 0x19268
jb 0xd2e5
leaq 0x7356(%rip), %rdi      # 0x14634
movb $0x0, %al
callq 0x10c0
movq 0xbf84(%rip), %rax      # 0x19270
movl 0xbf86(%rip), %ecx      # 0x19278
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xbf7b(%rip)      # 0x19278
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0xd34b
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0xbf48(%rip), %rax      # 0x19270
movl 0xbf4a(%rip), %ecx      # 0x19278
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xbf3f(%rip)      # 0x19278
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd30b
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: make_extern
void make_extern(char* sym_name)
{
	assert(elf_info.symbols.sym_idx != elf_info.symbols.allocated);
	struct Elf64_Symbol* sym = &elf_info.symbols.pairs[elf_info.symbols.sym_idx].syms;
	elf_info.symbols.pairs[elf_info.symbols.sym_idx].name = sym_name;
	sym->st_name = elf_info.strtable.str_idx + 1;
	sym->st_value = 0;
	sym->st_size = 0;
	sym->st_info = 16;
	sym->st_other = 0;
	sym->st_shndx = 0;
	strtable_write(strlen(sym_name), sym_name);
	elf_info.symbols.sym_idx++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl 0xbf31(%rip), %eax      # 0x19290
cmpq 0xbf1a(%rip), %rax      # 0x19280
je 0xd36a
jmp 0xd389
leaq 0x72d5(%rip), %rdi      # 0x14646
leaq 0x7305(%rip), %rsi      # 0x1467d
movl $0x60, %edx
leaq 0x730b(%rip), %rcx      # 0x1468f
callq 0x10e0
movq 0xbef8(%rip), %rax      # 0x19288
movl 0xbefa(%rip), %ecx      # 0x19290
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0xbeda(%rip), %rax      # 0x19288
movl 0xbedc(%rip), %edx      # 0x19290
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl 0xbeb3(%rip), %ecx      # 0x19278
addl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $0x10, 0x4(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x5(%rax)
movq 0x8(%rsp), %rax
movw $0x0, 0x6(%rax)
movq 0x10(%rsp), %rdi
callq 0x1090
movl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0xd2b0
movl 0xbe6e(%rip), %eax      # 0x19290
addl $0x1, %eax
movl %eax, 0xbe65(%rip)      # 0x19290
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: make_fn_sym
void make_fn_sym(char* fname, size_t start)
{
	assert(elf_info.symbols.sym_idx != elf_info.symbols.allocated);
	struct Elf64_Symbol* sym = &elf_info.symbols.pairs[elf_info.symbols.sym_idx].syms;
	elf_info.symbols.pairs[elf_info.symbols.sym_idx].name = fname;
	sym->st_name = elf_info.strtable.str_idx + 1;
	sym->st_value = start;
	sym->st_size = 0;
	sym->st_info = 16;
	sym->st_other = 0;
	sym->st_shndx = 1;
	strtable_write(strlen(fname), fname);
	elf_info.symbols.sym_idx++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0xbe4c(%rip), %eax      # 0x19290
cmpq 0xbe35(%rip), %rax      # 0x19280
je 0xd44f
jmp 0xd46e
leaq 0x71f0(%rip), %rdi      # 0x14646
leaq 0x7220(%rip), %rsi      # 0x1467d
movl $0x6f, %edx
leaq 0x723f(%rip), %rcx      # 0x146a8
callq 0x10e0
movq 0xbe13(%rip), %rax      # 0x19288
movl 0xbe15(%rip), %ecx      # 0x19290
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq 0xbdf6(%rip), %rax      # 0x19288
movl 0xbdf8(%rip), %edx      # 0x19290
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl 0xbdcf(%rip), %ecx      # 0x19278
addl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movb $0x10, 0x4(%rax)
movq (%rsp), %rax
movb $0x0, 0x5(%rax)
movq (%rsp), %rax
movw $0x1, 0x6(%rax)
movq 0x10(%rsp), %rdi
callq 0x1090
movl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0xd2b0
movl 0xbd8f(%rip), %eax      # 0x19290
addl $0x1, %eax
movl %eax, 0xbd86(%rip)      # 0x19290
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: make_global_sym
void make_global_sym(char* name, size_t loc, bool local)
{
	assert(elf_info.symbols.sym_idx != elf_info.symbols.allocated);
	struct Elf64_Symbol* sym = &elf_info.symbols.pairs[elf_info.symbols.sym_idx].syms;
	elf_info.symbols.pairs[elf_info.symbols.sym_idx].name = name;
	sym->st_name = elf_info.strtable.str_idx + 1;
	sym->st_value = loc;
	sym->st_size = 0;
	sym->st_info = local == 1 ? 1 : 16;
	sym->st_other = 0;
	sym->st_shndx = 2;
	strtable_write(strlen(name), name);
	elf_info.symbols.sym_idx++;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movl 0xbd64(%rip), %eax      # 0x19290
cmpq 0xbd4d(%rip), %rax      # 0x19280
je 0xd537
jmp 0xd556
leaq 0x7108(%rip), %rdi      # 0x14646
leaq 0x7138(%rip), %rsi      # 0x1467d
movl $0x7e, %edx
leaq 0x7178(%rip), %rcx      # 0x146c9
callq 0x10e0
movq 0xbd2b(%rip), %rax      # 0x19288
movl 0xbd2d(%rip), %ecx      # 0x19290
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0xbd0d(%rip), %rax      # 0x19288
movl 0xbd0f(%rip), %edx      # 0x19290
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl 0xbce6(%rip), %ecx      # 0x19278
addl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
movl $0x10, %eax
movl $0x1, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x5(%rax)
movq 0x8(%rsp), %rax
movw $0x2, 0x6(%rax)
movq 0x20(%rsp), %rdi
callq 0x1090
movl %eax, %edi
movq 0x20(%rsp), %rsi
callq 0xd2b0
movl 0xbc86(%rip), %eax      # 0x19290
addl $0x1, %eax
movl %eax, 0xbc7d(%rip)      # 0x19290
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: make_reloc
void make_reloc(unsigned int off, char* sym, int type)
{
	assert(elf_info.r_idx != elf_info.r_allocated);
	struct Elf64_Reloc* r = &elf_info.relocs[elf_info.r_idx];
	uint64_t loc = 0;

	for (unsigned int i = 2; i < elf_info.symbols.sym_idx; i++) {
		if (!strcmp(elf_info.symbols.pairs[i].name, sym))
			loc = i;
	}
	r->r_offset = off;
	r->r_info = ELF64_R_INFO(loc, type);
	r->r_addend = -4;

	elf_info.r_idx++;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl 0xbc69(%rip), %eax      # 0x192a0
cmpq 0xbc6a(%rip), %rax      # 0x192a8
je 0xd642
jmp 0xd661
leaq 0x70ac(%rip), %rdi      # 0x146f5
leaq 0x702d(%rip), %rsi      # 0x1467d
movl $0x8d, %edx
leaq 0x70c0(%rip), %rcx      # 0x1471c
callq 0x10e0
movq 0xbc30(%rip), %rax      # 0x19298
movl 0xbc32(%rip), %ecx      # 0x192a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x2, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0xbbfb(%rip), %eax      # 0x19290
jae 0xd6d4
movq 0xbbea(%rip), %rax      # 0x19288
movl 0xc(%rsp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0xd6c5
movl 0xc(%rsp), %eax
movq %rax, 0x10(%rsp)
jmp 0xd6c7
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd68b
movl 0x34(%rsp), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
shlq $0x20, %rcx
movslq 0x24(%rsp), %rax
movabsq $0xffffffff, %rdx       # imm = 0xFFFFFFFF
andq %rdx, %rax
addq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq $-0x4, 0x10(%rax)
movl 0xbb84(%rip), %eax      # 0x192a0
addl $0x1, %eax
movl %eax, 0xbb7b(%rip)      # 0x192a0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_strtab
void init_strtab()
{
	elf_info.strtable.str = (unsigned char*)malloc(STRTAB_SIZE);

	if (elf_info.strtable.str == NULL)
		INTERNAL_ERROR("Malloc fail");

	elf_info.strtable.allocated = STRTAB_SIZE;
	elf_info.strtable.str_idx = 0;
	memset(elf_info.strtable.str, 0, STRTAB_SIZE);
}

// Assembly:
pushq %rax
movl $0x80, %edi
callq 0x1160
movq %rax, 0xbb2e(%rip)      # 0x19270
cmpq $0x0, 0xbb26(%rip)      # 0x19270
jne 0xd75f
leaq 0x58d4(%rip), %rdi      # 0x13027
leaq 0x6fed(%rip), %rsi      # 0x14747
callq 0x114a0
movq $0x80, 0xbafe(%rip) # 0x19268
movl $0x0, 0xbb04(%rip)      # 0x19278
movq 0xbaf5(%rip), %rdi      # 0x19270
xorl %esi, %esi
movl $0x80, %edx
callq 0x10f0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_reloc
void init_reloc()
{
	elf_info.relocs = (struct Elf64_Reloc*)
		malloc(sizeof(struct Elf64_Reloc)*DEFAULT_SYMS);

	if (elf_info.relocs == NULL)
		INTERNAL_ERROR("Malloc fail");

	elf_info.r_idx = 0;
	elf_info.r_allocated = DEFAULT_SYMS;
	memset(elf_info.relocs, 0, sizeof(struct Elf64_Reloc)*DEFAULT_SYMS);
}

// Assembly:
pushq %rax
movl $0x180, %edi            # imm = 0x180
callq 0x1160
movq %rax, 0xbaf6(%rip)      # 0x19298
cmpq $0x0, 0xbaee(%rip)      # 0x19298
jne 0xd7bf
leaq 0x5874(%rip), %rdi      # 0x13027
leaq 0x6f99(%rip), %rsi      # 0x14753
callq 0x114a0
movl $0x0, 0xbad7(%rip)      # 0x192a0
movq $0x10, 0xbad4(%rip) # 0x192a8
movq 0xbabd(%rip), %rdi      # 0x19298
xorl %esi, %esi
movl $0x180, %edx            # imm = 0x180
callq 0x10f0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_elf_syms
void init_elf_syms()
{
	elf_info.symbols.pairs = (struct Elf_Pair*)
		malloc(sizeof(struct Elf_Pair)*DEFAULT_SYMS);

	if (elf_info.symbols.pairs == NULL)
		INTERNAL_ERROR("Malloc fail");

	elf_info.symbols.allocated = DEFAULT_SYMS;
	elf_info.symbols.sym_idx = 0;
	memset(elf_info.symbols.pairs, 0, sizeof(struct Elf_Pair)*DEFAULT_SYMS);

	struct Elf64_Symbol* sym = &elf_info.symbols.pairs[1].syms;
	elf_info.symbols.pairs[1].name = NULL;
	strtable_write(strlen("test.opp"), "test.opp");

	// ABS fname
	sym->st_name = 1;
	sym->st_value = 0;
	sym->st_size = 0;
	sym->st_info = 4;
	sym->st_other = 0;
	sym->st_shndx = 65521;
	elf_info.symbols.sym_idx = 2;
}

// Assembly:
pushq %rax
movl $0x200, %edi            # imm = 0x200
callq 0x1160
movq %rax, 0xba86(%rip)      # 0x19288
cmpq $0x0, 0xba7e(%rip)      # 0x19288
jne 0xd81f
leaq 0x5814(%rip), %rdi      # 0x13027
leaq 0x6f44(%rip), %rsi      # 0x1475e
callq 0x114a0
movq $0x10, 0xba56(%rip) # 0x19280
movl $0x0, 0xba5c(%rip)      # 0x19290
movq 0xba4d(%rip), %rdi      # 0x19288
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x10f0
movq 0xba3a(%rip), %rax      # 0x19288
addq $0x20, %rax
movq %rax, (%rsp)
movq 0xba2b(%rip), %rax      # 0x19288
movq $0x0, 0x38(%rax)
movl $0x8, %edi
leaq 0x6efb(%rip), %rsi      # 0x1476c
callq 0xd2b0
movq (%rsp), %rax
movl $0x1, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movb $0x4, 0x4(%rax)
movq (%rsp), %rax
movb $0x0, 0x5(%rax)
movq (%rsp), %rax
movw $0xfff1, 0x6(%rax)      # imm = 0xFFF1
movl $0x2, 0xb9d4(%rip)      # 0x19290
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_elf_header
void init_elf_header()
{
	elf_info.sect_list = (struct Elf64_SHDR*)
		malloc(sizeof(struct Elf64_SHDR)*DEFAULT_SECT);
 	
	if (elf_info.sect_list == NULL)
		INTERNAL_ERROR("Malloc fail");

	elf_info.sect_amount = DEFAULT_SECT;

	elf_info.elf64_hdr.e_ident[0] = EI_MAG0;
	elf_info.elf64_hdr.e_ident[1] = EI_MAG1;
	elf_info.elf64_hdr.e_ident[2] = EI_MAG2;
	elf_info.elf64_hdr.e_ident[3] = EI_MAG3;
	elf_info.elf64_hdr.e_ident[4] = ELFCLASS64;
	elf_info.elf64_hdr.e_ident[5] = ELFDATA2LSB;
	elf_info.elf64_hdr.e_ident[6] = EV_CURRENT;
	elf_info.elf64_hdr.e_ident[7] = ELFOSABI_NONE;
	elf_info.elf64_hdr.e_ident[8] = 0x0;

	elf_info.elf64_hdr.e_type = ET_REL;
	elf_info.elf64_hdr.e_machine = EM_X86_64;
	elf_info.elf64_hdr.e_version = EV_CURRENT;
	elf_info.elf64_hdr.e_entry = DEFAULT_ENTRY;
	elf_info.elf64_hdr.e_phoff = 0x0;
	elf_info.elf64_hdr.e_shoff = 64;
	elf_info.elf64_hdr.e_flags = 0x0;
	elf_info.elf64_hdr.e_ehsize = sizeof(elf_info.elf64_hdr);
	elf_info.elf64_hdr.e_phentsize = 0x0;
	elf_info.elf64_hdr.e_phnum = 0x0;
	elf_info.elf64_hdr.e_shentsize = 64;
	elf_info.elf64_hdr.e_shnum = DEFAULT_SECT;
	elf_info.elf64_hdr.e_shstrndx = 5;
}

// Assembly:
pushq %rax
movl $0x1c0, %edi            # imm = 0x1C0
callq 0x1160
movq %rax, 0xb98e(%rip)      # 0x19260
cmpq $0x0, 0xb986(%rip)      # 0x19260
jne 0xd8ef
leaq 0x5744(%rip), %rdi      # 0x13027
leaq 0x6e8b(%rip), %rsi      # 0x14775
callq 0x114a0
movl $0x7, 0xb91f(%rip)      # 0x19218
movb $0x7f, 0xb920(%rip)     # 0x19220
movb $0x45, 0xb91a(%rip)     # 0x19221
movb $0x4c, 0xb914(%rip)     # 0x19222
movb $0x46, 0xb90e(%rip)     # 0x19223
movb $0x2, 0xb908(%rip)      # 0x19224
movb $0x1, 0xb902(%rip)      # 0x19225
movb $0x1, 0xb8fc(%rip)      # 0x19226
movb $0x0, 0xb8f6(%rip)      # 0x19227
movb $0x0, 0xb8f0(%rip)      # 0x19228
movw $0x1, 0xb8ef(%rip)      # 0x19230
movw $0x3e, 0xb8e8(%rip)     # 0x19232
movl $0x1, 0xb8e0(%rip)      # 0x19234
movq $0x0, 0xb8d9(%rip) # 0x19238
movq $0x0, 0xb8d6(%rip) # 0x19240
movq $0x40, 0xb8d3(%rip) # 0x19248
movl $0x0, 0xb8d1(%rip)      # 0x19250
movw $0x40, 0xb8cc(%rip)     # 0x19254
movw $0x0, 0xb8c5(%rip)      # 0x19256
movw $0x0, 0xb8be(%rip)      # 0x19258
movw $0x40, 0xb8b7(%rip)     # 0x1925a
movw $0x7, 0xb8b0(%rip)      # 0x1925c
movw $0x5, 0xb8a9(%rip)      # 0x1925e
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_text_sect
void init_text_sect(struct OppIr* ir)
{
	struct Elf64_SHDR* sect = &elf_info.sect_list[SECT_TEXT];
	sect->sh_name = 1;
	sect->sh_type = SHT_PROGBITS;
	sect->sh_flags = 0x6;
	sect->sh_addr = 0x0;
	sect->sh_offset = 0x0;
	sect->sh_size = ir->code.idx;
	sect->sh_link = 0;
	sect->sh_info = 0;
	sect->sh_addralign = 0x8;
	sect->sh_entsize = 0;

	while (ir->code.idx % 8 != 0) {
		oppir_check_realloc(ir, 1);
		IR_EMIT(0x0);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0xb890(%rip), %rax      # 0x19260
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x8(%rsp), %rax
movq $0x6, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x8(%rsp), %rax
movq $0x8, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0xda9b
movq 0x10(%rsp), %rdi
movl $0x1, %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 $0x0, (%rax,%rcx)
jmp 0xda57
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_data_sect
void init_data_sect(struct OppIr* ir)
{
	struct Elf64_SHDR* sect = &elf_info.sect_list[SECT_DATA];
	sect->sh_name = 7;
	sect->sh_type = SHT_PROGBITS;
	sect->sh_flags = 3;
	sect->sh_addr = 0x0;
	sect->sh_offset = 0x0;
	sect->sh_size = ir->data_seg.idx;
	sect->sh_link = 0;
	sect->sh_info = 0;
	sect->sh_addralign = 8;
	sect->sh_entsize = 0;

	while (ir->data_seg.idx % 8 != 0) {
		oppir_check_data(ir, 1);
		ir->data_seg.data[ir->data_seg.idx++] = 0;
		break;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0xb7b0(%rip), %rax      # 0x19260
addq $0x40, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x7, (%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x8(%rsp), %rax
movq $0x3, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x8(%rsp), %rax
movq $0x8, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0xdb8d
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x97e0
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x88(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x88(%rdx)
movb $0x0, (%rax,%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_shstrtab_sect
void init_shstrtab_sect()
{
	struct Elf64_SHDR* sect = &elf_info.sect_list[SECT_SHSTRTAB];
	sect->sh_name = 13;
	sect->sh_type = 3;
	sect->sh_flags = 0;
	sect->sh_addr = 0x0;
	sect->sh_offset = 0x0;
	sect->sh_size = sizeof(shstrtab);
	sect->sh_link = 0;
	sect->sh_info = 0;
	sect->sh_addralign = 1;
	sect->sh_entsize = 0;
}

// Assembly:
movq 0xb6b9(%rip), %rax      # 0x19260
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0xd, (%rax)
movq -0x8(%rsp), %rax
movl $0x3, 0x4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x32, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rsp), %rax
movq $0x1, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_symtab_sect
void init_symtab_sect()
{
	struct Elf64_SHDR* sect = &elf_info.sect_list[SECT_SYMTAB];
	sect->sh_name = 23;
	sect->sh_type = 2;
	sect->sh_flags = 0;
	sect->sh_addr = 0x0;
	sect->sh_offset = 0x0;
	sect->sh_size = sizeof(struct Elf64_Symbol)*elf_info.symbols.sym_idx;
	sect->sh_link = 6;
	sect->sh_info = 2; 
	sect->sh_addralign = 4;
	sect->sh_entsize = sizeof(struct Elf64_Symbol);
}

// Assembly:
movq 0xb629(%rip), %rax      # 0x19260
addq $0x80, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x17, (%rax)
movq -0x8(%rsp), %rax
movl $0x2, 0x4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movl 0xb60a(%rip), %eax      # 0x19290
imulq $0x18, %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x6, 0x28(%rax)
movq -0x8(%rsp), %rax
movl $0x2, 0x2c(%rax)
movq -0x8(%rsp), %rax
movq $0x4, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x18, 0x38(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_strtab_sect
void init_strtab_sect()
{
	struct Elf64_SHDR* sect = &elf_info.sect_list[SECT_STRTAB];
	sect->sh_name = 31;
	sect->sh_type = 3;
	sect->sh_flags = 0;
	sect->sh_addr = 0x0;
	sect->sh_offset = 0x0;
	sect->sh_size = elf_info.strtable.str_idx;
	sect->sh_link = 0; 
	sect->sh_info = 0;
	sect->sh_addralign = 1;
	sect->sh_entsize = 0;
}

// Assembly:
movq 0xb589(%rip), %rax      # 0x19260
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x1f, (%rax)
movq -0x8(%rsp), %rax
movl $0x3, 0x4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movl 0xb552(%rip), %eax      # 0x19278
movl %eax, %ecx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rsp), %rax
movq $0x1, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: init_rela_text_sect
void init_rela_text_sect()
{
	struct Elf64_SHDR* sect = &elf_info.sect_list[SECT_RELA_TEXT];
	sect->sh_name = 39;
	sect->sh_type = 4;
	sect->sh_flags = 0;
	sect->sh_addr = 0x0;
	sect->sh_offset = 0x0;
	sect->sh_size = sizeof(struct Elf64_Reloc)*elf_info.r_idx;
	sect->sh_link = 3; 
	sect->sh_info = 1;
	sect->sh_addralign = 4;
	sect->sh_entsize = 24;
}

// Assembly:
movq 0xb4e9(%rip), %rax      # 0x19260
addq $0xc0, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x27, (%rax)
movq -0x8(%rsp), %rax
movl $0x4, 0x4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movl 0xb4da(%rip), %eax      # 0x192a0
imulq $0x18, %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x3, 0x28(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rsp), %rax
movq $0x4, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x18, 0x38(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: elf_offsets
void elf_offsets(struct OppIr* ir)
{
	unsigned int offset = 
		sizeof(struct Elf64_Header) + 
		(sizeof(struct Elf64_SHDR) * elf_info.sect_amount);

	// Text / Data
	elf_info.sect_list[SECT_TEXT].sh_offset = offset;
	offset += elf_info.sect_list[SECT_TEXT].sh_size + 
		(ir->code.idx - elf_info.sect_list[SECT_TEXT].sh_size);

	elf_info.sect_list[SECT_DATA].sh_offset = offset;
	offset += elf_info.sect_list[SECT_DATA].sh_size +
		(ir->data_seg.idx - elf_info.sect_list[SECT_DATA].sh_size);
	// do data

	for (int i = 2; i < elf_info.sect_amount-1; i++) {
		elf_info.sect_list[i].sh_offset = offset;
		offset += elf_info.sect_list[i].sh_size;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movslq 0xb3fc(%rip), %rax      # 0x19218
shlq $0x6, %rax
addq $0x40, %rax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
movq 0xb42b(%rip), %rax      # 0x19260
movq %rcx, 0x18(%rax)
movq 0xb420(%rip), %rax      # 0x19260
movq 0x20(%rax), %rcx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xb40c(%rip), %rdx      # 0x19260
subq 0x20(%rdx), %rax
addq %rax, %rcx
movl -0xc(%rsp), %eax
addq %rcx, %rax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
movq 0xb3ed(%rip), %rax      # 0x19260
movq %rcx, 0x58(%rax)
movq 0xb3e2(%rip), %rax      # 0x19260
movq 0x60(%rax), %rcx
movq -0x8(%rsp), %rax
movq 0x88(%rax), %rax
movq 0xb3cb(%rip), %rdx      # 0x19260
subq 0x60(%rdx), %rax
addq %rax, %rcx
movl -0xc(%rsp), %eax
addq %rcx, %rax
movl %eax, -0xc(%rsp)
movl $0x2, -0x10(%rsp)
movl -0x10(%rsp), %eax
movl 0xb35f(%rip), %ecx      # 0x19218
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xdf0c
movl -0xc(%rsp), %eax
movl %eax, %ecx
movq 0xb393(%rip), %rax      # 0x19260
movslq -0x10(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq 0xb37c(%rip), %rax      # 0x19260
movslq -0x10(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rcx
movl -0xc(%rsp), %eax
addq %rcx, %rax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xdeaf
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/memory/memory.c
// Function: allocator_init
bool allocator_init()
{
    root = (struct Allocator*)malloc(sizeof(struct Allocator));
    if (root == NULL) 
    	return false;

    root->first = block_init();

    if (root->first == NULL)
    	return false;

    root->current = root->first;
    root->used_mem = 0;

    return true;
}

// Assembly:
pushq %rax
movl $0x18, %edi
callq 0x1160
movq %rax, 0xb18e(%rip)      # 0x192b0
cmpq $0x0, 0xb186(%rip)      # 0x192b0
jne 0xe133
movb $0x0, 0x7(%rsp)
jmp 0xe184
callq 0xe380
movq %rax, %rcx
movq 0xb16e(%rip), %rax      # 0x192b0
movq %rcx, 0x8(%rax)
movq 0xb163(%rip), %rax      # 0x192b0
cmpq $0x0, 0x8(%rax)
jne 0xe15b
movb $0x0, 0x7(%rsp)
jmp 0xe184
movq 0xb14e(%rip), %rax      # 0x192b0
movq 0x8(%rax), %rcx
movq 0xb143(%rip), %rax      # 0x192b0
movq %rcx, 0x10(%rax)
movq 0xb138(%rip), %rax      # 0x192b0
movq $0x0, (%rax)
movb $0x1, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopl (%rax)