LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x8aab(%rip), %rax      # 0x10230
movabsq $0x200000017, %rcx      # imm = 0x200000017
movq %rcx, 0x80(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x98(%rax)
movups %xmm0, 0x88(%rax)
movl 0x8ab2(%rip), %ecx      # 0x10260
imulq $0x18, %rcx, %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_O2/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 0x8a45(%rip), %rax      # 0x10230
movabsq $0x30000001f, %rcx      # imm = 0x30000001F
movq %rcx, 0x140(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rax)
andq $0x0, 0x158(%rax)
movl 0x8a34(%rip), %ecx      # 0x10248
movq %rcx, 0x160(%rax)
andl $0x0, 0x168(%rax)
andl $0x0, 0x16c(%rax)
movq $0x1, 0x170(%rax)
andq $0x0, 0x178(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x89ec(%rip), %rax      # 0x10230
movabsq $0x400000027, %rcx      # imm = 0x400000027
movq %rcx, 0xc0(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0xd8(%rax)
movups %xmm0, 0xc8(%rax)
movl 0x8a03(%rip), %ecx      # 0x10270
imulq $0x18, %rcx, %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_O2/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:
movslq 0x893e(%rip), %rax      # 0x101e8
movl %eax, %ecx
shll $0x6, %ecx
addl $0x40, %ecx
movq 0x8977(%rip), %rdx      # 0x10230
movq %rcx, 0x18(%rdx)
addl 0x8(%rdi), %ecx
movq %rcx, 0x58(%rdx)
addl 0x88(%rdi), %ecx
decq %rax
addq $0xa0, %rdx
pushq $0x2
popq %rsi
cmpq %rax, %rsi
jge 0x78ed
movl %ecx, %edi
movq %rdi, -0x8(%rdx)
addl (%rdx), %ecx
incq %rsi
addq $0x40, %rdx
jmp 0x78d7
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rcx
leaq 0x88e6(%rip), %rdi      # 0x101f0
pushq $0x40
popq %rsi
pushq $0x1
popq %rdx
callq 0x1220
pushq $0x40
popq %rbp
subl $0x1, %ebp
jb 0x792a
movq 0x8(%rbx), %rsi
xorl %edi, %edi
callq 0x1120
jmp 0x7918
movq 0x88ff(%rip), %rdi      # 0x10230
movslq 0x88b0(%rip), %rdx      # 0x101e8
decq %rdx
movq 0x8(%rbx), %rcx
pushq $0x40
popq %rsi
callq 0x1220
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rcx
pushq $0x1
popq %r15
movq %r15, %rsi
callq 0x1220
movq 0x88(%r14), %rdx
movq 0x90(%r14), %rdi
movq 0x8(%rbx), %rcx
movq %r15, %rsi
callq 0x1220
xorl %r12d, %r12d
pushq $0x18
popq %r14
xorl %r13d, %r13d
movl 0x88d8(%rip), %eax      # 0x10260
cmpq %rax, %r13
jae 0x79af
movq 0x88c4(%rip), %rdi      # 0x10258
addq %r12, %rdi
movq 0x8(%rbx), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x1220
incq %r13
addq $0x20, %r12
jmp 0x7982
movq 0x88b2(%rip), %rdi      # 0x10268
movl 0x88b4(%rip), %edx      # 0x10270
movq 0x8(%rbx), %rcx
pushq $0x18
popq %rsi
callq 0x1220
movq 0x8861(%rip), %rax      # 0x10230
movq 0x120(%rax), %rdx
movq 0x8(%rbx), %rcx
leaq 0x87af(%rip), %rdi      # 0x10190
pushq $0x1
popq %r14
movq %r14, %rsi
callq 0x1220
movq 0x884c(%rip), %rdi      # 0x10240
movl 0x884e(%rip), %edx      # 0x10248
movq 0x8(%rbx), %rcx
movq %r14, %rsi
callq 0x1220
movl 0x883c(%rip), %ebp      # 0x10248
movq 0x8(%rbx), %rsi
xorl %edi, %edi
callq 0x1120
testb $0xf, %bpl
je 0x7a2d
movl 0x8825(%rip), %ebp      # 0x10248
incl %ebp
movl %ebp, 0x881d(%rip)      # 0x10248
jmp 0x7a0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x1180
movq %rax, 0x8834(%rip)      # 0x10280
testq %rax, %rax
je 0x7a72
callq 0x7b4d
movq 0x8823(%rip), %rcx      # 0x10280
movq %rax, 0x8(%rcx)
testq %rax, %rax
je 0x7a72
movq %rax, 0x10(%rcx)
andq $0x0, (%rcx)
movb $0x1, %al
jmp 0x7a74
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x87ff(%rip), %rdx      # 0x10280
movq 0x10(%rdx), %r14
movl %edi, %ebx
negl %ebx
andl $0x7, %ebx
addq %rdi, %rbx
movq 0x10(%r14), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, 0x10(%r14)
addq %rbx, (%rdx)
cmpq 0x18(%r14), %rcx
jb 0x7ae0
movq (%r14), %rcx
testq %rcx, %rcx
je 0x7aba
movq 0x8(%rcx), %rax
movq %rax, 0x10(%rcx)
movq %rcx, 0x10(%rdx)
jmp 0x7ad9
callq 0x7b4d
movq %rax, (%r14)
testq %rax, %rax
je 0x7ae8
movq %rax, %rcx
movq 0x87af(%rip), %rax      # 0x10280
movq %rcx, 0x10(%rax)
movq 0x10(%rcx), %rax
addq %rax, %rbx
movq %rbx, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x7ae0
// File: /workspace/github_c_makefile_star2_O2/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 0x8771(%rip), %rax      # 0x10280
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x7b31
movq (%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
jmp 0x7b13
movq 0x8748(%rip), %rdi      # 0x10280
callq 0x1030
andq $0x0, 0x873b(%rip)      # 0x10280
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x1180
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x7b77
xorl %eax, %eax
jmp 0x7b8e
movq %rbx, 0x8(%rax)
movq %rbx, 0x10(%rax)
andq $0x0, (%rax)
addq $0xfa00, %rbx           # imm = 0xFA00
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0x1180
movq %rax, %rbx
movq %r14, (%rax)
andl $0x0, 0x18(%rax)
pushq $0x40
popq %rdi
pushq $0x8
popq %rsi
callq 0x1130
movq %rax, 0x8(%rbx)
movq $0x40, 0x10(%rbx)
testq %rax, %rax
je 0x7bed
pushq $0x1
popq %rdi
movl $0x500, %esi            # imm = 0x500
callq 0x1130
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x7bed
movq $0xa0, 0x28(%rbx)
movq %rbx, %rdi
callq 0x7c0d
jmp 0x7c02
leaq 0x299c(%rip), %rdi      # 0xa590
leaq 0x3c29(%rip), %rsi      # 0xb824
callq 0x9287
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c29(%rip), %rsi      # 0xb845
movq %rbx, %rdi
callq 0x821c
movl $0x1, 0x8(%rax)
movq %rax, 0x8656(%rip)      # 0x10288
leaq 0x3c11(%rip), %rsi      # 0xb84a
movq %rbx, %rdi
callq 0x821c
movl $0x2, 0x8(%rax)
leaq 0x3c01(%rip), %rsi      # 0xb850
movq %rbx, %rdi
callq 0x821c
movl $0x3, 0x8(%rax)
movq %rax, 0x862b(%rip)      # 0x10290
leaq 0x3be8(%rip), %rsi      # 0xb854
movq %rbx, %rdi
callq 0x821c
movl $0x4, 0x8(%rax)
leaq 0x3bd7(%rip), %rsi      # 0xb859
movq %rbx, %rdi
callq 0x821c
andl $0x0, 0x8(%rax)
movq %rax, 0x8603(%rip)      # 0x10298
leaq 0x3bc2(%rip), %rsi      # 0xb85e
movq %rbx, %rdi
callq 0x821c
movl $0x5, 0x8(%rax)
leaq 0x3bb2(%rip), %rsi      # 0xb864
movq %rbx, %rdi
callq 0x821c
movl $0x6, 0x8(%rax)
movq %rax, 0x85d8(%rip)      # 0x102a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rdi
cmpq $0xa0, %r15
je 0x7d38
movq (%rdi,%r15,8), %rax
testq %rax, %rax
je 0x7d33
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x7d10
movq (%r14), %rdi
movq 0x20(%r14), %r12
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r12, %r14
jmp 0x7cf2
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpl $0x8, 0x8(%rdi)
jne 0x7d2e
movq (%rdi), %rdi
callq 0x1030
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1030
incq %r15
jmp 0x7cd8
callq 0x1030
xorl %r14d, %r14d
movl 0x18(%rbx), %eax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jae 0x7d5a
movq (%rdi,%r14,8), %rdi
callq 0x7d72
incq %r14
jmp 0x7d40
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x9c10
movq (%r14), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x820e
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0x8211
movq 0x20(%r14), %r14
jmp 0x81f4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x9c10
movq (%r15), %r13
movl %eax, %r12d
movq (%r13,%r12,8), %rax
testq %rax, %rax
je 0x829a
xorl %r14d, %r14d
movq %rax, %r15
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0x82cd
movq 0x20(%r15), %rax
testq %rax, %rax
jne 0x8249
pushq $0x28
popq %rdi
callq 0x1180
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0x828c
leaq 0x1dab(%rip), %rdi      # 0xa027
leaq 0x360b(%rip), %rsi      # 0xb88e
callq 0x9287
movq 0x20(%r15), %rax
movq %rbx, (%rax)
andq $0x0, 0x20(%rax)
movq 0x20(%r15), %r14
jmp 0x82cd
pushq $0x28
popq %rdi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
jne 0x82c0
leaq 0x1d76(%rip), %rdi      # 0xa027
leaq 0x35d6(%rip), %rsi      # 0xb88e
callq 0x9287
movq (%r15), %r13
movq %rbx, (%r14)
andq $0x0, 0x20(%r14)
movq %r14, (%r13,%r12,8)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
pushq $0x48
popq %rdi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
jne 0x863c
leaq 0x19f7(%rip), %rdi      # 0xa027
leaq 0x3412(%rip), %rsi      # 0xba49
callq 0x9287
movl %ebp, (%r14)
movq (%rbx), %rax
movl 0x28(%rax), %ecx
movl %ecx, 0x4(%r14)
movl 0x2c(%rax), %eax
movl %eax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
cmpl $0x22, 0x30(%rdi)
jne 0x8699
callq 0x95cd
movq %r14, %rdi
callq 0x87af
movq %rax, %rbx
movq (%r14), %rax
cmpl $0x23, 0x30(%rax)
je 0x87a0
pushq $0x29
popq %rsi
movq %r14, %rdi
callq 0x8bcb
jmp 0x87a0
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x8610
movq %rax, %rbx
movq (%r14), %r15
movl 0x30(%r15), %eax
decl %eax
cmpl $0x5, %eax
ja 0x8716
leaq 0x30ec(%rip), %rcx      # 0xb7a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x10(%rbx)
movq 0x40(%r15), %rdi
cmpq $0x21, %rdi
jb 0x86f2
movq 0x38(%r15), %rdx
leaq 0x33e4(%rip), %rsi      # 0xbac5
movq %r15, %rdi
xorl %eax, %eax
callq 0x919e
movq (%r14), %r15
movq 0x40(%r15), %rdi
incq %rdi
callq 0x1180
movq %rax, %r12
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x877f
leaq 0x191a(%rip), %rdi      # 0xa027
leaq 0x33e3(%rip), %rsi      # 0xbaf7
jmp 0x8777
leaq 0x3339(%rip), %rsi      # 0xba56
movq %r15, %rdi
xorl %eax, %eax
callq 0x919e
jmp 0x87a0
movl $0x3, 0x10(%rbx)
movsd 0x48(%r15), %xmm0
movsd %xmm0, 0x18(%rbx)
jmp 0x87a0
movl $0x2, 0x10(%rbx)
movq 0x48(%r15), %rax
jmp 0x879c
movl $0x5, 0x10(%rbx)
movq 0x40(%r15), %rdi
incq %rdi
callq 0x1180
movq %rax, %r12
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x877f
leaq 0x18b7(%rip), %rdi      # 0xa027
leaq 0x3395(%rip), %rsi      # 0xbb0c
callq 0x9287
movq (%r14), %r15
movq 0x38(%r15), %rsi
movq %r12, %rdi
callq 0x1050
jmp 0x87a0
movl $0x2, 0x10(%rbx)
movq 0x38(%r15), %rax
movsbq (%rax), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
callq 0x8c08
movq %rax, %r14
pushq $0x4
popq %rbp
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
cmpl $0x1b, %r12d
je 0x87d8
cmpl $0xf, %r12d
jne 0x8803
callq 0x95cd
movq %rbx, %rdi
callq 0x8c08
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movl %r12d, 0x10(%rax)
movq %rax, %r14
jmp 0x87c5
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8c62
movq %rax, %r14
pushq $0x2
popq %rbp
movq (%rbx), %rdi
cmpl $0x7, 0x30(%rdi)
jne 0x8c54
callq 0x95cd
movq %rbx, %rdi
callq 0x8c62
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movl $0x7, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r14
jmp 0x8c1d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8cbc
movq %rax, %r14
pushq $0x2
popq %rbp
movq (%rbx), %rdi
cmpl $0x8, 0x30(%rdi)
jne 0x8cae
callq 0x95cd
movq %rbx, %rdi
callq 0x8cbc
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movl $0x8, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r14
jmp 0x8c77
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x8d1a
movq %rax, %r14
pushq $0x2
popq %rbp
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0xd(%r12), %eax
cmpl $0x1, %eax
ja 0x8d0e
callq 0x95cd
movq %rbx, %rdi
callq 0x8d1a
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r14
jmp 0x8cd2
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x8d78
movq %rax, %r14
pushq $0x2
popq %rbp
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x9(%r12), %eax
cmpl $0x3, %eax
ja 0x8d6c
callq 0x95cd
movq %rbx, %rdi
callq 0x8d78
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r14
jmp 0x8d30
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_shifts
static struct Opp_Node* opp_parse_shifts(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_order1(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* result = NULL;

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

	while (operator == TSHL || operator == TSHR)
	{
		opp_next(parser->lex);
		right = opp_parse_order1(parser);

		result = opp_new_node(parser, EBIT);
		result->bin_expr.tok = operator;
		result->bin_expr.left = left;
		result->bin_expr.right = right;

		left = result;

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

	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x8dd6
movq %rax, %r14
pushq $0xe
popq %rbp
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x2b(%r12), %eax
cmpl $0x1, %eax
ja 0x8dca
callq 0x95cd
movq %rbx, %rdi
callq 0x8dd6
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r14
jmp 0x8d8e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_order1
static struct Opp_Node* opp_parse_order1(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_order2(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* result = NULL;

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

	while (operator == TADD || operator == TMIN)
	{
		opp_next(parser->lex);
		right = opp_parse_order2(parser);

		result = opp_new_node(parser, EBIN);
		result->bin_expr.tok = operator;
		result->bin_expr.left = left;
		result->bin_expr.right = right;

		left = result;

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

	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x8e34
movq %rax, %r14
pushq $0x1
popq %rbp
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x13(%r12), %eax
cmpl $0x1, %eax
ja 0x8e28
callq 0x95cd
movq %rbx, %rdi
callq 0x8e34
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r14
jmp 0x8dec
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_order2
static struct Opp_Node* opp_parse_order2(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_before(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* result = NULL;

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

	while (operator == TDIV || operator == TMUL || 
		operator == TMOD)
	{
		opp_next(parser->lex);
		right = opp_parse_before(parser);

		result = opp_new_node(parser, EBIN);
		result->bin_expr.tok = operator;
		result->bin_expr.left = left;
		result->bin_expr.right = right;

		left = result;

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

	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x8e92
movq %rax, %r14
pushq $0x1
popq %rbp
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x15(%r12), %eax
cmpl $0x2, %eax
ja 0x8e86
callq 0x95cd
movq %rbx, %rdi
callq 0x8e92
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8610
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r14
jmp 0x8e4a
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_block
static struct Opp_Node* opp_parse_block(struct Opp_Parser* parser)
{
	int block_init_size = 64;
	struct Opp_Node* block = opp_new_node(parser, STMT_BLOCK);
	block->block_stmt.stmts = calloc(block_init_size, sizeof(struct Opp_Node*));

	if (block->block_stmt.stmts == NULL)
		INTERNAL_ERROR("Malloc fail");

	opp_next(parser->lex);
	int index = 0;

	while (parser->lex->t.id != TCLOSEC && parser->lex->t.id != FEND) {
		if (index == block_init_size)
		{
			block->block_stmt.stmts = (struct Opp_Node**)realloc(block->block_stmt.stmts, 
					(64+block_init_size) * sizeof(struct Opp_Node*));
			if (block == NULL)
				INTERNAL_ERROR("Malloc Fail");
			block_init_size += 64;
		}
		block->block_stmt.stmts[index] = opp_parse_statement(parser);
		index++;

		opp_next(parser->lex);
	}

	block->block_stmt.stmts[index] = NULL;
	block->block_stmt.len = index;

	if (parser->lex->t.id != TCLOSEC || parser->lex->t.id == FEND)
		opp_error(parser->lex, "Expected terminating '}' after block statement\n");

	return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
pushq $0x12
popq %rsi
callq 0x8610
movq %rax, %rbx
pushq $0x40
popq %rdi
pushq $0x8
popq %rsi
callq 0x1130
movq %rax, %r15
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x90bc
leaq 0xf77(%rip), %rdi       # 0xa027
leaq 0x2ad5(%rip), %rsi      # 0xbb8c
callq 0x9287
pushq $0x40
popq %rbp
xorl %r12d, %r12d
movq (%r14), %rdi
callq 0x95cd
movq (%r14), %rax
movl 0x30(%rax), %eax
cmpl $0x28, %eax
je 0x910f
cmpl $0x40, %eax
je 0x910f
movl %ebp, %eax
cmpq %rax, %r12
jne 0x90fe
movslq %ebp, %rax
addl $0x40, %ebp
leaq 0x200(,%rax,8), %rsi
movq %r15, %rdi
callq 0x11a0
movq %rax, %r15
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x880f
movq %rax, (%r15,%r12,8)
incq %r12
jmp 0x90c2
movl %r12d, %eax
andq $0x0, (%r15,%rax,8)
movl %r12d, 0x18(%rbx)
movq (%r14), %rdi
cmpl $0x28, 0x30(%rdi)
je 0x9132
leaq 0x2a71(%rip), %rsi      # 0xbb9c
xorl %eax, %eax
callq 0x919e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_expr
static struct Opp_Node* opp_parse_expr(struct Opp_Parser* parser)
{
	struct Opp_Node* new_expr = opp_parse_allign(parser);

	if (parser->lex->t.id != TSEMICOLON) 
		opp_error(parser->lex, "Expected ';' after expression");

	return new_expr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x87af
movq %rax, %rbx
movq (%r14), %rdi
cmpl $0x2a, 0x30(%rdi)
je 0x9164
leaq 0x2bcd(%rip), %rsi      # 0xbd2a
xorl %eax, %eax
callq 0x919e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: hex2i64
uint64_t hex2i64(char *str)
{
	uint64_t res = 0;
	char c;

	while ((c = *str++)) {
		char v = (c & 0xF) + (c >> 6) | ((c >> 3) & 0x8);
		res = (res << 4) | (uint64_t) v;
	}

	return res;
}

// Assembly:
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x919d
incq %rdi
movl %ecx, %edx
andl $0xf, %edx
movl %ecx, %esi
shrl $0x6, %esi
addl %edx, %esi
shrl $0x3, %ecx
andl $0x8, %ecx
orl %esi, %ecx
shlq $0x4, %rax
movsbq %cl, %rcx
orq %rcx, %rax
jmp 0x9172
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_error
void opp_error(struct Opp_Scan* s, const char* str, ...)
{
	va_list ap;
	va_start(ap, str);
	
	printf("%s:%u:%u ", s->io.fname, s->line, s->colum);
	#ifdef UNX
		printf(CL_RED);
	#endif

	printf("error: \n\t");
	printf(CL_RESET); 
	vfprintf(stdout, str, ap);
	fprintf(stdout, "\n");
	va_end(ap);
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x91fd
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0x10(%rdi), %rsi
movl 0x28(%rdi), %edx
movl 0x2c(%rdi), %ecx
leaq 0x141e(%rip), %rdi      # 0xa64c
xorl %eax, %eax
callq 0x10e0
leaq 0xf92(%rip), %rdi       # 0xa1ce
xorl %eax, %eax
callq 0x10e0
leaq 0x2cde(%rip), %rdi      # 0xbf28
xorl %eax, %eax
callq 0x10e0
leaq 0x1035(%rip), %rdi      # 0xa28d
xorl %eax, %eax
callq 0x10e0
movq 0x6d7a(%rip), %r15      # 0xffe0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x11f0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1120
pushq $0x1
popq %rdi
callq 0x1210
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: internal_error
void internal_error(const char* str, const char* func)
{
	#ifdef UNX 
	printf(CL_RED); 
	#endif 
	printf("** Error: %s [%s] **\n", str, func); 
	#ifdef UNX 
	printf(CL_RESET); 
	#endif 
	exit(1); 
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf36(%rip), %rdi       # 0xa1ce
xorl %eax, %eax
callq 0x10e0
leaq 0x2c8c(%rip), %rdi      # 0xbf32
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10e0
leaq 0xfd3(%rip), %rdi       # 0xa28d
xorl %eax, %eax
callq 0x10e0
pushq $0x1
popq %rdi
callq 0x1210
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: is_keyword
bool is_keyword(struct Opp_Scan* s)
{
	for (int i = 0; i < OPP_KEYOWRDS; i++) {
		if (!strcmp(opp_keywords[i].key, s->t.buffer.buf)) {
			s->t.id = opp_keywords[i].id;
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
leaq 0x6a11(%rip), %r15      # 0xfcf0
xorl %ecx, %ecx
movq %rcx, %r12
cmpq $0x10, %rcx
je 0x9309
movq (%r15), %rdi
movq %r14, %rsi
callq 0x1140
leaq 0x1(%r12), %rcx
addq $0x10, %r15
testl %eax, %eax
jne 0x92e1
movl -0x8(%r15), %eax
movl %eax, 0x30(%rbx)
cmpq $0x10, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: realloc_buf
void realloc_buf(struct Opp_Scan* s)
{
	s->t.buffer.len += 32;
	char* temp = realloc(s->t.buffer.buf, s->t.buffer.len);
	if (temp == NULL)
		INTERNAL_ERROR("malloc fail");
	s->t.buffer.buf = temp;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq 0x40(%rbx), %rsi
addq $0x20, %rsi
movq %rsi, 0x40(%rbx)
callq 0x11a0
testq %rax, %rax
je 0x9340
movq %rax, 0x38(%rbx)
popq %rbx
retq
leaq 0x2c01(%rip), %rdi      # 0xbf48
leaq 0x2c06(%rip), %rsi      # 0xbf54
callq 0x9287
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: init_opp_file
void init_opp_file(struct Opp_Scan* s, const char* fname)
{
	s->io.fname = fname;
	s->io.file = fopen(fname, "r");

	if (!s->io.file) {
		printf("Error opening file '%s'\n", fname);
		exit(1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x10(%rdi)
leaq 0x24e0(%rip), %rsi      # 0xb848
movq %rbx, %rdi
callq 0x11e0
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x9381
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2bd8(%rip), %rdi      # 0xbf60
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
pushq $0x1
popq %rdi
callq 0x1210
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: init_opp_lex
void init_opp_lex(struct Opp_Scan* s, char* content)
{
	s->line = 1;
	s->colum = 0;
	s->src = content;
	s->content = content;
	s->t.buffer.buf = (char*)malloc(SCAN_BUF);
	if (s->t.buffer.buf == NULL)
		INTERNAL_ERROR("malloc fail");

	s->t.buffer.len = SCAN_BUF;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq $0x1, 0x28(%rdi)
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
pushq $0x20
popq %rdi
callq 0x1180
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x93c8
movq $0x20, 0x40(%rbx)
popq %rbx
retq
leaq 0x2b79(%rip), %rdi      # 0xbf48
leaq 0x2ba3(%rip), %rsi      # 0xbf79
callq 0x9287
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_free_lex
void opp_free_lex(struct Opp_Scan* s, bool alloc)
{
	free(s->content);
	free(s->t.buffer.buf);

	if (alloc)
		free(s);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1030
movq 0x38(%rbx), %rdi
callq 0x1030
testl %ebp, %ebp
je 0x9407
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_lex_identifier
void opp_lex_identifier(struct Opp_Scan* s)
{
	unsigned int idx = 0;
	while (isletter(*s->src) || isnum(*s->src)) {

		if (idx > s->t.buffer.len)
			realloc_buf(s);

		s->t.buffer.buf[idx] = *s->src;
		idx++;
		INCR;
	}
	s->t.buffer.buf[idx] = '\0';
	if (is_keyword(s))
		return;
	s->t.id = TIDENT;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
xorl %ebp, %ebp
movb (%rax), %al
leal -0x30(%rax), %ecx
movl %ebp, %r14d
cmpb $0xa, %cl
jb 0x9438
cmpb $0x5f, %al
je 0x9438
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x9463
cmpq %r14, 0x40(%rbx)
jae 0x944b
movq %rbx, %rdi
callq 0x931c
movq (%rbx), %rax
movb (%rax), %al
movq 0x38(%rbx), %rcx
movb %al, (%rcx,%r14)
incl %ebp
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
incl 0x2c(%rbx)
jmp 0x941a
movq 0x38(%rbx), %rax
movb $0x0, (%rax,%r14)
movq %rbx, %rdi
callq 0x92c9
testb %al, %al
jne 0x947f
movl $0x1, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_lex_hex
void opp_lex_hex(struct Opp_Scan* s)
{
	unsigned int idx = 0;
	s->t.id = TINTEGER;
	INCR;
	while (isletter(*s->src) || isnum(*s->src)) {
		s->t.buffer.buf[idx] = *s->src;
		idx++;
		INCR;
	}
	s->t.buffer.buf[idx] = '\0';
	s->t.num = hex2i64(s->t.buffer.buf);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x30(%rdi)
movq (%rdi), %rax
incq %rax
movq %rax, (%rdi)
xorl %ecx, %ecx
incl 0x2c(%rbx)
movb (%rax), %al
leal -0x30(%rax), %esi
movq 0x38(%rbx), %rdx
movl %ecx, %ecx
cmpb $0xa, %sil
jb 0x94c2
cmpb $0x5f, %al
je 0x94c2
movl %eax, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x94d2
movb %al, (%rdx,%rcx)
incl %ecx
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
jmp 0x949a
movb $0x0, (%rdx,%rcx)
movq 0x38(%rbx), %rdi
callq 0x9170
movq %rax, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_lex_numeral
void opp_lex_numeral(struct Opp_Scan* s)
{
	unsigned int idx = 0;
	s->t.id = TINTEGER;
	INCR;
	if (*s->src == 'x' || *s->src == 'X') {
		opp_lex_hex(s);
		return;
	} 
	else {
		DECR;
	} 

	while (isnum(*s->src) || *s->src == '.') {
		if (*s->src == '.') s->t.id = TFLOAT;
		s->t.buffer.buf[idx] = *s->src;
		idx++;
		INCR;
	}
	s->t.buffer.buf[idx] = '\0';

	switch (s->t.id)
	{
		case TINTEGER: 
			s->t.num = atol(s->t.buffer.buf);
			break;

		case TFLOAT:
			s->t.real = atof(s->t.buffer.buf);
			break;

		default: break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x30(%rdi)
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movl 0x2c(%rdi), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x2c(%rdi)
movzbl 0x1(%rax), %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x9518
movq %rbx, %rdi
popq %rbx
jmp 0x9484
movq %rax, (%rbx)
xorl %ecx, %ecx
movl %edx, 0x2c(%rbx)
movb (%rax), %sil
leal -0x30(%rsi), %edi
movl %ecx, %edx
cmpb $0xa, %dil
jb 0x953e
cmpb $0x2e, %sil
jne 0x9558
movl $0x3, 0x30(%rbx)
movb (%rax), %sil
movq 0x38(%rbx), %rax
movb %sil, (%rax,%rdx)
incl %ecx
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
movl 0x2c(%rbx), %edx
incl %edx
jmp 0x951d
movq 0x38(%rbx), %rax
movb $0x0, (%rax,%rdx)
movl 0x30(%rbx), %eax
cmpl $0x3, %eax
je 0x957c
cmpl $0x2, %eax
jne 0x958a
movq 0x38(%rbx), %rdi
callq 0x11c0
movq %rax, 0x48(%rbx)
jmp 0x958a
movq 0x38(%rbx), %rdi
callq 0x1080
movsd %xmm0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_peek_tok
void opp_peek_tok(struct Opp_Scan* s, int times)
{
	char* temp = s->src;
	uint32_t tline = s->line, tcolum = s->colum;

	for (int i = 0; i < times; i++)
		opp_next(s);

	s->src = temp;
	s->line = tline;
	s->colum = tcolum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x28(%rdi), %ebp
movl 0x2c(%rdi), %r15d
xorl %r12d, %r12d
testl %esi, %esi
cmovgl %esi, %r12d
subl $0x1, %r12d
jb 0x95ba
movq %rbx, %rdi
callq 0x95cd
jmp 0x95aa
movq %r14, (%rbx)
movl %ebp, 0x28(%rbx)
movl %r15d, 0x2c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_next
void opp_next(struct Opp_Scan* s)
{
	memset(s->t.buffer.buf, 0, s->t.buffer.len);
	while (*s->src)
	{
		if (*s->src == '\n') {
			s->line++;
			s->colum = 0;
		}
		else if (ignore(*s->src)) {}
		else if (*s->src == '/') {
			INCR;
			if (*s->src == '/') {
				while (*s->src != '\n' && *s->src) {
					s->src++;
				}
				s->colum = 0;
				s->line++;
			}
			else if (*s->src == '*') {
				opp_long_comment(s);
			}
			else {
				s->t.id = TDIV;
				return;
			}
		}
		else if (isletter(*s->src)) {
			opp_lex_identifier(s); 
			return;
		}
		else if (*s->src == '\"') {
			opp_lex_str(s);
			return;
		}
		else if (isnum(*s->src)) {
			opp_lex_numeral(s);
			return;
		}
		else {
			enum Opp_Token res = opp_lex_char(s);
			if (res == INVALID) 
				opp_error(s, "Invalid token found '%c'", *s->src);
			s->t.id = res;
			INCR;
			return;
		}

		s->colum++;
		s->src++;
	}
	s->t.id = FEND;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq 0x40(%rbx), %rdx
xorl %esi, %esi
callq 0x1110
movq (%rbx), %rax
pushq $0x1
popq %rcx
movzbl (%rax), %edx
cmpl $0x9, %edx
je 0x96bc
cmpl $0xa, %edx
je 0x9650
cmpl $0xd, %edx
je 0x96bc
cmpl $0x20, %edx
je 0x96bc
cmpl $0x2f, %edx
jne 0x96ca
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movl 0x2c(%rbx), %edx
incl %edx
movl %edx, 0x2c(%rbx)
movzbl 0x1(%rax), %esi
cmpl $0x2a, %esi
je 0x9659
cmpl $0x2f, %esi
jne 0x96fd
addq $0x2, %rax
testb %sil, %sil
je 0x96b2
movzbl %sil, %edx
cmpl $0xa, %edx
je 0x96b2
movq %rax, (%rbx)
movb (%rax), %sil
incq %rax
jmp 0x9637
incl 0x28(%rbx)
andl $0x0, 0x2c(%rbx)
jmp 0x96bc
leaq 0x2(%rax), %rsi
movq %rsi, (%rbx)
addq $0x3, %rax
movl %ecx, %esi
testl %esi, %esi
je 0x96b9
movzbl -0x1(%rax), %edi
cmpl $0xa, %edi
je 0x9693
cmpl $0x2a, %edi
je 0x969a
cmpl $0x2f, %edi
je 0x9686
testl %edi, %edi
jne 0x96a5
jmp 0x972e
xorl %edi, %edi
cmpb $0x2a, (%rax)
sete %dil
addl %edi, %esi
jmp 0x96a5
incl 0x28(%rbx)
xorl %edx, %edx
jmp 0x96a5
xorl %edi, %edi
cmpb $0x2f, (%rax)
sete %dil
subl %edi, %esi
movq %rax, (%rbx)
incl %edx
movl %edx, 0x2c(%rbx)
incq %rax
jmp 0x9666
andl $0x0, 0x2c(%rbx)
incl 0x28(%rbx)
decq %rax
incl 0x2c(%rbx)
incq %rax
movq %rax, (%rbx)
jmp 0x95e6
testl %edx, %edx
jne 0x96d7
movl $0x40, 0x30(%rbx)
jmp 0x972c
cmpb $0x5f, %dl
je 0x96f4
movl %edx, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x96f4
cmpb $0x22, %dl
jne 0x9706
movq %rbx, %rdi
popq %rbx
jmp 0x9756
movq %rbx, %rdi
popq %rbx
jmp 0x940e
movl $0x15, 0x30(%rbx)
jmp 0x972c
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x9717
movq %rbx, %rdi
popq %rbx
jmp 0x94e5
movq %rbx, %rdi
callq 0x9829
testl %eax, %eax
je 0x973f
movl %eax, 0x30(%rbx)
incq (%rbx)
incl 0x2c(%rbx)
popq %rbx
retq
leaq 0x294d(%rip), %rsi      # 0xc082
movq %rbx, %rdi
xorl %eax, %eax
callq 0x919e
movq (%rbx), %rax
movsbl (%rax), %edx
leaq 0x289f(%rip), %rsi      # 0xbfeb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x919e
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_lex_str
void opp_lex_str(struct Opp_Scan* s)
{
	INCR;
	unsigned int idx = 0;
	while (*s->src != '"') {
		if (idx >= s->t.buffer.len)
			realloc_buf(s);

		if (*s->src == EOF || *s->src == '\n')
			opp_error(s, "Expected terminating '\"' in string");
		else if (*s->src == '\\') {
			INCR;
			switch (*s->src) {
				case 'n': 
					s->t.buffer.buf[idx] = '\n';
					break;

				case 't':
					s->t.buffer.buf[idx] = '\t';
					break;

				case '\\':
					s->t.buffer.buf[idx] = '\\';
					break;

				case '"':
					s->t.buffer.buf[idx] = '\"';
					break;

				default:
					opp_error(s, "Invalid escape character '%c'", *s->src);
			}
		}
		else
			s->t.buffer.buf[idx] = *s->src;
		idx++;
		s->src++;
		s->colum++;
	}
	INCR;
	s->t.buffer.buf[idx] = '\0';
	s->t.id = TSTR;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
incq %rax
movq %rax, (%rdi)
xorl %ebp, %ebp
movl 0x2c(%rbx), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x2c(%rbx)
movb (%rax), %cl
movl %ebp, %r14d
cmpb $0x22, %cl
je 0x97e3
cmpq %r14, 0x40(%rbx)
ja 0x978e
movq %rbx, %rdi
callq 0x931c
movq (%rbx), %rax
movb (%rax), %cl
cmpb $0x5c, %cl
je 0x97a4
movzbl %cl, %eax
cmpl $0xff, %eax
je 0x9804
cmpl $0xa, %eax
jne 0x97ce
jmp 0x9804
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
incl 0x2c(%rbx)
movzbl 0x1(%rax), %eax
cmpl $0x22, %eax
je 0x97cc
cmpl $0x5c, %eax
je 0x97cc
movb $0xa, %cl
cmpl $0x6e, %eax
je 0x97ce
cmpl $0x74, %eax
jne 0x9815
movb $0x9, %cl
jmp 0x97ce
movl %eax, %ecx
movq 0x38(%rbx), %rax
movb %cl, (%rax,%r14)
incl %ebp
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
jmp 0x9768
incq %rax
movq %rax, (%rbx)
addl $0x2, %edx
movl %edx, 0x2c(%rbx)
movq 0x38(%rbx), %rax
movb $0x0, (%rax,%r14)
movl $0x5, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x277b(%rip), %rsi      # 0xbf86
movq %rbx, %rdi
xorl %eax, %eax
callq 0x919e
movsbl %al, %edx
leaq 0x278a(%rip), %rsi      # 0xbfa9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x919e