LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_before
static struct Opp_Node* opp_parse_before(struct Opp_Parser* parser)
{
	struct Opp_Node* value = NULL;
	
	if (parser->lex->t.id == TMIN)
	{
		value = opp_new_node(parser, ESUB);
		opp_next(parser->lex);
		value->sub_expr.unary = opp_parse_order2(parser);

		return value;
	}
	else if (parser->lex->t.id == TMUL)
	{
		value = opp_new_node(parser, EDEREF);
		opp_next(parser->lex);
		value->deref_expr.deref = opp_parse_order2(parser);

		return value;
	}
	else if (parser->lex->t.id == TADDR)
	{
		value = opp_new_node(parser, EADDR);
		opp_next(parser->lex);
		value->addr_expr.addr = opp_parse_order2(parser);

		return value;
	}
	else if (parser->lex->t.id == TSIZEOF)
	{
		value = opp_new_node(parser, ESIZEOF);
		opp_next(parser->lex);
		value->sizeof_expr.expr = opp_parse_order2(parser);

		return value;
	}

	return opp_parse_prefix(parser);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x14, 0x30(%rax)
jne 0x10682
movq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0xf950
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x8(%rsp), %rdi
callq 0x10530
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x10784
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x16, 0x30(%rax)
jne 0x106d3
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0xf950
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x8(%rsp), %rdi
callq 0x10530
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x10784
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x1a, 0x30(%rax)
jne 0x10721
movq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0xf950
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x8(%rsp), %rdi
callq 0x10530
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x10784
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x32, 0x30(%rax)
jne 0x1076f
movq 0x8(%rsp), %rdi
movl $0xb, %esi
callq 0xf950
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x8(%rsp), %rdi
callq 0x10530
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x10784
jmp 0x10771
jmp 0x10773
jmp 0x10775
movq 0x8(%rsp), %rdi
callq 0x10790
movq %rax, 0x10(%rsp)
movq 0x10(%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_comma
static struct Opp_List* opp_parse_comma(struct Opp_Parser* parser)
{
	int i = 0;
	struct Opp_List* list = (struct Opp_List*)malloc(sizeof(struct Opp_List));

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

	list->list = (struct Opp_Node**)malloc(sizeof(struct Opp_Node*)*DEFAULT_LIST_SIZE);

	if (list->list == NULL)
		INTERNAL_ERROR("Malloc fail");

	do {
		if (i == DEFAULT_LIST_SIZE)
			opp_error(parser->lex, "Max auto list variable declaration limit met (8)");

		opp_next(parser->lex);

		if (parser->lex->t.id == FEND || parser->lex->t.id == TCLOSEP)
			break;

		list->list[i] = opp_parse_allign(parser);

		i++;
	} while (parser->lex->t.id == TCOMMA);

	list->length = i;

	return list;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x10, %edi
callq 0x1160
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x10a19
leaq 0x261a(%rip), %rdi      # 0x13027
leaq 0x425c(%rip), %rsi      # 0x14c70
callq 0x114a0
movl $0x40, %edi
callq 0x1160
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x10a4c
leaq 0x25e7(%rip), %rdi      # 0x13027
leaq 0x4229(%rip), %rsi      # 0x14c70
callq 0x114a0
jmp 0x10a4e
cmpl $0x8, 0xc(%rsp)
jne 0x10a6b
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x421c(%rip), %rsi      # 0x14c80
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x40, 0x30(%rax)
je 0x10a94
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x23, 0x30(%rax)
jne 0x10a96
jmp 0x10acd
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, %rdx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x24, 0x30(%rax)
je 0x10a4e
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq (%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_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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x40, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x12, %esi
callq 0xf950
movq %rax, 0x10(%rsp)
movslq 0x1c(%rsp), %rdi
movl $0x8, %esi
callq 0x1100
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x10b3f
leaq 0x24f4(%rip), %rdi      # 0x13027
leaq 0x418a(%rip), %rsi      # 0x14cc4
callq 0x114a0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x28, 0x30(%rcx)
movb %al, 0xb(%rsp)
je 0x10b7b
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $0x40, 0x30(%rax)
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x10b88
jmp 0x10c1c
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jne 0x10be0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x1c(%rsp), %eax
addl $0x40, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x1180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x10(%rsp)
jne 0x10bd5
leaq 0x2a3f(%rip), %rdi      # 0x13608
leaq 0x40f4(%rip), %rsi      # 0x14cc4
callq 0x114a0
movl 0x1c(%rsp), %eax
addl $0x40, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0xfbb0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
jmp 0x10b54
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xc(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $0x28, 0x30(%rax)
jne 0x10c5a
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $0x40, 0x30(%rax)
jne 0x10c70
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x406b(%rip), %rsi      # 0x14cd4
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_return
static struct Opp_Node* opp_parse_return(struct Opp_Parser* parser)
{
	struct Opp_Node* ret = opp_new_node(parser, STMT_RET);

	opp_next(parser->lex);
	if (parser->lex->t.id == TSEMICOLON) 
		ret->ret_stmt.value = NULL;
	else
		ret->ret_stmt.value = opp_parse_expr(parser);

	return ret;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x17, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x2a, 0x30(%rax)
jne 0x10cc7
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x10cdd
movq 0x10(%rsp), %rdi
callq 0x112b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%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_parse_while
static struct Opp_Node* opp_parse_while(struct Opp_Parser* parser)
{
	struct Opp_Node* loop = opp_new_node(parser, STMT_WHILE);

	opp_next(parser->lex);

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

	loop->while_stmt.cond = opp_parse_allign(parser);
	loop->while_stmt.then = opp_parse_statement(parser);

	return loop;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x15, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x22, 0x30(%rax)
je 0x10d3e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3fcd(%rip), %rsi      # 0x14d04
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0xfbb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
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_goto
static struct Opp_Node* opp_parse_goto(struct Opp_Parser* parser)
{
	struct Opp_Node* jmp = opp_new_node(parser, STMT_GOTO);

	opp_next(parser->lex);

	if (parser->lex->t.id != TIDENT)
		opp_error(parser->lex, "Expected label after goto");

	jmp->goto_stmt.name = opp_parse_unary(parser);

	opp_next(parser->lex);

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

	return jmp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x10, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x1, 0x30(%rax)
je 0x10dce
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3f56(%rip), %rsi      # 0x14d1d
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rdi
callq 0xf9c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x2a, 0x30(%rax)
je 0x10e0e
movq 0x10(%rsp), %rdi
movl $0x3b, %esi
callq 0xff50
movq 0x8(%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_if
static struct Opp_Node* opp_parse_if(struct Opp_Parser* parser)
{
	struct Opp_Node* ifstmt = opp_new_node(parser, STMT_IF);

	opp_next(parser->lex);

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

	opp_next(parser->lex);

	ifstmt->if_stmt.cond = opp_parse_allign(parser);

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

	opp_next(parser->lex);

	ifstmt->if_stmt.then = opp_parse_statement(parser);
	ifstmt->if_stmt.other = NULL;

	opp_peek_tok(parser->lex, 1);

	if (parser->lex->t.id == TELSE) {
		opp_next(parser->lex);
		opp_next(parser->lex);
		ifstmt->if_stmt.other = opp_parse_statement(parser);
	}

	return ifstmt;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x11, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x22, 0x30(%rax)
je 0x10e6e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3ed0(%rip), %rsi      # 0x14d37
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x23, 0x30(%rax)
je 0x10eb5
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3e9f(%rip), %rsi      # 0x14d4d
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfbb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x11b40
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x35, 0x30(%rax)
jne 0x10f35
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfbb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
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_for
static struct Opp_Node* opp_parse_for(struct Opp_Parser* parser)
{
	struct Opp_Node* for_loop = opp_new_node(parser, STMT_FOR);

	opp_next(parser->lex);

	if (parser->lex->t.id != TOPENP)
		opp_error(parser->lex, "Expectd '(' after 'for'");

	opp_next(parser->lex);
	for_loop->for_stmt.decl = opp_parse_statement(parser);
	opp_next(parser->lex);
	for_loop->for_stmt.cond = opp_parse_expr(parser);
	opp_next(parser->lex);
	for_loop->for_stmt.expr = opp_parse_allign(parser);

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

	opp_next(parser->lex);

	for_loop->for_stmt.body = opp_parse_statement(parser);

	return for_loop;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x19, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x22, 0x30(%rax)
je 0x10f8e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3de6(%rip), %rsi      # 0x14d6d
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfbb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0x112b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
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 $0x23, 0x30(%rax)
je 0x1101b
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3d71(%rip), %rsi      # 0x14d85
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfbb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%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_switch
static struct Opp_Node* opp_parse_switch(struct Opp_Parser* parser)
{
	struct Opp_Node* swt = opp_new_node(parser, STMT_SWITCH);

	opp_next(parser->lex);

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

	opp_next(parser->lex);
	swt->switch_stmt.cond = opp_parse_allign(parser);

	if (parser->lex->t.id != TCLOSEP)
		opp_error(parser->lex, "Expected ')' after 'switch' condition");

	opp_next(parser->lex);

	if (parser->lex->t.id != TOPENC)
		opp_error(parser->lex, "Expected '{' after 'switch' condition\n\tFormat: switch (...) { \n\t\t\t...\n\t\t}");

	swt->switch_stmt.block = opp_parse_block(parser);

	return swt;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1a, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x22, 0x30(%rax)
je 0x1109e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3d11(%rip), %rsi      # 0x14da8
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x23, 0x30(%rax)
je 0x110e5
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3cf0(%rip), %rsi      # 0x14dce
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x27, 0x30(%rax)
je 0x11116
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3ce5(%rip), %rsi      # 0x14df4
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rdi
callq 0x10ae0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
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_case
static struct Opp_Node* opp_parse_case(struct Opp_Parser* parser)
{
	struct Opp_Node* cond = opp_new_node(parser, STMT_CASE);

	opp_next(parser->lex);

	cond->case_stmt.cond = opp_parse_allign(parser);

	if (parser->lex->t.id != TCOLON)
		opp_error(parser->lex, "Expected colon after 'case' keyword");

	opp_next(parser->lex);
	cond->case_stmt.stmt = opp_parse_statement(parser);

	return cond;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1c, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x1b, 0x30(%rax)
je 0x111a4
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3ca1(%rip), %rsi      # 0x14e3e
movb $0x0, %al
callq 0x11370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x10(%rsp), %rdi
callq 0xfbb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
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_peak
static bool opp_parse_peak(struct Opp_Parser* parser, char ch)
{
	char* temp = parser->lex->src;
	if (*temp == ch)
		return true;
	return false;
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0x11254
movb $0x1, -0x1(%rsp)
jmp 0x11259
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_label
static struct Opp_Node* opp_parse_label(struct Opp_Parser* parser)
{
	struct Opp_Node* label = opp_new_node(parser, STMT_LABEL);

	label->label_stmt.name = opp_parse_unary(parser);
	opp_next(parser->lex);

	return label;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0xf, %esi
callq 0xf950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xf9c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x11bd0
movq 0x8(%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_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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xfad0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x2a, 0x30(%rax)
je 0x112ec
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x3b7d(%rip), %rsi      # 0x14e62
movb $0x0, %al
callq 0x11370
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/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:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb (%rax), %al
movb %al, -0x11(%rsp)
cmpb $0x0, %al
je 0x11365
movsbl -0x11(%rsp), %eax
andl $0xf, %eax
movsbl -0x11(%rsp), %ecx
sarl $0x6, %ecx
addl %ecx, %eax
movsbl -0x11(%rsp), %ecx
sarl $0x3, %ecx
andl $0x8, %ecx
orl %ecx, %eax
movb %al, -0x12(%rsp)
movq -0x10(%rsp), %rax
shlq $0x4, %rax
movsbq -0x12(%rsp), %rcx
orq %rcx, %rax
movq %rax, -0x10(%rsp)
jmp 0x1130e
movq -0x10(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xd8, %rsp
testb %al, %al
je 0x113ac
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xd0(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xd0(%rsp), %rax
movl 0x28(%rax), %edx
movq 0xd0(%rsp), %rax
movl 0x2c(%rax), %ecx
leaq 0x22a3(%rip), %rdi      # 0x136c4
movb $0x0, %al
callq 0x10c0
leaq 0x2008(%rip), %rdi      # 0x13437
movb $0x0, %al
callq 0x10c0
leaq 0x3cff(%rip), %rdi      # 0x1513c
movb $0x0, %al
callq 0x10c0
leaq 0x1c85(%rip), %rdi      # 0x130d0
movb $0x0, %al
callq 0x10c0
movq 0x7b87(%rip), %rax      # 0x18fe0
movq (%rax), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x11d0
movq 0x7b68(%rip), %rax      # 0x18fe0
movq (%rax), %rdi
leaq 0x3dc9(%rip), %rsi      # 0x1524b
movb $0x0, %al
callq 0x1120
leaq 0xb0(%rsp), %rax
movl $0x1, %edi
callq 0x11f0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x1f82(%rip), %rdi      # 0x13437
movb $0x0, %al
callq 0x10c0
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x3c79(%rip), %rdi      # 0x15146
movb $0x0, %al
callq 0x10c0
leaq 0x1bf5(%rip), %rdi      # 0x130d0
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x11f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x10, 0x4(%rsp)
jge 0x11565
movslq 0x4(%rsp), %rcx
leaq 0x77dc(%rip), %rax      # 0x18cf0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x11556
movslq 0x4(%rsp), %rcx
leaq 0x77b3(%rip), %rax      # 0x18cf0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x30(%rax)
movb $0x1, 0x17(%rsp)
jmp 0x1156a
jmp 0x11558
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x11501
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x1180
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x115d1
leaq 0x3b97(%rip), %rdi      # 0x1515c
leaq 0x3b9c(%rip), %rsi      # 0x15168
callq 0x114a0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
leaq 0x3368(%rip), %rsi      # 0x14980
callq 0x11c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x11652
movq 0x8(%rsp), %rsi
leaq 0x3b33(%rip), %rdi      # 0x15174
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x11f0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl $0x1, 0x28(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x20, %edi
callq 0x1160
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x116d6
leaq 0x3a92(%rip), %rdi      # 0x1515c
leaq 0x3abc(%rip), %rsi      # 0x1518d
callq 0x114a0
movq 0x10(%rsp), %rax
movq $0x20, 0x40(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x1030
testb $0x1, 0xf(%rsp)
je 0x1172f
movq 0x10(%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x11820
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x11782
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x11880
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x1178c
jmp 0x117ec
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0x117a5
movq 0x10(%rsp), %rdi
callq 0x11580
movq 0x10(%rsp), %rax
movq (%rax), %rax
movb (%rax), %dl
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x11751
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rdi
callq 0x114f0
testb $0x1, %al
jne 0x1180d
jmp 0x1180f
jmp 0x1181b
movq 0x10(%rsp), %rax
movl $0x1, 0x30(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl $0x2, 0x30(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x11820
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x1191b
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x11880
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x11925
jmp 0x11969
movq 0x10(%rsp), %rax
movq (%rax), %rax
movb (%rax), %dl
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x118ea
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11300
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl $0x2, 0x30(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
je 0x119fa
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0x11a09
movq 0x10(%rsp), %rdi
callq 0x118b0
jmp 0x11b2e
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x11a28
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x11880
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x11a5a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x11a64
jmp 0x11ac7
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x11a80
movq 0x10(%rsp), %rax
movl $0x3, 0x30(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movb (%rax), %dl
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x11a28
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x2, %eax
je 0x11af6
jmp 0x11aeb
movl 0x4(%rsp), %eax
subl $0x3, %eax
je 0x11b12
jmp 0x11b2c
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
jmp 0x11b2e
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x1060
movq 0x10(%rsp), %rax
movsd %xmm0, 0x48(%rax)
jmp 0x11b2e
jmp 0x11b2e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x11b9b
movq 0x20(%rsp), %rdi
callq 0x11bd0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x11b7a
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x28(%rax)
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x2c(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_long_comment
static void opp_long_comment(struct Opp_Scan* s)
{
	unsigned int d = 1;
	s->src++;
	while (d > 0 && *s->src) {
		if (*s->src == '*' && s->src[1] == '/')
			d--;
		else if (*s->src == '\n') {
			s->line++;
			s->colum = 0;
		}
		else if (*s->src == '/' && s->src[1] == '*')
			d++;
		INCR;
	}

	if (!(*s->src) && d != 0)
		opp_error(s, "Expected terminating '*/'");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0xb(%rsp)
jbe 0x12732
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x1273f
jmp 0x127eb
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x1276d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x1276d
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x127c9
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x12799
movq 0x10(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x127c7
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x127c5
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2a, %eax
jne 0x127c5
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x127c7
jmp 0x127c9
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x12710
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x12812
cmpl $0x0, 0xc(%rsp)
je 0x12812
movq 0x10(%rsp), %rdi
leaq 0x2a8b(%rip), %rsi      # 0x15296
movb $0x0, %al
callq 0x11370
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: dump_tokens
void dump_tokens(struct Opp_Scan* s)
{
	do {
		opp_next(s);
		printf("%s:%d:%d ", s->io.fname, s->line, s->colum);
		if (s->t.id == TFLOAT)
			printf("FLOAT %lf\n", s->t.real);
		else if (s->t.id == TINTEGER)
			printf("INT %ld\n", s->t.num);
		else if (s->t.id == TIDENT)
			printf("IDENT %s\n", s->t.buffer.buf);
		else if (s->t.id == TSTR)
			printf("STRING \"%s\"\n", s->t.buffer.buf);
		else if (s->t.id > 5 && s->t.id <= 38)
			printf("CHAR %d\n", s->t.id);

	} while (s->t.id != FEND);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x11bd0
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq (%rsp), %rax
movl 0x28(%rax), %edx
movq (%rsp), %rax
movl 0x2c(%rax), %ecx
leaq 0x29cd(%rip), %rdi      # 0x15218
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rax
cmpl $0x3, 0x30(%rax)
jne 0x12878
movq (%rsp), %rax
movsd 0x48(%rax), %xmm0
leaq 0x29b6(%rip), %rdi      # 0x15222
movb $0x1, %al
callq 0x10c0
jmp 0x1290f
movq (%rsp), %rax
cmpl $0x2, 0x30(%rax)
jne 0x1289a
movq (%rsp), %rax
movq 0x48(%rax), %rsi
leaq 0x299c(%rip), %rdi      # 0x1522d
movb $0x0, %al
callq 0x10c0
jmp 0x1290d
movq (%rsp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x128bc
movq (%rsp), %rax
movq 0x38(%rax), %rsi
leaq 0x2983(%rip), %rdi      # 0x15236
movb $0x0, %al
callq 0x10c0
jmp 0x1290b
movq (%rsp), %rax
cmpl $0x5, 0x30(%rax)
jne 0x128de
movq (%rsp), %rax
movq 0x38(%rax), %rsi
leaq 0x296b(%rip), %rdi      # 0x15240
movb $0x0, %al
callq 0x10c0
jmp 0x12909
movq (%rsp), %rax
cmpl $0x5, 0x30(%rax)
jbe 0x12907
movq (%rsp), %rax
cmpl $0x26, 0x30(%rax)
ja 0x12907
movq (%rsp), %rax
movl 0x30(%rax), %esi
leaq 0x294d(%rip), %rdi      # 0x1524d
movb $0x0, %al
callq 0x10c0
jmp 0x12909
jmp 0x1290b
jmp 0x1290d
jmp 0x1290f
jmp 0x12911
movq (%rsp), %rax
cmpl $0x40, 0x30(%rax)
jne 0x12825
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: hash_str
unsigned int hash_str(char *string, unsigned int size)
{
	unsigned int h = 0;
	while (*string) {
		h = ((h<<5)-h)^(unsigned char)*(string++);
	}
	h = h % size;
	
	return h;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x12972
movl -0x10(%rsp), %eax
shll $0x5, %eax
subl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0x10(%rsp)
jmp 0x12941
movl -0x10(%rsp), %eax
xorl %edx, %edx
divl -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: init_namespace
struct Opp_Namespace* init_namespace(struct Opp_Namespace* parent, void* (*xmalloc)(size_t))
{
	struct Opp_Namespace* ns = (struct Opp_Namespace*)
		xmalloc(sizeof(struct Opp_Namespace));

	if (ns == NULL) 
		INTERNAL_ERROR("Malloc Fail");

	ns->xmalloc = xmalloc;
	ns->parent = parent;
	ns->items = (struct Opp_Bucket**)
		xmalloc(sizeof(struct Opp_Bucket*)*HASH_SIZE);

	if (ns->items == NULL)
		INTERNAL_ERROR("Malloc Fail");

	ns->size = HASH_SIZE;
	
	for (int i = 0; i < HASH_SIZE; i++)
		ns->items[i] = NULL;

	return ns;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x20, %edi
callq *0x18(%rsp)
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x129c7
leaq 0xc4d(%rip), %rdi       # 0x13608
leaq 0x28ee(%rip), %rsi      # 0x152b0
callq 0x114a0
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0xa00, %edi            # imm = 0xA00
callq *0x18(%rsp)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x12a17
leaq 0xbfd(%rip), %rdi       # 0x13608
leaq 0x289e(%rip), %rsi      # 0x152b0
callq 0x114a0
movq 0x10(%rsp), %rax
movq $0x140, (%rax)          # imm = 0x140
movl $0x0, 0xc(%rsp)
cmpl $0x140, 0xc(%rsp)       # imm = 0x140
jge 0x12a58
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12a2b
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: env_add_item
struct Opp_Bucket* env_add_item(struct Opp_Namespace* ns, char* name)
{
	unsigned int loc = hash_str(name, ns->size);

	if (ns->items[loc] != NULL) {
		struct Opp_Bucket* pos = ns->items[loc];

		while (pos) {
			if (!strcmp(pos->key, name)) 
				return NULL;
			else if (pos->next == NULL) {
				pos->next = (struct Opp_Bucket*)
					ns->xmalloc(sizeof(struct Opp_Bucket));

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

				pos->next->key = name;
				pos->next->next = NULL;
				return pos->next;
			}
			else
				pos = pos->next;
		}
	}
	else {
		struct Opp_Bucket* node = (struct Opp_Bucket*)
			ns->xmalloc(sizeof(struct Opp_Bucket));

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

		node->key = name;
		node->next = NULL;
		ns->items[loc] = node;

		return node;
	}

	return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl %eax, %esi
callq 0x12930
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x12b85
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x12b83
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x12af5
movq $0x0, 0x30(%rsp)
jmp 0x12bf7
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x12b6e
movq 0x28(%rsp), %rax
movl $0x38, %edi
callq *0x18(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x12b39
leaq 0x4fa(%rip), %rdi       # 0x13027
leaq 0x278b(%rip), %rsi      # 0x152bf
callq 0x114a0
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x12bf7
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x12b7e
jmp 0x12ac4
jmp 0x12bee
movq 0x28(%rsp), %rax
movl $0x38, %edi
callq *0x18(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12bb2
leaq 0x481(%rip), %rdi       # 0x13027
leaq 0x2712(%rip), %rsi      # 0x152bf
callq 0x114a0
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x12bf7
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: env_get_item
struct Opp_Bucket* env_get_item(struct Opp_Namespace* ns, char* name)
{
	unsigned int loc = hash_str(name, ns->size);

	struct Opp_Namespace* scope = ns;

	while (scope != NULL)
	{
		if (scope->items[loc] != NULL) 
		{
			struct Opp_Bucket* node = scope->items[loc];

			while (node) {
				if (!strcmp(node->key, name)) 
					return node;
				else if (node->next != NULL)
					node = node->next;
				else 
					break;
			}
		}
		scope = scope->parent;
	}

	return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl %eax, %esi
callq 0x12930
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x12cd8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x12cc5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x12cc3
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x12ca1
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x12ce1
movq 0x8(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x12cbd
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x12cbf
jmp 0x12cc3
jmp 0x12cc1
jmp 0x12c76
jmp 0x12cc5
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x12c40
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_mbox.c
// Function: djb2
static unsigned long
djb2(unsigned char *s, unsigned long hash)
{
	int c;

	while ((c = *s++))
		hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x17ef
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x17bc
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_decodification_pthreads.c
// Function: open_file
FILE* open_file(char *filename, char *mode) {
    FILE* fp;
    fp = fopen(filename, mode);
    if (fp == NULL)
        exit(EXIT_FAILURE);

    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12e2
movl $0x1, %edi
callq 0x1170
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_decodification_pthreads.c
// Function: decodification_thread
void *decodification_thread(void *huffman_info_thread) {
    huffman_thread_struct* thread_arg = (huffman_thread_struct*) huffman_info_thread;
    int id = thread_arg->thread_id;

    int index_input = thread_arg->input_indexes[id];
    int thread_size_output = thread_arg->output_buffer_size / NUM_THREADS;
    int index_output = id * thread_size_output;
    unsigned long long int nbits = thread_arg->nbits_buffer[id];
    
    char *input_buffer = thread_arg->input_buffer;
    char *output_buffer = thread_arg->output_buffer;

    printf("Hy! %d start %d, size %d !\n", id, index_input, index_output);

    decode_bytes_for_chunk_pthreads(thread_arg->root, input_buffer + index_input, nbits, output_buffer + index_output);

    pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x20(%rbp), %ecx
leaq 0x1c8d(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x30(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
movslq -0x20(%rbp), %rax
addq %rax, %rcx
callq 0x1b00
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
nop