LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0xb110(%rip), %rax      # 0x192b0
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0xe1d1
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xe1b2
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0xb0b3(%rip), %rax      # 0x192b0
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jb 0xe2b8
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0xe253
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0xb063(%rip), %rax      # 0x192b0
movq %rcx, 0x10(%rax)
jmp 0xe28c
callq 0xe380
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xe279
movq $0x0, 0x20(%rsp)
jmp 0xe2c2
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0xb028(%rip), %rax      # 0x192b0
movq %rcx, 0x10(%rax)
movq 0xb01d(%rip), %rax      # 0x192b0
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0xb004(%rip), %rax      # 0x192b0
movq 0x10(%rax), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq 0xaf95(%rip), %rax      # 0x192b0
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xe35d
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xe324
movq 0xaf4c(%rip), %rdi      # 0x192b0
callq 0x1030
movq $0x0, 0xaf3c(%rip) # 0x192b0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0xfa00, %edi           # imm = 0xFA00
callq 0x1160
movq %rax, (%rsp)
movl $0x20, %edi
callq 0x1160
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xe3c1
cmpq $0x0, (%rsp)
jne 0xe3cc
movq $0x0, 0x10(%rsp)
jmp 0xe410
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rcx
addq $0xfa00, %rcx           # imm = 0xFA00
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x38, %edi
callq 0x1160
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movl $0x40, %edi
movl $0x8, %esi
callq 0x1100
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq $0x40, 0x10(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe481
jmp 0xe4d7
movl $0x500, %edi            # imm = 0x500
callq 0x1160
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xe4a3
jmp 0xe4d7
movq (%rsp), %rax
movq $0xa0, 0x28(%rax)
movq (%rsp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
movl $0x500, %edx            # imm = 0x500
callq 0x10f0
movq (%rsp), %rdi
callq 0xe500
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xe4f3
leaq 0x512a(%rip), %rdi      # 0x13608
leaq 0x6477(%rip), %rsi      # 0x1495c
callq 0x114a0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x6464(%rip), %rsi      # 0x1497d
callq 0xee20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0xad7d(%rip)      # 0x192b8
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x6437(%rip), %rsi      # 0x14982
callq 0xee20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x2, 0x8(%rax)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x6417(%rip), %rsi      # 0x14988
callq 0xee20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0xad2d(%rip)      # 0x192c0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x63e9(%rip), %rsi      # 0x1498c
callq 0xee20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x4, 0x8(%rax)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x63c8(%rip), %rsi      # 0x14991
callq 0xee20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0xacdd(%rip)      # 0x192c8
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x639b(%rip), %rsi      # 0x14996
callq 0xee20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x5, 0x8(%rax)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x637b(%rip), %rsi      # 0x1499c
callq 0xee20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x6, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0xac8d(%rip)      # 0x192d0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0xa0, 0x1c(%rsp)
jae 0xe732
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xe720
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xe6da
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
jmp 0xe6a1
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x8, 0x8(%rax)
jne 0xe70a
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0xe722
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xe661
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0xe779
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0xe7a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe748
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parser_begin
void opp_parser_begin(struct Opp_Parser* parser)
{
	if (parser == NULL)
		return;

	for (;;) {
		opp_next(parser->lex);
		if (parser->lex->t.id == FEND)
			break;

		struct Opp_Node* stmt = opp_parse_global_def(parser);

		if (parser->nstmts == parser->stmt_size) {
			parser->statments = (struct Opp_Node**)
				realloc(parser->statments, (64+parser->stmt_size) * sizeof(struct Opp_Node*));

			if (parser->statments == NULL)
				INTERNAL_ERROR("Malloc Fail");

			parser->stmt_size += 64;
		}

		parser->statments[parser->nstmts] = stmt;
		parser->nstmts++;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xebc6
jmp 0xec92
jmp 0xebc8
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x40, 0x30(%rax)
jne 0xebe8
jmp 0xec92
movq 0x10(%rsp), %rdi
callq 0xeca0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xec65
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
addq $0x40, %rsi
shlq $0x3, %rsi
callq 0x1180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xec54
leaq 0x49c0(%rip), %rdi      # 0x13608
leaq 0x5d1d(%rip), %rsi      # 0x1496c
callq 0x114a0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x18(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0xebc8
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_global_def
static struct Opp_Node* opp_parse_global_def(struct Opp_Parser* parser)
{
	switch (parser->lex->t.id)
	{
		// Structs / Extern etc...
		case TUNSIGNED:
		case TIDENT:
			return opp_parse_type(parser);

		case TEXTERN:
			return opp_parse_extern(parser);

		case TIMPORT:
			return opp_parse_import(parser);

		case TSTRUCT:
			return opp_parse_struct(parser);

		default:
			opp_error(parser->lex, 
				"Error unexpected global declaration '%s'", parser->lex->t.buffer.buf);
	}

	return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0xeceb
jmp 0xecbf
movl 0x4(%rsp), %eax
subl $0x38, %eax
je 0xed1e
jmp 0xecca
movl 0x4(%rsp), %eax
subl $0x3a, %eax
je 0xecfc
jmp 0xecd5
movl 0x4(%rsp), %eax
subl $0x3b, %eax
je 0xed0d
jmp 0xece0
movl 0x4(%rsp), %eax
subl $0x3f, %eax
jne 0xed2f
jmp 0xeceb
movq 0x8(%rsp), %rdi
callq 0xefb0
movq %rax, 0x10(%rsp)
jmp 0xed5a
movq 0x8(%rsp), %rdi
callq 0xf140
movq %rax, 0x10(%rsp)
jmp 0xed5a
movq 0x8(%rsp), %rdi
callq 0xf1c0
movq %rax, 0x10(%rsp)
jmp 0xed5a
movq 0x8(%rsp), %rdi
callq 0xf260
movq %rax, 0x10(%rsp)
jmp 0xed5a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdx
leaq 0x5c85(%rip), %rsi      # 0x149cf
movb $0x0, %al
callq 0x11370
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0x12930
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xee06
jmp 0xedb4
cmpq $0x0, (%rsp)
je 0xee04
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0xeddc
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xee0f
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0xedf5
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
jmp 0xee00
movq $0x0, 0x20(%rsp)
jmp 0xee0f
jmp 0xee02
jmp 0xedb4
jmp 0xee06
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0x12930
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xef31
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xef2f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0xeea4
movq $0x0, 0x30(%rsp)
jmp 0xef9f
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xef1a
movl $0x28, %edi
callq 0x1160
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xeee5
leaq 0x414e(%rip), %rdi      # 0x13027
leaq 0x5ae6(%rip), %rsi      # 0x149c6
callq 0x114a0
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xef9f
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xef2a
jmp 0xee73
jmp 0xef96
movl $0x28, %edi
callq 0x1160
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xef5b
leaq 0x40d8(%rip), %rdi      # 0x13027
leaq 0x5a70(%rip), %rsi      # 0x149c6
callq 0x114a0
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xef9f
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_type
static struct Opp_Node* opp_parse_type(struct Opp_Parser* parser)
{
	struct Opp_Type_Decl type = {0};

	if (parser->lex->t.id == TUNSIGNED) {
		opp_next(parser->lex);
		type.unsign = 1;
	}

	type.decl = get_type(&parser->tree, parser->lex->t.buffer.buf);

	if (type.decl == NULL)
		opp_error(parser->lex, "Use of undeclared type '%s'", parser->lex->t.buffer.buf);

	else if ((type.decl->t_type == TYPE_FLOAT || type.decl->t_type == TYPE_DOUBLE 
		|| type.decl->t_type == TYPE_STRUCT) && type.unsign)
		opp_error(parser->lex, "Type '%s' cannot be unsigned", type.decl->id);

	int lookahead = 1;
	do {
		opp_peek_tok(parser->lex, lookahead);
		if (parser->lex->t.id != TMUL && parser->lex->t.id != TIDENT)
			opp_error(parser->lex, "Expected a identifier or '*' got unexpected");
		lookahead++;
	} while (parser->lex->t.id != TIDENT);

	opp_peek_tok(parser->lex, lookahead);

	if (parser->lex->t.id == TOPENP)
		return opp_parse_func(parser, type);
	else
		return opp_parse_var_decl(parser, type);
	
	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x3f, 0x30(%rax)
jne 0xefea
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movb $0x1, 0x14(%rsp)
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rsi
callq 0xed70
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xf035
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdx
leaq 0x59cc(%rip), %rsi      # 0x149f8
movb $0x0, %al
callq 0x11370
jmp 0xf07d
movq 0x8(%rsp), %rax
cmpl $0x5, 0x8(%rax)
je 0xf056
movq 0x8(%rsp), %rax
cmpl $0x6, 0x8(%rax)
je 0xf056
movq 0x8(%rsp), %rax
cmpl $0x8, 0x8(%rax)
jne 0xf07b
testb $0x1, 0x14(%rsp)
je 0xf07b
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0x59a0(%rip), %rsi      # 0x14a14
movb $0x0, %al
callq 0x11370
jmp 0xf07d
movl $0x1, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl 0x4(%rsp), %esi
callq 0x11b40
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x16, 0x30(%rax)
je 0xf0c8
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x1, 0x30(%rax)
je 0xf0c8
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x5970(%rip), %rsi      # 0x14a31
movb $0x0, %al
callq 0x11370
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x1, 0x30(%rax)
jne 0xf085
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl 0x4(%rsp), %esi
callq 0x11b40
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x22, 0x30(%rax)
jne 0xf11b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xf4e0
movq %rax, 0x20(%rsp)
jmp 0xf134
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xf880
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_extern
static struct Opp_Node* opp_parse_extern(struct Opp_Parser* parser)
{
	struct Opp_Node* extrn = opp_new_node(parser, STMT_EXTERN);

	opp_next(parser->lex);

	extrn->extrn_stmt.stmt = opp_parse_type(parser);

	if (extrn->extrn_stmt.stmt->type == STMT_FUNC) {
		if (extrn->extrn_stmt.stmt->fn_stmt.body != NULL)
			opp_error(parser->lex, "Unexpected body in extern function declaration");
	}

	return extrn;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xefb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x16, (%rax)
jne 0xf1b6
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0xf1b4
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x5cfe(%rip), %rsi      # 0x14eab
movb $0x0, %al
callq 0x11370
jmp 0xf1b6
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_import
static struct Opp_Node* opp_parse_import(struct Opp_Parser* parser)
{
	struct Opp_Node* import = opp_new_node(parser, STMT_IMPORT);

	opp_next(parser->lex);

	if (parser->lex->t.id != TSTR)
		opp_error(parser->lex, "Expected file path after import statement");

	opp_add_module(parser, parser->lex->t.buffer.buf);

	opp_next(parser->lex);

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

	return import;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x14, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x5, 0x30(%rax)
je 0xf20e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x5cd3(%rip), %rsi      # 0x14eda
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rsi
callq 0x18e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x2a, 0x30(%rax)
je 0xf255
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x5cb6(%rip), %rsi      # 0x14f04
movb $0x0, %al
callq 0x11370
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_var_decl
static struct Opp_Node* opp_parse_var_decl(struct Opp_Parser* parser, struct Opp_Type_Decl type)
{
	struct Opp_Node* var = opp_new_node(parser, STMT_VAR);

	var->var_stmt.type = type;

	var->var_stmt.type.depth = 0;
	opp_next(parser->lex);
	while (parser->lex->t.id != TIDENT) {
		var->var_stmt.type.depth++;
		opp_next(parser->lex);
	}
	
	var->var_stmt.var = opp_parse_allign(parser);
	//try tree recursion logic with ptr to next
	// var->var_stmt.vars = opp_parse_comma(parser);

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

	return var;
}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x13, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movw $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x1, 0x30(%rax)
je 0xf904
movq 0x8(%rsp), %rax
movw 0x18(%rax), %cx
addw $0x1, %cx
movw %cx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
jmp 0xf8d6
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x2a, 0x30(%rax)
je 0xf93e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x5549(%rip), %rsi      # 0x14e80
movb $0x0, %al
callq 0x11370
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x48, %edi
callq 0x1160
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xf985
leaq 0x36ae(%rip), %rdi      # 0x13027
leaq 0x5201(%rip), %rsi      # 0x14b81
callq 0x114a0
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x2c(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x22, 0x30(%rax)
jne 0xf9f4
movq 0x18(%rsp), %rdi
callq 0xfd60
movq %rax, 0x20(%rsp)
jmp 0xfac5
movq 0x18(%rsp), %rdi
movl $0x5, %esi
callq 0xf950
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x5, %eax
ja 0xfaa5
movq 0x8(%rsp), %rax
leaq 0x4dcf(%rip), %rcx      # 0x14800
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfdc0
jmp 0xfabb
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfe70
jmp 0xfabb
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfea0
jmp 0xfabb
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfed0
jmp 0xfabb
movq 0x10(%rsp), %rax
movl $0x2, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movsbq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0xfabb
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x50da(%rip), %rsi      # 0x14b8e
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10010
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
movb $0x1, %al
cmpl $0xf, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0xfb22
cmpl $0x1b, 0x4(%rsp)
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0xfb2c
jmp 0xfba2
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x10010
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0xfb09
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_statement
static struct Opp_Node* opp_parse_statement(struct Opp_Parser* parser)
{
	switch (parser->lex->t.id)
	{
		case TSEMICOLON:
			opp_error(parser->lex, "Trailing ';' found");
			break;

		case TOPENC:
			return opp_parse_block(parser);

		case TRET:
			return opp_parse_return(parser);

		case TWHILE:
			return opp_parse_while(parser);

		case TGOTO:
			return opp_parse_goto(parser);

		case TIF:
			return opp_parse_if(parser);

		case TFOR:
			return opp_parse_for(parser);

		case TSWITCH:
			return opp_parse_switch(parser);

		case TCASE:
			return opp_parse_case(parser);

		case TBREAK:
			return opp_parse_break(parser);

		case TUNSIGNED:
			return opp_parse_type(parser);

		case TIDENT: 
			if (opp_parse_peak(parser, ':'))
				return opp_parse_label(parser);

			if (get_type(&parser->tree, parser->lex->t.buffer.buf) != NULL)
				return opp_parse_type(parser);
			else 
				return opp_parse_expr(parser);

		default:
			return opp_parse_expr(parser);
	}

	return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3e, %eax
ja 0xfd34
movq (%rsp), %rax
leaq 0x4c38(%rip), %rcx      # 0x14818
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x50b9(%rip), %rsi      # 0x14cb1
movb $0x0, %al
callq 0x11370
jmp 0xfd45
movq 0x8(%rsp), %rdi
callq 0x10ae0
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x10c80
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x10cf0
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x10d80
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x10e20
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x10f40
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x11050
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x11140
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x111e0
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0xefb0
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
movl $0x3a, %esi
callq 0x11220
testb $0x1, %al
jne 0xfce1
jmp 0xfcf2
movq 0x8(%rsp), %rdi
callq 0x11260
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rsi
callq 0xed70
cmpq $0x0, %rax
je 0xfd23
movq 0x8(%rsp), %rdi
callq 0xefb0
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x112b0
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq 0x8(%rsp), %rdi
callq 0x112b0
movq %rax, 0x10(%rsp)
jmp 0xfd4e
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_paran
static struct Opp_Node* opp_parse_paran(struct Opp_Parser* parser)
{
	struct Opp_Node* node = NULL;
	opp_next(parser->lex);

	node = opp_parse_allign(parser);

	if (parser->lex->t.id != TCLOSEP) 
		opp_expect_error(parser, ')');

	return node;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x23, 0x30(%rax)
je 0xfdab
movq 0x10(%rsp), %rdi
movl $0x29, %esi
callq 0xff50
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_identifier
static void opp_parse_identifier(struct Opp_Parser* parser, struct Opp_Node* node)
{
	node->unary_expr.type = TIDENT;

	if (parser->lex->t.buffer.len > 32)
		opp_error(parser->lex, "Identifier declaration exceeds 32 characters '%s'", parser->lex->t.buffer.buf);

	node->unary_expr.val.strval = (char*)malloc(parser->lex->t.buffer.len + 1);

	if (node->unary_expr.val.strval == NULL)
		INTERNAL_ERROR("Malloc fail");

	strcpy(node->unary_expr.val.strval, parser->lex->t.buffer.buf);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpq $0x20, 0x40(%rax)
jbe 0xfe0b
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdx
leaq 0x4df9(%rip), %rsi      # 0x14bfd
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
addq $0x1, %rdi
callq 0x1160
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xfe4b
leaq 0x31e8(%rip), %rdi      # 0x13027
leaq 0x4de9(%rip), %rsi      # 0x14c2f
callq 0x114a0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rsi
callq 0x1040
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_str
static void opp_parse_str(struct Opp_Parser* parser, struct Opp_Node* node)
{
	node->unary_expr.type = TSTR;
	node->unary_expr.val.strval = (char*)malloc(parser->lex->t.buffer.len + 1);

	if (node->unary_expr.val.strval == NULL)
		INTERNAL_ERROR("Malloc fail");

	strcpy(node->unary_expr.val.strval, parser->lex->t.buffer.buf);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x5, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
addq $0x1, %rdi
callq 0x1160
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xff2a
leaq 0x3109(%rip), %rdi      # 0x13027
leaq 0x4d1f(%rip), %rsi      # 0x14c44
callq 0x114a0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rsi
callq 0x1040
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_expect_error
static void opp_expect_error(struct Opp_Parser* parser, char sym)
{
	if (*parser->lex->src >= 33 && *parser->lex->src <= 126)
		opp_error(parser->lex, "Expected matching '%c' but found '%c'",
			sym, *parser->lex->src);
	else {
		char* t = parser->lex->src;
		while (*t <= 32) t--;
		opp_error(parser->lex, "Expected matching '%c' near \"%c\"", sym, *t);
	}
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jl 0xffb1
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jg 0xffb1
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movsbl 0xf(%rsp), %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
leaq 0x4c0e(%rip), %rsi      # 0x14bb6
movb $0x0, %al
callq 0x11370
jmp 0xfffc
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jg 0xffda
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0xffc0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movsbl 0xf(%rsp), %edx
movq (%rsp), %rax
movsbl (%rax), %ecx
leaq 0x4be7(%rip), %rsi      # 0x14bdc
movb $0x0, %al
callq 0x11370
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x100d0
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $0x7, 0x4(%rsp)
jne 0x100c3
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x100d0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x7, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x10049
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10190
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jne 0x10183
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x10190
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x8, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x10109
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10270
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
movb $0x1, %al
cmpl $0xd, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x101e2
cmpl $0xe, 0x4(%rsp)
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x101ec
jmp 0x10262
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x10270
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x101c9
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10370
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
movb $0x1, %al
cmpl $0x9, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x102dc
movb $0x1, %al
cmpl $0xb, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x102dc
movb $0x1, %al
cmpl $0xc, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x102dc
cmpl $0xa, 0x4(%rsp)
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x102e6
jmp 0x1035c
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x10370
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x102a9
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10450
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
movb $0x1, %al
cmpl $0x2b, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x103c2
cmpl $0x2c, 0x4(%rsp)
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x103cc
jmp 0x10442
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x10450
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0xe, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x103a9
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10530
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
movb $0x1, %al
cmpl $0x13, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x104a2
cmpl $0x14, 0x4(%rsp)
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x104ac
jmp 0x10522
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x10530
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x10489
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10620
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
movb $0x1, %al
cmpl $0x15, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x1058f
movb $0x1, %al
cmpl $0x16, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x1058f
cmpl $0x17, 0x4(%rsp)
sete %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x10599
jmp 0x1060f
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x20(%rsp), %rdi
callq 0x10620
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x10569
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)