LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/ir/ir.c
// Function: oppir_save_reg
static void oppir_save_reg(struct OppIr* ir, enum Regs reg_type, struct OppIr_Set* set)
{
	bool small = set->val.imm_i32 > -128;

	if (small)
		set->val.type = IMM_I8;

	oppir_check_realloc(ir, 3);
	switch (set->loc_type)
	{
		case IMM_I8:
		case IMM_U8:
			IR_EMIT(0x88);
			break;

		case IMM_I16:
		case IMM_U16:
			IR_EMIT(0x66);
			IR_EMIT(0x89);
			break;

		case IMM_I32:
		case IMM_U32:
			IR_EMIT(0x89);
			break;

		case IMM_I64:
		case IMM_U64:
			IR_EMIT(0x48);
			IR_EMIT(0x89);
			break;

		case IMM_F32:
			IR_EMIT(0xf3);
			IR_EMIT(0x0f);
			IR_EMIT(0x11);
			reg_type -= 3;
			break;

		case IMM_F64:
			IR_EMIT(0xf2);
			IR_EMIT(0x0f);
			IR_EMIT(0x11);
			reg_type -= 3;
			break;

		default: break;
	}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl 0x8(%rdx), %r15d
cmpl $-0x7f, %r15d
jl 0x7274
movl $0x4, (%rbx)
movq %r14, %rdi
movl $0x3, %esi
callq 0x686f
movl 0x10(%rbx), %eax
addl $-0x3, %eax
cmpl $0x9, %eax
ja 0x7346
leaq 0x50a5(%rip), %rcx      # 0xc33c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $-0x78, (%rax,%rcx)
jmp 0x7346
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $0x66, (%rax,%rcx)
jmp 0x72e0
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $0x48, (%rax,%rcx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $-0x77, (%rax,%rcx)
jmp 0x7346
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $-0xe, (%rax,%rcx)
jmp 0x731d
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $-0xd, (%rax,%rcx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $0xf, (%rax,%rcx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $0x11, (%rax,%rcx)
addl $-0x3, %ebp
shlb $0x3, %bpl
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
cmpl $-0x7f, %r15d
movq %rdx, 0x8(%r14)
movl $0x45, %edx
movl $0x85, %esi
cmovgel %edx, %esi
addb %bpl, %sil
movb %sil, (%rax,%rcx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x709f
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x40(%rdi)
cmpq 0x38(%rdi), %rcx
jb 0x73a6
cmpb $0x0, -0x4(%rax)
jne 0x73b2
leaq 0x5173(%rip), %rdi      # 0xc520
callq 0x1060
movq 0x40(%rbx), %rcx
movb 0xd(%rcx), %al
movb $0x0, 0xc(%rcx)
cmpb $0x1, %al
jne 0x7421
xorl %eax, %eax
movb %al, 0xd(%rcx)
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
movl 0x8(%rcx), %edx
movl %edx, 0x8(%rsi)
movl 0x4(%rcx), %ecx
movl %ecx, 0x10(%rsi)
movb %al, 0x14(%rsi)
movq %rbx, %rdi
callq 0x6902
movq %rbx, %rdi
callq 0x7386
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x7441
movq 0x28(%rbx), %rsi
movq 0x40(%rbx), %rdi
movl 0x8(%rdi), %edi
movl $0x1, %r8d
xorl %r9d, %r9d
cmpl %edi, 0x4(%rsi,%r9,8)
je 0x743c
movl %r8d, %r9d
incl %r8d
cmpq %r9, %rcx
ja 0x740d
jmp 0x7441
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
movl %eax, %ecx
shlq $0x4, %rcx
leaq 0x8cfb(%rip), %rsi      # 0x10130
movb $0x0, 0xc(%rcx,%rsi)
jmp 0x7441
movb $0x0, (%rsi,%r9,8)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movl %r15d, %eax
shlq $0x4, %rax
leaq 0x8cb2(%rip), %rcx      # 0x10130
cmpb $0x0, 0xc(%rax,%rcx)
jne 0x74c4
movq %rdx, %r14
movq %rdi, %rbx
addq %rcx, %rax
addq $0xc, %rax
movb $0x1, (%rax)
callq 0x7181
movq 0x40(%rbx), %rax
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq 0x40(%rbx), %rax
movw $0x1, 0xc(%rax)
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5072(%rip), %rdi      # 0xc53d
callq 0x1060
movl $0x1, %edi
callq 0x1210
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x38(%rdi), %r15
cmpq 0x40(%rdi), %r15
jae 0x7565
movq %rdi, %rbx
movl $0x9, %ebp
leaq 0x8c31(%rip), %r12      # 0x10130
leaq 0x8(%rsp), %r14
cmpb $0x1, 0xc(%r15)
jne 0x755b
cmpb $0x0, 0xd(%r15)
jne 0x755b
movb $0x1, 0xd(%r15)
movq %rbx, %rdi
callq 0x71c9
movl %eax, 0x8(%r15)
movl (%r15), %esi
movl 0x4(%r15), %ecx
leal -0xd(%rcx), %edx
cmpl $-0x2, %edx
cmovbl %ebp, %ecx
movq %rsi, %rdx
shlq $0x4, %rdx
movb $0x0, 0xc(%rdx,%r12)
movl $0x8, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7255
addq $0x10, %r15
cmpq 0x40(%rbx), %r15
jb 0x7504
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x511c(%rip), %rdi      # 0xc6c4
callq 0x1060
movq 0x80(%rbx), %rsi
movq 0x88(%rbx), %rdx
leaq 0x4fa6(%rip), %rdi      # 0xc568
xorl %eax, %eax
callq 0x10e0
cmpq $0x0, 0x88(%rbx)
je 0x7615
movl $0x1, %ebp
leaq 0x5a0b(%rip), %r14      # 0xcfea
xorl %eax, %eax
testb $0xf, %bpl
je 0x75fe
movq 0x90(%rbx), %rcx
movzbl (%rcx,%rax), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10e0
jmp 0x7608
movl $0xa, %edi
callq 0x1040
movl %ebp, %eax
incl %ebp
cmpq %rax, 0x88(%rbx)
ja 0x75e1
movl $0xa, %edi
callq 0x1040
leaq 0x50a8(%rip), %rdi      # 0xc6ce
callq 0x1060
movq 0x8c46(%rip), %rsi      # 0x10278
movl 0x8c38(%rip), %edx      # 0x10270
leaq 0x4f38(%rip), %rdi      # 0xc577
xorl %eax, %eax
callq 0x10e0
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl 0x8be4(%rip), %eax      # 0x10248
addl %r14d, %eax
addl $0x2, %eax
cmpq %rax, 0x8bc7(%rip)      # 0x10238
ja 0x767f
leaq 0x505f(%rip), %rdi      # 0xc6d9
callq 0x1060
movq 0x8bba(%rip), %rax      # 0x10240
movl 0x8bbc(%rip), %ecx      # 0x10248
leal 0x1(%rcx), %edx
movl %edx, 0x8bb3(%rip)      # 0x10248
movb $0x0, (%rax,%rcx)
testl %r14d, %r14d
je 0x76c9
movl %r14d, %eax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movq 0x8b93(%rip), %rsi      # 0x10240
movl 0x8b95(%rip), %edi      # 0x10248
leal 0x1(%rdi), %r8d
movl %r8d, 0x8b8a(%rip)      # 0x10248
movb %dl, (%rsi,%rdi)
incq %rcx
cmpq %rcx, %rax
jne 0x76a3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movl 0x8b88(%rip), %eax      # 0x10260
cmpq %rax, 0x8b71(%rip)      # 0x10250
je 0x7726
movq %rdi, %rbx
movq 0x8b6d(%rip), %rcx      # 0x10258
shlq $0x5, %rax
movq %rdi, 0x18(%rcx,%rax)
movl 0x8b4e(%rip), %edx      # 0x10248
incl %edx
movl %edx, (%rcx,%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rcx,%rax)
movl $0x10, 0x4(%rcx,%rax)
callq 0x10b0
movl %eax, %edi
movq %rbx, %rsi
callq 0x7654
incl 0x8b3c(%rip)            # 0x10260
popq %rbx
retq
leaq 0x4e58(%rip), %rdi      # 0xc585
leaq 0x4e88(%rip), %rsi      # 0xc5bc
leaq 0x4e93(%rip), %rcx      # 0xc5ce
movl $0x60, %edx
callq 0x1100
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movl 0x8b14(%rip), %eax      # 0x10260
cmpq %rax, 0x8afd(%rip)      # 0x10250
je 0x77a0
movq %rdi, %rbx
movq 0x8af9(%rip), %rcx      # 0x10258
shlq $0x5, %rax
movq %rdi, 0x18(%rcx,%rax)
movl 0x8ada(%rip), %edx      # 0x10248
incl %edx
movl %edx, (%rcx,%rax)
movq %rsi, 0x8(%rcx,%rax)
movq $0x0, 0x10(%rcx,%rax)
movl $0x10010, 0x4(%rcx,%rax) # imm = 0x10010
callq 0x10b0
movl %eax, %edi
movq %rbx, %rsi
callq 0x7654
incl 0x8ac2(%rip)            # 0x10260
popq %rbx
retq
leaq 0x4dde(%rip), %rdi      # 0xc585
leaq 0x4e0e(%rip), %rsi      # 0xc5bc
leaq 0x4e32(%rip), %rcx      # 0xc5e7
movl $0x6f, %edx
callq 0x1100
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movl 0x8a9a(%rip), %eax      # 0x10260
cmpq %rax, 0x8a83(%rip)      # 0x10250
je 0x7835
movq %rdi, %rbx
movq 0x8a7f(%rip), %rcx      # 0x10258
shlq $0x5, %rax
movq %rdi, 0x18(%rcx,%rax)
movl 0x8a60(%rip), %edi      # 0x10248
incl %edi
movl %edi, (%rcx,%rax)
movq %rsi, 0x8(%rcx,%rax)
testb %dl, %dl
movl $0x1, %edx
movl $0x10, %esi
cmovnel %edx, %esi
movq $0x0, 0x10(%rcx,%rax)
movb %sil, 0x4(%rcx,%rax)
movb $0x0, 0x5(%rcx,%rax)
movw $0x2, 0x6(%rcx,%rax)
movq %rbx, %rdi
callq 0x10b0
movl %eax, %edi
movq %rbx, %rsi
callq 0x7654
incl 0x8a2d(%rip)            # 0x10260
popq %rbx
retq
leaq 0x4d49(%rip), %rdi      # 0xc585
leaq 0x4d79(%rip), %rsi      # 0xc5bc
leaq 0x4dbe(%rip), %rcx      # 0xc608
movl $0x7e, %edx
callq 0x1100
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl 0x8a05(%rip), %esi      # 0x10270
cmpq %rsi, 0x8a06(%rip)      # 0x10278
je 0x7915
movq 0x89e9(%rip), %r12      # 0x10268
movl 0x89db(%rip), %ebx      # 0x10260
cmpq $0x3, %rbx
jb 0x78dd
movl %edi, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x89b9(%rip), %rbp      # 0x10258
addq $0x58, %rbp
movl $0x2, %r15d
xorl %r13d, %r13d
movq (%rbp), %rdi
movq %r14, %rsi
callq 0x1140
testl %eax, %eax
cmoveq %r15, %r13
incq %r15
addq $0x20, %rbp
cmpq %r15, %rbx
jne 0x78ac
shlq $0x20, %r13
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %edi
jmp 0x78e0
xorl %r13d, %r13d
leaq (%rsi,%rsi,2), %rax
movl %edi, %ecx
movq %rcx, (%r12,%rax,8)
movl %edx, %ecx
orq %r13, %rcx
movq %rcx, 0x8(%r12,%rax,8)
movq $-0x4, 0x10(%r12,%rax,8)
leal 0x1(%rsi), %eax
movl %eax, 0x896a(%rip)      # 0x10270
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d18(%rip), %rdi      # 0xc634
leaq 0x4c99(%rip), %rsi      # 0xc5bc
leaq 0x4d31(%rip), %rcx      # 0xc65b
movl $0x8d, %edx
callq 0x1100
// File: /workspace/github_c_makefile_star2_O1/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 0x1180
movq %rax, 0x88fa(%rip)      # 0x10240
testq %rax, %rax
jne 0x795e
leaq 0x36d5(%rip), %rdi      # 0xb027
leaq 0x4d2d(%rip), %rsi      # 0xc686
callq 0x98fb
movq $0x80, 0x88cf(%rip) # 0x10238
movl $0x0, 0x88d5(%rip)      # 0x10248
movq 0x88c6(%rip), %rax      # 0x10240
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1180
movq %rax, 0x88b8(%rip)      # 0x10268
testq %rax, %rax
jne 0x79c8
leaq 0x366b(%rip), %rdi      # 0xb027
leaq 0x4ccf(%rip), %rsi      # 0xc692
callq 0x98fb
movl $0x0, 0x889e(%rip)      # 0x10270
movq $0x10, 0x889b(%rip) # 0x10278
movq 0x8884(%rip), %rdi      # 0x10268
movl $0x180, %edx            # imm = 0x180
xorl %esi, %esi
popq %rax
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl $0x200, %edi            # imm = 0x200
callq 0x1180
movq %rax, 0x8855(%rip)      # 0x10258
testq %rax, %rax
jne 0x7a1b
leaq 0x3618(%rip), %rdi      # 0xb027
leaq 0x4c87(%rip), %rsi      # 0xc69d
callq 0x98fb
movq $0x10, 0x882a(%rip) # 0x10250
movl $0x0, 0x8830(%rip)      # 0x10260
movq 0x8821(%rip), %rbx      # 0x10258
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1110
leaq 0x4c5e(%rip), %rsi      # 0xc6ab
movl $0x8, %edi
callq 0x7654
movabsq $-0xefffbffffffff, %rax # imm = 0xFFF1000400000001
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x2, 0x87ea(%rip)      # 0x10260
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq 0x8717(%rip), %rax      # 0x10230
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, (%rax)
movq $0x6, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x20(%rax)
xorl %ecx, %ecx
movq %rcx, 0x28(%rax)
movq $0x8, 0x30(%rax)
movq %rcx, 0x38(%rax)
testb $0x7, 0x8(%rdi)
je 0x7b7e
movq %rdi, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x686f
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x0, (%rax,%rcx)
testb $0x7, 0x8(%rbx)
jne 0x7b58
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x86a9(%rip), %rax      # 0x10230
movabsq $0x100000007, %rcx      # imm = 0x100000007
movq %rcx, 0x40(%rax)
movq $0x3, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movq 0x88(%rdi), %rcx
movq %rcx, 0x60(%rax)
xorl %edx, %edx
movq %rdx, 0x68(%rax)
movq $0x8, 0x70(%rax)
movq %rdx, 0x78(%rax)
testb $0x7, %cl
je 0x7bf2
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68b0
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x88(%rbx)
movb $0x0, (%rcx,%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x85e6(%rip), %rax      # 0x10230
movabsq $0x200000017, %rcx      # imm = 0x200000017
movq %rcx, 0x80(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rax)
movq $0x0, 0x98(%rax)
movl 0x85ea(%rip), %ecx      # 0x10260
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rcx, 0xa0(%rax)
movl $0x6, 0xa8(%rax)
movl $0x2, 0xac(%rax)
movq $0x4, 0xb0(%rax)
movq $0x18, 0xb8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8579(%rip), %rax      # 0x10230
movabsq $0x30000001f, %rcx      # imm = 0x30000001F
movq %rcx, 0x140(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rax)
xorl %ecx, %ecx
movq %rcx, 0x158(%rax)
movl 0x8567(%rip), %edx      # 0x10248
movq %rdx, 0x160(%rax)
movl %ecx, 0x168(%rax)
movl %ecx, 0x16c(%rax)
movq $0x1, 0x170(%rax)
movq %rcx, 0x178(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8522(%rip), %rax      # 0x10230
movabsq $0x400000027, %rcx      # imm = 0x400000027
movq %rcx, 0xc0(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xc8(%rax)
movq $0x0, 0xd8(%rax)
movl 0x8536(%rip), %ecx      # 0x10270
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rcx, 0xe0(%rax)
movl $0x3, 0xe8(%rax)
movl $0x1, 0xec(%rax)
movq $0x4, 0xf0(%rax)
movq $0x18, 0xf8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x846e(%rip), %eax      # 0x101e8
movl %eax, %ecx
shll $0x6, %ecx
addl $0x40, %ecx
movq 0x84a7(%rip), %rdx      # 0x10230
movq %rcx, 0x18(%rdx)
addl 0x8(%rdi), %ecx
movq %rcx, 0x58(%rdx)
cmpl $0x4, %eax
jl 0x7dc5
addl 0x88(%rdi), %ecx
decl %eax
shlq $0x6, %rax
addq $-0x80, %rax
xorl %esi, %esi
movl %ecx, %edi
movq %rdi, 0x98(%rdx,%rsi)
addl 0xa0(%rdx,%rsi), %ecx
addq $0x40, %rsi
cmpq %rsi, %rax
jne 0x7dab
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/ir/ir-linux.c
// Function: write_elf64
void write_elf64(struct OppIr* ir, OppIO* io)
{
	// Header
	fwrite(&elf_info.elf64_hdr, sizeof(elf_info.elf64_hdr), 1, io->file);

	// Sections
	for (unsigned int i = 0; i < sizeof(struct Elf64_SHDR); i++) 
		fwrite(((char[1]){0}), 1, 1, io->file);
	fwrite(elf_info.sect_list, sizeof(struct Elf64_SHDR), elf_info.sect_amount-1, io->file);
	
	// Text
	fwrite(ir->code.bytes, 1, ir->code.idx, io->file);

	// Data
	fwrite(ir->data_seg.data, 1, ir->data_seg.idx, io->file);

	// Sym / Rela
	for (unsigned int i = 0; i < elf_info.symbols.sym_idx; i++)
		fwrite(&elf_info.symbols.pairs[i].syms, sizeof(struct Elf64_Symbol), 1, io->file);

	// Rela Text
	fwrite(elf_info.relocs, sizeof(struct Elf64_Reloc), elf_info.r_idx, io->file);

	// Shstrtab
	fwrite(shstrtab, 1, elf_info.sect_list[SECT_SHSTRTAB].sh_size, io->file);

	// Strtab
	fwrite(elf_info.strtable.str, 1, elf_info.strtable.str_idx, io->file);
	char z = 0;
	while (elf_info.strtable.str_idx % 16 != 0) {
		fwrite(&z, 1, 1, io->file);
		elf_info.strtable.str_idx++;
	}
	fwrite(&z, 1, 1, io->file);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rcx
leaq 0x8412(%rip), %rdi      # 0x101f0
movl $0x40, %esi
movl $0x1, %edx
callq 0x1220
movl $0x40, %ebp
movq 0x8(%rbx), %rsi
xorl %edi, %edi
callq 0x1120
decl %ebp
jne 0x7df2
movq 0x8428(%rip), %rdi      # 0x10230
movslq 0x83d9(%rip), %rdx      # 0x101e8
decq %rdx
movq 0x8(%rbx), %rcx
movl $0x40, %esi
callq 0x1220
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rcx
movl $0x1, %esi
callq 0x1220
movq 0x88(%r14), %rdx
movq 0x90(%r14), %rdi
movq 0x8(%rbx), %rcx
movl $0x1, %esi
callq 0x1220
cmpl $0x0, 0x8408(%rip)      # 0x10260
je 0x7e8f
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x83f1(%rip), %rdi      # 0x10258
addq %r14, %rdi
movq 0x8(%rbx), %rcx
movl $0x18, %esi
movl $0x1, %edx
callq 0x1220
incq %r15
movl 0x83da(%rip), %eax      # 0x10260
addq $0x20, %r14
cmpq %rax, %r15
jb 0x7e60
movq 0x83d2(%rip), %rdi      # 0x10268
movl 0x83d4(%rip), %edx      # 0x10270
movq 0x8(%rbx), %rcx
movl $0x18, %esi
callq 0x1220
movq 0x837f(%rip), %rax      # 0x10230
movq 0x120(%rax), %rdx
movq 0x8(%rbx), %rcx
leaq 0x82cd(%rip), %rdi      # 0x10190
movl $0x1, %esi
callq 0x1220
movq 0x836c(%rip), %rdi      # 0x10240
movl 0x836e(%rip), %edx      # 0x10248
movq 0x8(%rbx), %rcx
movl $0x1, %esi
callq 0x1220
testb $0xf, 0x8359(%rip)      # 0x10248
je 0x7f0e
movq 0x8(%rbx), %rsi
xorl %edi, %edi
callq 0x1120
movl 0x8346(%rip), %eax      # 0x10248
incl %eax
movl %eax, 0x833e(%rip)      # 0x10248
testb $0xf, %al
jne 0x7ef1
movq 0x8(%rbx), %rsi
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1120
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1180
movq %rax, 0x834a(%rip)      # 0x10280
testq %rax, %rax
je 0x7f5f
callq 0x8044
movq 0x8339(%rip), %rcx      # 0x10280
movq %rax, 0x8(%rcx)
testq %rax, %rax
je 0x7f5f
movq %rax, 0x10(%rcx)
movq $0x0, (%rcx)
movb $0x1, %al
jmp 0x7f61
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/memory/memory.c
// Function: alloc
char* alloc(size_t size)
{
    struct Block_Header* block = root->current;
    char *ptr = NULL;

    while ((size % 8) != 0)
    	size++;

    ptr = block->free;
    block->free += size;
    root->used_mem += size;

    #ifdef DEBUG_MEMORY
    printf("Allocating: %ld Used: %ld\n", size, root->used_mem);
    #endif

    if (block->free >= block->end) {
        if (block->next != NULL) {
            block->next->free = block->next->block;
            root->current = block->next;
        }
        else {
            #ifdef DEBUG_MEMORY
            printf("Allocating extra block\n");
            #endif
        	block->next = block_init();

            if (block->next == NULL) 
            	return NULL;
            root->current = block->next;
        }

        ptr = root->current->free;
        root->current->free += size;
    }

    return ptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8312(%rip), %rcx      # 0x10280
movq 0x10(%rcx), %r14
movl %edi, %ebx
negl %ebx
andl $0x7, %ebx
addq %rdi, %rbx
movq 0x10(%r14), %rax
leaq (%rax,%rbx), %rdx
movq %rdx, 0x10(%r14)
addq %rbx, (%rcx)
cmpq 0x18(%r14), %rdx
jb 0x7fd1
movq (%r14), %rax
testq %rax, %rax
je 0x7fa3
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rax)
jmp 0x7fb7
callq 0x8044
movq %rax, (%r14)
testq %rax, %rax
je 0x7fd9
movq 0x82c9(%rip), %rcx      # 0x10280
movq %rax, 0x10(%rcx)
movq 0x82be(%rip), %rax      # 0x10280
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rax
addq %rax, %rbx
movq %rbx, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x7fd1
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/memory/memory.c
// Function: allocator_free
void allocator_free()
{
    struct Block_Header* ptr;
    struct Block_Header* hdr = root->first;

    while (hdr != NULL)
    {
        ptr = hdr->next;
        free(hdr->block);
        free(hdr);
        hdr = ptr;
    }
    free(root);
    root = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8280(%rip), %rax      # 0x10280
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x8025
movq (%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x8009
movq 0x8254(%rip), %rdi      # 0x10280
callq 0x1030
movq $0x0, 0x8244(%rip) # 0x10280
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/memory/memory.c
// Function: block_init
static struct Block_Header* block_init()
{
    struct Block_Header *alloc = NULL;
    char *block = NULL;

    block = (char*)malloc(BLOCK_SIZE);
    alloc = (struct Block_Header*)
    	malloc(sizeof(struct Block_Header));

    if (alloc == NULL || block == NULL) 
    	return NULL;

    alloc->block = block;
    alloc->free = block;
    alloc->next = NULL;
    alloc->end = block + BLOCK_SIZE;

    return alloc;
}

// Assembly:
pushq %rbx
movl $0xfa00, %edi           # imm = 0xFA00
callq 0x1180
movq %rax, %rbx
movl $0x20, %edi
callq 0x1180
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x8070
xorl %eax, %eax
jmp 0x808a
movq %rbx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0x0, (%rax)
addq $0xfa00, %rbx           # imm = 0xFA00
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parser_init
struct Opp_Parser* opp_parser_init(struct Opp_Scan* s)
{
	struct Opp_Parser* parser = (struct Opp_Parser*)
		malloc(sizeof(struct Opp_Parser));

	parser->lex = s;
	parser->nstmts = 0;
	parser->statments = calloc(64, sizeof(*parser->statments));
	parser->stmt_size = 64;

	if (parser->statments == NULL)
		goto err;

	// Init type tree
	parser->tree.types = (struct Opp_Type_Entry**)
		malloc(sizeof(struct Opp_Type_Entry*)*DEFAULT_TYPE_TREE_SIZE);

	if (parser->tree.types == NULL)
		goto err;

	parser->tree.size = DEFAULT_TYPE_TREE_SIZE;

	memset(parser->tree.types, 0, sizeof(struct Opp_Type_Entry*)*DEFAULT_TYPE_TREE_SIZE);

	opp_add_std_types(parser);

	return parser;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x38, %edi
callq 0x1180
movq %rax, %rbx
movq %r14, (%rax)
movl $0x0, 0x18(%rax)
movl $0x40, %edi
movl $0x8, %esi
callq 0x1130
movq %rax, 0x8(%rbx)
movq $0x40, 0x10(%rbx)
testq %rax, %rax
je 0x80fe
movl $0x500, %edi            # imm = 0x500
callq 0x1180
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x80fe
movq $0xa0, 0x28(%rbx)
movl $0x500, %edx            # imm = 0x500
movq %rax, %rdi
xorl %esi, %esi
callq 0x1110
movq %rbx, %rdi
callq 0x811e
jmp 0x8113
leaq 0x348b(%rip), %rdi      # 0xb590
leaq 0x46f8(%rip), %rsi      # 0xc804
callq 0x98fb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_add_std_types
void opp_add_std_types(struct Opp_Parser* parser)
{
	struct Opp_Type_Entry* type1;

	type1 = add_type(&parser->tree, "char");
	type1->t_type = TYPE_I8;
	char_type = type1;

	type1 = add_type(&parser->tree, "short");
	type1->t_type = TYPE_I16;

	type1 = add_type(&parser->tree, "int");
	type1->t_type = TYPE_I32;
	int_type = type1;

	type1 = add_type(&parser->tree, "long");
	type1->t_type = TYPE_I64;

	type1 = add_type(&parser->tree, "void");
	type1->t_type = TYPE_VOID;
	void_type = type1;

	type1 = add_type(&parser->tree, "float");
	type1->t_type = TYPE_FLOAT;

	type1 = add_type(&parser->tree, "double");
	type1->t_type = TYPE_DOUBLE;
	float_type = type1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rbx
leaq 0x46f8(%rip), %rsi      # 0xc825
movq %rbx, %rdi
callq 0x877c
movl $0x1, 0x8(%rax)
movq %rax, 0x8145(%rip)      # 0x10288
leaq 0x46e0(%rip), %rsi      # 0xc82a
movq %rbx, %rdi
callq 0x877c
movl $0x2, 0x8(%rax)
leaq 0x46d0(%rip), %rsi      # 0xc830
movq %rbx, %rdi
callq 0x877c
movl $0x3, 0x8(%rax)
movq %rax, 0x811a(%rip)      # 0x10290
leaq 0x46b7(%rip), %rsi      # 0xc834
movq %rbx, %rdi
callq 0x877c
movl $0x4, 0x8(%rax)
leaq 0x46a6(%rip), %rsi      # 0xc839
movq %rbx, %rdi
callq 0x877c
movl $0x0, 0x8(%rax)
movq %rax, 0x80ef(%rip)      # 0x10298
leaq 0x468e(%rip), %rsi      # 0xc83e
movq %rbx, %rdi
callq 0x877c
movl $0x5, 0x8(%rax)
leaq 0x467e(%rip), %rsi      # 0xc844
movq %rbx, %rdi
callq 0x877c
movl $0x6, 0x8(%rax)
movq %rax, 0x80c4(%rip)      # 0x102a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_free_parser
void opp_free_parser(struct Opp_Parser* parser)
{
	for (unsigned int i = 0; i < DEFAULT_TYPE_TREE_SIZE; i++) {
		if (parser->tree.types[i] != NULL) {

			struct Opp_Type_Entry* t = parser->tree.types[i]->next;
			while (t != NULL) {
				struct Opp_Type_Entry* c = t;
				t = t->next;
				free(c->id);
				free(c);
			}

			if (parser->tree.types[i]->t_type == TYPE_STRUCT)
				free(parser->tree.types[i]->id);
			free(parser->tree.types[i]);
		}
	}
	free(parser->tree.types);

	for (unsigned int i = 0; i < parser->nstmts; i++)
		opp_free_node(parser->statments[i]);

	free(parser->statments);
	free(parser);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x8241
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x821e
movq (%r14), %rdi
movq 0x20(%r14), %r12
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r12, %r14
testq %r12, %r12
jne 0x8202
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x8, 0x8(%rax)
jne 0x8234
movq (%rax), %rdi
callq 0x1030
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1030
incq %r15
cmpq $0xa0, %r15
jne 0x81ec
movq 0x20(%rbx), %rdi
callq 0x1030
cmpl $0x0, 0x18(%rbx)
je 0x8277
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8293
incq %r14
movl 0x18(%rbx), %eax
cmpq %rax, %r14
jb 0x825f
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: get_type
struct Opp_Type_Entry* get_type(struct Opp_Type_Tree* tree, char* name)
{
	unsigned int loc = hash_str(name, tree->size);

	struct Opp_Type_Entry* scope = tree->types[loc];

	if (scope != NULL) 
	{
		while (scope) {
			if (!strcmp(scope->id, name)) 
				return scope;
			else if (scope->next != NULL)
				scope = scope->next;
			else 
				return NULL;
		}
	}

	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0xa340
movq (%r14), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x876e
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0x8771
movq 0x20(%r14), %r14
jmp 0x8754
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: add_type
static struct Opp_Type_Entry* add_type(struct Opp_Type_Tree* tree, char* name)
{
	unsigned int loc = hash_str(name, tree->size);

	if (tree->types[loc] != NULL) {
		struct Opp_Type_Entry* pos = tree->types[loc];

		while (pos) {
			if (!strcmp(pos->id, name)) 
				return NULL;
			else if (pos->next == NULL) {
				pos->next = (struct Opp_Type_Entry*)
					malloc(sizeof(struct Opp_Type_Entry));

				if (!pos->next)
					INTERNAL_ERROR("Malloc fail");

				pos->next->id = name;
				pos->next->next = NULL;
				return pos->next;
			}
			else 
				pos = pos->next;
		}
	}
	else {
		struct Opp_Type_Entry* t = (struct Opp_Type_Entry*)
			malloc(sizeof(struct Opp_Type_Entry));

		if (t == NULL)
			INTERNAL_ERROR("Malloc fail");

		t->id = name;
		t->next = NULL;
		tree->types[loc] = t;

		return t;
	}

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0xa340
movq (%r15), %rcx
movl %eax, %r12d
movq (%rcx,%r12,8), %rax
testq %rax, %rax
je 0x87fd
xorl %r14d, %r14d
movq %rax, %r15
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0x8834
movq 0x20(%r15), %rax
testq %rax, %rax
jne 0x87a7
movl $0x28, %edi
callq 0x1180
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0x87e8
leaq 0x284b(%rip), %rdi      # 0xb027
leaq 0x408b(%rip), %rsi      # 0xc86e
callq 0x98fb
movq 0x20(%r15), %rax
movq %rbx, (%rax)
movq $0x0, 0x20(%rax)
movq 0x20(%r15), %r14
jmp 0x8834
movl $0x28, %edi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
jne 0x8822
leaq 0x2811(%rip), %rdi      # 0xb027
leaq 0x4051(%rip), %rsi      # 0xc86e
callq 0x98fb
movq %rbx, (%r14)
movq $0x0, 0x20(%r14)
movq (%r15), %rax
movq %r14, (%rax,%r12,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_new_node
static struct Opp_Node* opp_new_node(struct Opp_Parser* parser, enum Opp_Node_Type type)
{
	struct Opp_Node* node = (struct Opp_Node*)
		malloc(sizeof(struct Opp_Node));

	if (node == NULL)
		INTERNAL_ERROR("Malloc fail");

	node->type = type;
	node->debug.line = parser->lex->line;
	node->debug.colum = parser->lex->colum;

	return node;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x48, %edi
callq 0x1180
movq %rax, %rbx
testq %rax, %rax
jne 0x8bc9
leaq 0x246a(%rip), %rdi      # 0xb027
leaq 0x3e65(%rip), %rsi      # 0xca29
callq 0x98fb
movl %ebp, (%rbx)
movq (%r14), %rax
movl 0x28(%rax), %ecx
movl %ecx, 0x4(%rbx)
movl 0x2c(%rax), %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_unary
static struct Opp_Node* opp_parse_unary(struct Opp_Parser* parser)
{
	struct Opp_Node* unary = NULL;

	if (parser->lex->t.id == TOPENP) {
		return opp_parse_paran(parser);
	}

	unary = opp_new_node(parser, EUNARY);

	switch (parser->lex->t.id)
	{
		case TIDENT: 
			opp_parse_identifier(parser, unary);
			break;

		case TINTEGER:	
			opp_parse_integer(parser, unary);
			break;

		case TFLOAT:
			opp_parse_float(parser, unary);
			break;

		case TSTR:
			opp_parse_str(parser, unary);
			break;

		case TCH:
			unary->unary_expr.type = TINTEGER;
			unary->unary_expr.val.i64val = (int64_t)parser->lex->t.buffer.buf[0];
			break;
			
		default:
			opp_error(parser->lex, "Expected unary value but got unexpected");
			break;
	}

	return unary;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rdi
cmpl $0x22, 0x30(%rdi)
jne 0x8c22
callq 0x9cc3
movq %r14, %rdi
callq 0x8d29
movq %rax, %rbx
movq (%r14), %rax
cmpl $0x23, 0x30(%rax)
je 0x8d20
movq %r14, %rdi
movl $0x29, %esi
callq 0x915e
jmp 0x8d20
movq %r14, %rdi
movl $0x5, %esi
callq 0x8b9b
movq %rax, %rbx
movq (%r14), %rdi
movl 0x30(%rdi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x8c9a
leaq 0x3b42(%rip), %rcx      # 0xc788
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x10(%rbx)
cmpq $0x21, 0x40(%rdi)
jb 0x8c6f
movq 0x38(%rdi), %rdx
leaq 0x3e3d(%rip), %rsi      # 0xcaa5
xorl %eax, %eax
callq 0x980e
movq (%r14), %rax
movq 0x40(%rax), %rdi
incq %rdi
callq 0x1180
movq %rax, %r15
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x8cfc
leaq 0x2396(%rip), %rdi      # 0xb027
leaq 0x3e3f(%rip), %rsi      # 0xcad7
jmp 0x8cf7
leaq 0x3d95(%rip), %rsi      # 0xca36
xorl %eax, %eax
callq 0x980e
jmp 0x8d20
movl $0x3, 0x10(%rbx)
movsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x18(%rbx)
jmp 0x8d20
movl $0x2, 0x10(%rbx)
movq 0x48(%rdi), %rax
jmp 0x8d1c
movl $0x5, 0x10(%rbx)
movq 0x40(%rdi), %rdi
incq %rdi
callq 0x1180
movq %rax, %r15
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x8cfc
leaq 0x2337(%rip), %rdi      # 0xb027
leaq 0x3df5(%rip), %rsi      # 0xcaec
callq 0x98fb
movq (%r14), %rax
movq 0x38(%rax), %rsi
movq %r15, %rdi
callq 0x1050
jmp 0x8d20
movl $0x2, 0x10(%rbx)
movq 0x38(%rdi), %rax
movsbq (%rax), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_allign
static struct Opp_Node* opp_parse_allign(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_or(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* assign = NULL;

	int operator = parser->lex->t.id;

	while (operator == TEQ || operator == TCOLON)
	{
		opp_next(parser->lex);
		right = opp_parse_or(parser);

		assign = opp_new_node(parser, EASSIGN);
		assign->assign_expr.ident = left;
		assign->assign_expr.val = right;
		assign->assign_expr.op = operator;

		left = assign;

		operator = parser->lex->t.id;
	}

	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9198
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %ebp
cmpl $0x1b, %ebp
je 0x8d4b
cmpl $0xf, %ebp
jne 0x8d75
callq 0x9cc3
movq %rbx, %rdi
callq 0x9198
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8b9b
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movl %ebp, 0x10(%rax)
jmp 0x8d38
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_or
static struct Opp_Node* opp_parse_or(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_and(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* or = NULL;

	int operator = parser->lex->t.id;

	while (operator == TOR) 
	{
		opp_next(parser->lex);
		right = opp_parse_and(parser);

		or = opp_new_node(parser, ELOGIC);
		or->logic_expr.tok = TOR;
		or->logic_expr.left = left;
		or->logic_expr.right = right;

		left = or;

		operator = parser->lex->t.id;
	}

	return left;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x91f4
movq %rax, %r14
movq (%rbx), %rdi
cmpl $0x7, 0x30(%rdi)
jne 0x91eb
callq 0x9cc3
movq %rbx, %rdi
callq 0x91f4
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8b9b
movl $0x7, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq (%rbx), %rdi
cmpl $0x7, 0x30(%rdi)
movq %rax, %r14
je 0x91b1
jmp 0x91ee
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_and
static struct Opp_Node* opp_parse_and(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_relation(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* and = NULL;

	int operator = parser->lex->t.id;

	while (operator == TAND) 
	{
		opp_next(parser->lex);
		right = opp_parse_relation(parser);

		and = opp_new_node(parser, ELOGIC);
		and->logic_expr.tok = TAND;
		and->logic_expr.left = left;
		and->logic_expr.right = right;

		left = and;

		operator = parser->lex->t.id;
	}

	return left;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x9250
movq %rax, %r14
movq (%rbx), %rdi
cmpl $0x8, 0x30(%rdi)
jne 0x9247
callq 0x9cc3
movq %rbx, %rdi
callq 0x9250
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8b9b
movl $0x8, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq (%rbx), %rdi
cmpl $0x8, 0x30(%rdi)
movq %rax, %r14
je 0x920d
jmp 0x924a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_relation
static struct Opp_Node* opp_parse_relation(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_comparison(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* relation = NULL;

	int operator = parser->lex->t.id;

	while (operator == TEQEQ || operator == TNOTEQ)
	{
		opp_next(parser->lex);
		right = opp_parse_comparison(parser);

		relation = opp_new_node(parser, ELOGIC);
		relation->logic_expr.tok = operator;
		relation->logic_expr.left = left;
		relation->logic_expr.right = right;

		left = relation;

		operator = parser->lex->t.id;
	}

	return left;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x92c2
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0xd(%r12), %eax
cmpl $0x1, %eax
ja 0x92b3
callq 0x9cc3
movq %rbx, %rdi
callq 0x92c2
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8b9b
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0xd(%r12), %ecx
movq %rax, %r14
cmpl $0x2, %ecx
jb 0x9274
jmp 0x92b6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_comparison
static struct Opp_Node* opp_parse_comparison(struct Opp_Parser* parser)
{
	// struct Opp_Node* left = opp_parse_order1(parser);
	struct Opp_Node* left = opp_parse_shifts(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* comp = NULL;

	int operator = parser->lex->t.id;

	while (operator == TGT || operator == TLT ||
			operator == TGE || operator == TLE)
	{
		opp_next(parser->lex);
		// right = opp_parse_order1(parser);
		right = opp_parse_shifts(parser);

		comp = opp_new_node(parser, ELOGIC);
		comp->logic_expr.tok = operator;
		comp->logic_expr.left = left;
		comp->logic_expr.right = right;

		left = comp;

		operator = parser->lex->t.id;
	}

	return left;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9334
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x9(%r12), %eax
cmpl $0x3, %eax
ja 0x9325
callq 0x9cc3
movq %rbx, %rdi
callq 0x9334
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8b9b
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x9(%r12), %ecx
movq %rax, %r14
cmpl $0x4, %ecx
jb 0x92e6
jmp 0x9328
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq