LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_shifts
static struct Opp_Node* opp_parse_shifts(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_order1(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* result = NULL;

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

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

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

		left = result;

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

	return left;
}

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

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

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

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

		left = result;

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

	return left;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9418
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x13(%r12), %eax
cmpl $0x1, %eax
ja 0x9409
callq 0x9cc3
movq %rbx, %rdi
callq 0x9418
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8b9b
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x13(%r12), %ecx
movq %rax, %r14
cmpl $0x2, %ecx
jb 0x93ca
jmp 0x940c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_order2
static struct Opp_Node* opp_parse_order2(struct Opp_Parser* parser)
{
	struct Opp_Node* left = opp_parse_before(parser);
	struct Opp_Node* right = NULL;
	struct Opp_Node* result = NULL;

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

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

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

		left = result;

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

	return left;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x948a
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x15(%r12), %eax
cmpl $0x2, %eax
ja 0x947b
callq 0x9cc3
movq %rbx, %rdi
callq 0x948a
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8b9b
movl %r12d, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x15(%r12), %ecx
movq %rax, %r14
cmpl $0x3, %ecx
jb 0x943c
jmp 0x947e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_block
static struct Opp_Node* opp_parse_block(struct Opp_Parser* parser)
{
	int block_init_size = 64;
	struct Opp_Node* block = opp_new_node(parser, STMT_BLOCK);
	block->block_stmt.stmts = calloc(block_init_size, sizeof(struct Opp_Node*));

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

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

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

		opp_next(parser->lex);
	}

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

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

	return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x12, %esi
callq 0x8b9b
movq %rax, %rbx
movl $0x40, %edi
movl $0x8, %esi
callq 0x1130
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x96ea
leaq 0x1949(%rip), %rdi      # 0xb027
leaq 0x3487(%rip), %rsi      # 0xcb6c
callq 0x98fb
movq (%r14), %rdi
callq 0x9cc3
movl $0x40, %ebp
xorl %r13d, %r13d
leaq 0x1e8f(%rip), %r15      # 0xb590
leaq 0x3464(%rip), %r12      # 0xcb6c
movq (%r14), %rax
movl 0x30(%rax), %eax
cmpl $0x28, %eax
je 0x9767
cmpl $0x40, %eax
je 0x9767
movl %ebp, %eax
cmpq %rax, %r13
jne 0x974a
movq 0x20(%rbx), %rdi
movslq %ebp, %rax
addl $0x40, %ebp
leaq 0x200(,%rax,8), %rsi
callq 0x11a0
movq %rax, 0x20(%rbx)
testq %rbx, %rbx
jne 0x974a
movq %r15, %rdi
movq %r12, %rsi
callq 0x98fb
movq %r14, %rdi
callq 0x8d83
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
movq (%r14), %rdi
callq 0x9cc3
jmp 0x9708
movq 0x20(%rbx), %rax
movl %r13d, %ecx
movq $0x0, (%rax,%rcx,8)
movl %r13d, 0x18(%rbx)
movq (%r14), %rdi
cmpl $0x28, 0x30(%rdi)
je 0x9791
leaq 0x33f2(%rip), %rsi      # 0xcb7c
xorl %eax, %eax
callq 0x980e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_expr
static struct Opp_Node* opp_parse_expr(struct Opp_Parser* parser)
{
	struct Opp_Node* new_expr = opp_parse_allign(parser);

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

	return new_expr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x8d29
movq %rax, %rbx
movq (%r14), %rdi
cmpl $0x2a, 0x30(%rdi)
je 0x97c9
leaq 0x3548(%rip), %rsi      # 0xcd0a
xorl %eax, %eax
callq 0x980e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %cl
testb %cl, %cl
je 0x980b
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
movl %ecx, %edx
andl $0xf, %edx
movl %ecx, %esi
shrl $0x6, %esi
addl %edx, %esi
shrl $0x3, %ecx
andl $0x8, %ecx
orl %esi, %ecx
shlq $0x4, %rax
movsbq %cl, %rcx
orq %rcx, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x97df
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_error
void opp_error(struct Opp_Scan* s, const char* str, ...)
{
	va_list ap;
	va_start(ap, str);
	
	printf("%s:%u:%u ", s->io.fname, s->line, s->colum);
	#ifdef UNX
		printf(CL_RED);
	#endif

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq $0x1, 0x28(%rdi)
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
movl $0x20, %edi
callq 0x1180
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x9a5e
movq $0x20, 0x40(%rbx)
popq %rbx
retq
leaq 0x34c3(%rip), %rdi      # 0xcf28
leaq 0x34ed(%rip), %rsi      # 0xcf59
callq 0x98fb
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_free_lex
void opp_free_lex(struct Opp_Scan* s, bool alloc)
{
	free(s->content);
	free(s->t.buffer.buf);

	if (alloc)
		free(s);
}

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movb (%rax), %cl
leal -0x30(%rcx), %edx
xorl %eax, %eax
cmpb $0xa, %dl
jb 0x9aca
cmpb $0x5f, %cl
je 0x9aca
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x9b16
movl %eax, %r14d
cmpq %r14, 0x40(%rbx)
jae 0x9adb
movq %rbx, %rdi
callq 0x99ae
movq (%rbx), %rax
movq 0x38(%rbx), %rcx
movb (%rax), %al
movb %al, (%rcx,%r14)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
incl 0x2c(%rbx)
leal 0x1(%r14), %eax
movb 0x1(%rcx), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x9aca
cmpb $0x5f, %cl
je 0x9aca
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x9aca
movl %eax, %eax
movq 0x38(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
callq 0x993f
testb %al, %al
jne 0x9b31
movl $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_lex_hex
void opp_lex_hex(struct Opp_Scan* s)
{
	unsigned int idx = 0;
	s->t.id = TINTEGER;
	INCR;
	while (isletter(*s->src) || isnum(*s->src)) {
		s->t.buffer.buf[idx] = *s->src;
		idx++;
		INCR;
	}
	s->t.buffer.buf[idx] = '\0';
	s->t.num = hex2i64(s->t.buffer.buf);
}

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

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

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

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

		default: break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x30(%rdi)
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movl 0x2c(%rdi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%rdi)
movzbl 0x1(%rax), %edx
orl $0x20, %edx
cmpl $0x78, %edx
jne 0x9bf1
movq %rbx, %rdi
popq %rbx
jmp 0x9b39
movq %rax, (%rbx)
movl %ecx, 0x2c(%rbx)
movb (%rax), %dl
leal -0x30(%rdx), %ecx
cmpb $0xa, %cl
setae %sil
cmpb $0x2e, %dl
setne %dil
xorl %ecx, %ecx
testb %sil, %dil
jne 0x9c53
cmpb $0x2e, %dl
jne 0x9c1d
movl $0x3, 0x30(%rbx)
movb (%rax), %al
movq 0x38(%rbx), %rdx
movl %ecx, %esi
movb %al, (%rdx,%rsi)
movq (%rbx), %rdx
leaq 0x1(%rdx), %rax
movq %rax, (%rbx)
incl 0x2c(%rbx)
incl %ecx
movb 0x1(%rdx), %dl
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
setb %sil
cmpb $0x2e, %dl
sete %dil
orb %sil, %dil
jne 0x9c11
movl %ecx, %ecx
movq 0x38(%rbx), %rax
movb $0x0, (%rax,%rcx)
movl 0x30(%rbx), %eax
cmpl $0x3, %eax
je 0x9c77
cmpl $0x2, %eax
jne 0x9c85
movq 0x38(%rbx), %rdi
callq 0x11c0
movq %rax, 0x48(%rbx)
jmp 0x9c85
movq 0x38(%rbx), %rdi
callq 0x1080
movsd %xmm0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_peek_tok
void opp_peek_tok(struct Opp_Scan* s, int times)
{
	char* temp = s->src;
	uint32_t tline = s->line, tcolum = s->colum;

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

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

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq 0x40(%rbx), %rdx
xorl %esi, %esi
callq 0x1110
movq (%rbx), %rax
movb (%rax), %cl
movzbl %cl, %edx
cmpl $0xc, %edx
jle 0x9d39
cmpl $0xd, %edx
je 0x9de1
cmpl $0x20, %edx
je 0x9de1
cmpl $0x2f, %edx
jne 0x9dfc
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
incl 0x2c(%rbx)
movzbl 0x1(%rax), %edx
cmpl $0x2a, %edx
je 0x9d5a
cmpl $0x2f, %edx
jne 0x9e22
movq %rcx, %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x9dc7
cmpl $0xa, %ecx
je 0x9dc7
incq %rax
movq %rax, (%rbx)
jmp 0x9d1d
cmpl $0x9, %edx
je 0x9de1
cmpl $0xa, %edx
jne 0x9def
incl 0x28(%rbx)
movl $0x0, 0x2c(%rbx)
jmp 0x9de1
leaq 0x2(%rax), %rcx
movq %rcx, (%rbx)
addq $0x3, %rax
movl $0x1, %ecx
movzbl -0x1(%rax), %edx
cmpl $0x29, %edx
jle 0x9d86
cmpl $0x2f, %edx
je 0x9da9
cmpl $0x2a, %edx
jne 0x9db3
cmpb $0x2f, (%rax)
jne 0x9d9d
decl %ecx
jmp 0x9db3
cmpl $0xa, %edx
jne 0x9d97
incl 0x28(%rbx)
movl $0x0, 0x2c(%rbx)
jmp 0x9db3
testl %edx, %edx
jne 0x9db3
jmp 0x9dd3
cmpl $0x2f, %edx
je 0x9da9
cmpl $0xa, %edx
je 0x9d8b
jmp 0x9db3
xorl %edx, %edx
cmpb $0x2a, (%rax)
sete %dl
addl %edx, %ecx
movq %rax, (%rbx)
incl 0x2c(%rbx)
incq %rax
testl %ecx, %ecx
jne 0x9d6a
decq %rax
xorl %ecx, %ecx
jmp 0x9dd8
movl $0x0, 0x2c(%rbx)
incl 0x28(%rbx)
jmp 0x9de1
decq %rax
movb $0x1, %cl
testb %cl, %cl
je 0x9de1
cmpb $0x0, (%rax)
je 0x9e53
incl 0x2c(%rbx)
incq %rax
movq %rax, (%rbx)
jmp 0x9cd9
testl %edx, %edx
jne 0x9dfc
movl $0x40, 0x30(%rbx)
jmp 0x9e51
cmpb $0x5f, %cl
je 0x9e19
movl %ecx, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x9e19
cmpb $0x22, %cl
jne 0x9e2b
movq %rbx, %rdi
popq %rbx
jmp 0x9e7b
movq %rbx, %rdi
popq %rbx
jmp 0x9aa4
movl $0x15, 0x30(%rbx)
jmp 0x9e51
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x9e3c
movq %rbx, %rdi
popq %rbx
jmp 0x9bbe
movq %rbx, %rdi
callq 0x9f77
testl %eax, %eax
je 0x9e64
movl %eax, 0x30(%rbx)
incq (%rbx)
incl 0x2c(%rbx)
popq %rbx
retq
leaq 0x3208(%rip), %rsi      # 0xd062
movq %rbx, %rdi
xorl %eax, %eax
callq 0x980e
movq (%rbx), %rax
movsbl (%rax), %edx
leaq 0x315a(%rip), %rsi      # 0xcfcb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x980e
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_lex_str
void opp_lex_str(struct Opp_Scan* s)
{
	INCR;
	unsigned int idx = 0;
	while (*s->src != '"') {
		if (idx >= s->t.buffer.len)
			realloc_buf(s);

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rdi)
movl 0x2c(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x2c(%rdi)
xorl %eax, %eax
cmpb $0x22, 0x1(%rcx)
je 0x9f2e
movl %eax, %r14d
cmpq %r14, 0x40(%rbx)
ja 0x9eb2
movq %rbx, %rdi
callq 0x99ae
movq (%rbx), %rcx
movzbl (%rcx), %eax
cmpl $0x5c, %eax
je 0x9ed2
cmpl $0xff, %eax
je 0x9f52
cmpl $0xa, %eax
jne 0x9f03
jmp 0x9f52
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
incl 0x2c(%rbx)
movb 0x1(%rcx), %cl
movzbl %cl, %edx
cmpl $0x6d, %edx
jg 0x9ef5
cmpl $0x22, %edx
je 0x9ef1
cmpl $0x5c, %edx
jne 0x9f63
movl %ecx, %eax
jmp 0x9f03
movb $0xa, %al
cmpl $0x6e, %edx
je 0x9f03
cmpl $0x74, %edx
jne 0x9f63
movb $0x9, %al
movq 0x38(%rbx), %rcx
movb %al, (%rcx,%r14)
leal 0x1(%r14), %eax
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movl 0x2c(%rbx), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x2c(%rbx)
cmpb $0x22, 0x1(%rcx)
jne 0x9ea1
movl %eax, %eax
addq $0x2, %rcx
movq %rcx, (%rbx)
addl $0x2, %edx
movl %edx, 0x2c(%rbx)
movq 0x38(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movl $0x5, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x300d(%rip), %rsi      # 0xcf66
movq %rbx, %rdi
xorl %eax, %eax
callq 0x980e
movsbl %cl, %edx
leaq 0x301c(%rip), %rsi      # 0xcf89
movq %rbx, %rdi
xorl %eax, %eax
callq 0x980e
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d54(%rip), %r14      # 0xcfe4
leaq 0x2c5d(%rip), %r12      # 0xcef4
leaq 0x2d5b(%rip), %r13      # 0xcff9
leaq 0x2d49(%rip), %rbp      # 0xcfee
leaq 0x2d60(%rip), %r15      # 0xd00c
movq %rbx, %rdi
callq 0x9cc3
movq 0x10(%rbx), %rsi
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
movq %r14, %rdi
xorl %eax, %eax
callq 0x10e0
movl 0x30(%rbx), %esi
leal -0x1(%rsi), %eax
cmpl $0x4, %eax
ja 0xa319
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x38(%rbx), %rsi
leaq 0x2d1b(%rip), %rdi      # 0xd002
jmp 0xa30a
movsd 0x48(%rbx), %xmm0
movq %rbp, %rdi
movb $0x1, %al
callq 0x10e0
jmp 0xa311
movq 0x48(%rbx), %rsi
movq %r13, %rdi
jmp 0xa30a
movq 0x38(%rbx), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10e0
cmpl $0x40, 0x30(%rbx)
jne 0xa2ac
jmp 0xa331
leal -0x6(%rsi), %eax
cmpl $0x20, %eax
ja 0xa311
leaq 0x2cf1(%rip), %rdi      # 0xd019
xorl %eax, %eax
callq 0x10e0
jmp 0xa311
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %cl
testb %cl, %cl
je 0xa362
incq %rdi
xorl %eax, %eax
movl %eax, %edx
shll $0x5, %edx
subl %eax, %edx
movzbl %cl, %eax
xorl %edx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xa34b
jmp 0xa364
xorl %eax, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %edi
callq *%rsi
movq %rax, %rbx
testq %rax, %rax
jne 0xa398
leaq 0x1204(%rip), %rdi      # 0xb590
leaq 0x2ce9(%rip), %rsi      # 0xd07c
callq 0x98fb
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0xa00, %edi            # imm = 0xA00
callq *%r14
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xa3c4
leaq 0x11d8(%rip), %rdi      # 0xb590
leaq 0x2cbd(%rip), %rsi      # 0xd07c
callq 0x98fb
movq $0x140, (%rbx)          # imm = 0x140
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq $0x140, %rax            # imm = 0x140
jne 0xa3cd
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movb (%rsi), %dl
testb %dl, %dl
je 0xa420
leaq 0x1(%rbx), %rsi
xorl %eax, %eax
movl %eax, %edi
shll $0x5, %edi
subl %eax, %edi
movzbl %dl, %eax
xorl %edi, %eax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0xa409
jmp 0xa422
xorl %eax, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0xa492
xorl %r15d, %r15d
movq %rax, %r12
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0xa4c9
movq 0x30(%r12), %rax
testq %rax, %rax
jne 0xa439
movl $0x38, %edi
callq *0x18(%r14)
movq %rax, 0x30(%r12)
testq %rax, %rax
jne 0xa47b
leaq 0xbb8(%rip), %rdi       # 0xb027
leaq 0x2c15(%rip), %rsi      # 0xd08b
callq 0x98fb
movq 0x30(%r12), %rax
movq %rbx, (%rax)
movq $0x0, 0x30(%rax)
movq 0x30(%r12), %r15
jmp 0xa4c9
movl $0x38, %edi
callq *0x18(%r14)
movq %rax, %r15
testq %rax, %rax
jne 0xa4b6
leaq 0xb7d(%rip), %rdi       # 0xb027
leaq 0x2bda(%rip), %rsi      # 0xd08b
callq 0x98fb
movq %rbx, (%r15)
movq $0x0, 0x30(%r15)
movq 0x8(%r14), %rax
movq %r15, (%rax,%r12,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Encryptr[P]O-plus-plus/opp/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movb (%rsi), %dl
testb %dl, %dl
je 0xa50c
leaq 0x1(%rbx), %rsi
xorl %eax, %eax
movl %eax, %edi
shll $0x5, %edi
subl %eax, %edi
movzbl %dl, %eax
xorl %edi, %eax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0xa4f5
jmp 0xa50e
xorl %eax, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %r12
testq %r12, %r12
je 0xa548
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0xa541
movq 0x30(%r12), %r12
testq %r12, %r12
jne 0xa522
movq %r13, %r12
jmp 0xa544
movq %r12, %r13
testl %eax, %eax
je 0xa554
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0xa515
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dxwc[P]sfeed/sfeed_mbox.c
// Function: main
int
main(int argc, char *argv[])
{
	struct tm tm;
	time_t t;
	FILE *fp;
	char *name;
	int i;

	if (pledge(argc == 1 ? "stdio" : "stdio rpath", NULL) == -1)
		err(1, "pledge");

	if (!(user = getenv("USER")))
		user = "you";
	if (gethostname(host, sizeof(host)) == -1)
		err(1, "gethostname");
	if ((t = time(NULL)) == -1)
		err(1, "time");
	if (!gmtime_r(&t, &tm))
		errx(1, "gmtime_r: can't get current time");
	if (!strftime(mtimebuf, sizeof(mtimebuf), "%a %b %d %H:%M:%S %Y", &tm))
		errx(1, "strftime: can't format current time");

	if (argc == 1) {
		printfeed(stdin, "");
	} else {
		for (i = 1; i < argc; i++) {
			if (!(fp = fopen(argv[i], "r")))
				err(1, "fopen: %s", argv[i]);
			name = ((name = strrchr(argv[i], '/'))) ? name + 1 : argv[i];
			printfeed(fp, name);
			if (ferror(fp))
				err(1, "ferror: %s", argv[i]);
			fclose(fp);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xcce(%rip), %rdi       # 0x2004
callq 0x1030
testq %rax, %rax
leaq 0xcc4(%rip), %rcx       # 0x2009
cmovneq %rax, %rcx
movq %rcx, 0x2de0(%rip)      # 0x4130
leaq 0x2de9(%rip), %rdi      # 0x4140
movl $0x100, %esi            # imm = 0x100
callq 0x11f0
cmpl $-0x1, %eax
je 0x1479
xorl %edi, %edi
callq 0x1180
movq %rax, 0x8(%rsp)
cmpq $-0x1, %rax
je 0x1482
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10f0
testq %rax, %rax
je 0x1495
leaq 0x2ea1(%rip), %rdi      # 0x4240
leaq 0xc94(%rip), %rdx       # 0x203a
leaq 0x10(%rsp), %rcx
movl $0x20, %esi
callq 0x11b0
testq %rax, %rax
je 0x149e
cmpl $0x1, %ebp
jne 0x13db
movq 0x2c16(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xd69(%rip), %rsi       # 0x213d
callq 0x14b1
jmp 0x1440
jle 0x1440
movl %ebp, %r13d
movl $0x1, %ebp
leaq 0xc87(%rip), %r14       # 0x2073
movq (%rbx,%rbp,8), %rdi
movq %r14, %rsi
callq 0x11c0
movq (%rbx,%rbp,8), %r12
testq %rax, %rax
je 0x1451
movq %rax, %r15
movq %r12, %rdi
movl $0x2f, %esi
callq 0x10e0
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r12, %rsi
movq %r15, %rdi
callq 0x14b1
movq %r15, %rdi
callq 0x1070
testl %eax, %eax
jne 0x1462
movq %r15, %rdi
callq 0x1080
incq %rbp
cmpq %rbp, %r13
jne 0x13ec
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc1d(%rip), %rsi       # 0x2075
movl $0x1, %edi
movq %r12, %rdx
jmp 0x1472
movq (%rbx,%rbp,8), %rdx
leaq 0xc12(%rip), %rsi       # 0x207f
movl $0x1, %edi
xorl %eax, %eax
callq 0x11a0
leaq 0xb8d(%rip), %rsi       # 0x200d
jmp 0x1489
leaq 0xbe5(%rip), %rsi       # 0x206e
movl $0x1, %edi
xorl %eax, %eax
callq 0x11a0
leaq 0xb7d(%rip), %rsi       # 0x2019
jmp 0x14a5
leaq 0xbaa(%rip), %rsi       # 0x204f
movl $0x1, %edi
xorl %eax, %eax
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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 %rax
callq 0x1170
testq %rax, %rax
je 0x1329
popq %rcx
retq
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %rsi
movq 0x10(%rdi), %rax
movslq (%rax,%rsi,4), %rdx
movl 0x20(%rdi), %eax
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
imull %esi, %ecx
movq 0x28(%rdi), %rax
movq %rdx, %r14
addq 0x8(%rdi), %r14
movq (%rax,%rsi,8), %r15
movslq %ecx, %rcx
movq 0x18(%rdi), %r12
addq %rcx, %r12
leaq 0x1c8a(%rip), %rdi      # 0x3004
xorl %eax, %eax
callq 0x10a0
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x17e3
xorl %edi, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O1/teodorst[P]app-huffman/huffman_decodification_pthreads.c
// Function: main
int main (int argc, char *argv[]) {
    if (argc == 4) {
        fprintf(stderr, "%s %s %s\n", argv[INPUT_FILE], argv[OUTPUT_FILE], argv[CODIFICATION]);
        huffman_decodification_pthreads(argv[INPUT_FILE], argv[OUTPUT_FILE], argv[CODIFICATION]);
    }
    else {
        printf("Bad arguments\n");
        printf("Usage huffman_serial operation[compress/decompress] input_file ouput_file codification_file_name\n");
        return 1;
    }
    return 0;
    /* Last thing that main() should do */
    pthread_exit(NULL);
}

// Assembly:
pushq %rax
cmpl $0x4, %edi
je 0x1615
leaq 0x1a83(%rip), %rdi      # 0x3080
callq 0x1060
leaq 0x1a85(%rip), %rdi      # 0x308e
callq 0x1060
movl $0x1, %eax
popq %rcx
retq
movq %rsi, %rdi
callq 0x11f0
xorl %eax, %eax
jmp 0x1613
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x1/main.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("===============================\n");
	printf("Programming Pearls: Chapter 0x1\n");
	printf("===============================\n");

	if (bitmap_test(&i))
		fail++;

	puts("");

	return fail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0xe92(%rip), %r14       # 0x2024
movq %r14, %rdi
callq 0x1040
leaq 0xe63(%rip), %rdi       # 0x2004
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1240
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl $0xa, %edi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x1/bitmap_test.c
// Function: bitmap_test
int bitmap_test(int *i)
{
	const struct test {
		const char	*name;
		int		pos;
	} tests[] = {
		{
			.name	= "min value in the range",
			.pos	= min(),
		},
		{
			.name	= "max value in the range",
			.pos	= max(),
		},
		{
			.name	= "middle value in the range",
			.pos	= (min()+max())/2,
		},
		{ /* sentry */ },
	};
	const struct test *t;

	for (t = tests; t->name; t++) {
		int j;

		printf("%2d) %-70s", ++(*i), t->name);
		reset();
		set(t->pos);
		/* make sure it's set */
		assert(is_set(t->pos));
		/* make sure others are not set */
		for (j = min(); j <= max(); j++)
			if (j != t->pos)
				assert(!is_set(j));
		puts("PASS");
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xdec(%rip), %rax       # 0x2044
movq %rax, (%rsp)
xorl %eax, %eax
callq 0x11e7
movl %eax, 0x8(%rsp)
leaq 0xded(%rip), %rax       # 0x205b
movq %rax, 0x10(%rsp)
xorl %eax, %eax
callq 0x11ea
movl %eax, 0x18(%rsp)
leaq 0xded(%rip), %rax       # 0x2072
movq %rax, 0x20(%rsp)
xorl %eax, %eax
callq 0x11e7
movl %eax, %ebp
xorl %eax, %eax
callq 0x11ea
addl %ebp, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x135e
movq %rsp, %r13
leaq 0xdbb(%rip), %r14       # 0x208c
leaq 0xdfe(%rip), %r15       # 0x20d6
movl (%rbx), %esi
incl %esi
movl %esi, (%rbx)
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
callq 0x11d4
movl 0x8(%r13), %edi
callq 0x11f0
movl 0x8(%r13), %edi
callq 0x1224
testl %eax, %eax
je 0x138e
xorl %eax, %eax
callq 0x11e7
movl %eax, %r12d
xorl %eax, %eax
callq 0x11ea
cmpl %eax, %r12d
jg 0x1345
cmpl 0x8(%r13), %r12d
je 0x1331
movl %r12d, %edi
callq 0x1224
testl %eax, %eax
jne 0x136f
leal 0x1(%r12), %ebp
xorl %eax, %eax
callq 0x11ea
cmpl %eax, %r12d
movl %ebp, %r12d
jl 0x131f
movq %r15, %rdi
callq 0x1040
movq 0x10(%r13), %rdx
addq $0x10, %r13
testq %rdx, %rdx
jne 0x12d8
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd55(%rip), %rdi       # 0x20cb
leaq 0xd29(%rip), %rsi       # 0x20a6
leaq 0xd30(%rip), %rcx       # 0x20b4
movl $0x29, %edx
callq 0x1060
leaq 0xd02(%rip), %rdi       # 0x2097
leaq 0xd0a(%rip), %rsi       # 0x20a6
leaq 0xd11(%rip), %rcx       # 0x20b4
movl $0x25, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/main.c
// Function: do_sh_bareitem
void do_sh_bareitem(SH_BareItem* obj) {
	SH_Item_type t;
	sh_char_t* s;
	void* x;

	int err = 0;

	t = SH_BareItem__type(obj, 0);
	printf("    - type =: %u\n", (unsigned int)t);

	x = (void*)SH_BareItem__get_integer(obj, &err);
	printf("    o get_integer: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_decimal(obj, &err);
	printf("    o get_decimal: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_string(obj, &err);
	printf("    o get_string: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_token(obj, &err);
	printf("    o get_token: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_bytesequence(obj, &err);
	printf("    o get_bytesequence: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_boolean(obj, &err);
	printf("    o get_boolean: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	s = SH_BareItem__to_s(obj, &err);
	if ((sh_char_t*)0 == s || err) {
		printf("    * unable to to_s: [%llX] 0x%08X\n", (long long)s, err);
	} else {
		printf("    - to_s =:\n");
		hexdump_string(s);
		free(s);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0xc(%rsp), %rbx
movl %r15d, (%rbx)
xorl %esi, %esi
callq 0x3b55
leaq 0x3e39(%rip), %rdi      # 0x502c
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b68
movl (%rbx), %edx
leaq 0x3e2e(%rip), %rdi      # 0x503e
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movl %r15d, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b95
movl (%rbx), %edx
leaq 0x3e2f(%rip), %rdi      # 0x5060
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movl %r15d, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bc2
movl (%rbx), %edx
leaq 0x3e30(%rip), %rdi      # 0x5082
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movl %r15d, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bef
movl (%rbx), %edx
leaq 0x3e30(%rip), %rdi      # 0x50a3
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movl %r15d, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c1c
movl (%rbx), %edx
leaq 0x3e2f(%rip), %rdi      # 0x50c3
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movl %r15d, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c49
movl (%rbx), %edx
leaq 0x3e35(%rip), %rdi      # 0x50ea
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movl %r15d, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ca3
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%rbx), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x12f7
leaq 0x3e21(%rip), %rdi      # 0x510c
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1313
leaq 0x44d0(%rip), %rdi      # 0x57ce
callq 0x1040
movq %r14, %rdi
callq 0x131d
movq %r14, %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/main.c
// Function: hexdump_string
void hexdump_string(const sh_char_t* str) {
	sh_char_t* ptr = (sh_char_t*)str;
	int n = 0;
	int i, j;
	char line[HEXDUMP_LEN];

	if ((sh_char_t*)0 == ptr) {
		printf("NULL\n");
		return;
	}
	if (SH_CHAR_C(0) == *ptr) {
		printf("\"\"\n");
		return;
	}

	printf("%s\n", hexdump_rule);

	while (SH_CHAR_C(0) != *ptr) {
		if (n == 0) {
			memcpy((void*)line, (const void*)hexdump_line, sizeof(char)*74);
			i = 2;
			j = 54;
		}
		if (n == 8) {
			i += 2;
			j ++;
		}

		line[i++] = hexdump_char[((*ptr) & 0xF0) >> 4];
		line[i++] = hexdump_char[ (*ptr) & 0x0F];
		i++;

		if (*ptr >= SH_CHAR_C(0x20) && *ptr < SH_CHAR_C(0x7F)) {
			line[j++] = (char)(*ptr);
		} else {
			line[j++] = '.';
		}

		ptr++;
		n++;
		if (n == 16) {
			printf("%s\n", line);
			n = 0;
		}
	}

	if (n != 0) {
		printf("%s\n", line);
	}

	printf("%s\n", hexdump_rule);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
testq %rdi, %rdi
je 0x1422
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x142b
leaq 0x4529(%rip), %rbx      # 0x5870
movq %rbx, %rdi
callq 0x1040
movb (%r14), %dl
testb %dl, %dl
je 0x1432
incq %r14
xorl %eax, %eax
movq %rsp, %rbp
leaq 0x45a7(%rip), %r13      # 0x5910
movl $0x2e, %r9d
testl %eax, %eax
jne 0x1397
movl $0x9, %ecx
movq %rbp, %rdi
leaq 0x453e(%rip), %rsi      # 0x58c0
rep  movsq (%rsi), %es:(%rdi)
movw $0x7c, 0x48(%rsp)
movl $0x36, %r15d
movl $0x2, %ecx
leal 0x2(%rcx), %ebx
xorl %r12d, %r12d
cmpl $0x8, %eax
cmovnel %ecx, %ebx
sete %r12b
leal (%r15,%r12), %ecx
movzbl %dl, %edx
movl %edx, %esi
shrl $0x4, %esi
movb (%rsi,%r13), %sil
movslq %ebx, %rdi
movb %sil, (%rsp,%rdi)
movl %edx, %esi
andl $0xf, %esi
movb (%rsi,%r13), %sil
movb %sil, 0x1(%rsp,%rdi)
leal -0x20(%rdx), %esi
cmpb $0x5f, %sil
cmovael %r9d, %edx
movslq %ecx, %rcx
movb %dl, (%rsp,%rcx)
incl %eax
cmpl $0x10, %eax
jne 0x13f4
movq %rbp, %rdi
callq 0x1040
movl $0x2e, %r9d
xorl %eax, %eax
addl $0x3, %ebx
addl %r12d, %r15d
incl %r15d
movb (%r14), %dl
incq %r14
movl %ebx, %ecx
testb %dl, %dl
jne 0x136f
testl %eax, %eax
je 0x1419
movq %rsp, %rdi
callq 0x1040
leaq 0x4450(%rip), %rbx      # 0x5870
jmp 0x1432
leaq 0x43b6(%rip), %rbx      # 0x57df
jmp 0x1432
leaq 0x43aa(%rip), %rbx      # 0x57dc
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/main.c
// Function: do_sh_null
void do_sh_null() {
	SH_BareItem* bi;

	int err = 0;

	printf("+ NULL item\n");

	bi = SH_BareItem__init_null(&err);
	if ((SH_BareItem*)0 == bi || err) {
		printf("  * unable to init SH_BareItem: [%llX] 0x%08X\n", (long long)bi, err);
	} else {
		printf("  + init SH_BareItem: [%llX]\n", (long long)bi);
		do_sh_bareitem(bi);
		SH_BareItem__destroy(bi, SH_FALSE, 0);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
leaq 0x4385(%rip), %rdi      # 0x57e4
callq 0x1040
movq %r14, %rdi
callq 0x381c
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r14), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1497
leaq 0x3ca6(%rip), %rdi      # 0x5131
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x14bc
leaq 0x3cc2(%rip), %rdi      # 0x5160
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x11ce
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/main.c
// Function: do_sh_integer
void do_sh_integer(sh_int_t value) {
	SH_Integer* obj;
	SH_BareItem* bi;

	sh_int_t i;
	sh_bool_t b;
	sh_char_t* s;

	int err = 0;

	obj = SH_Integer__init(value, &err);
	if ((SH_Integer*)0 == obj || err) {
		printf("* unable to init SH_Integer(%lld): [%llX] 0x%08X\n", (long long)value, (long long)obj, err);
	} else {
		printf("+ init SH_Integer(%lld): [%llX]\n", (long long)value, (long long)obj);

		i = SH_Integer__int(obj, 0);
		printf("  - int =: %lld\n", (long long)i);

		b = SH_Integer__negative(obj, 0);
		printf("  - negative =: %hhu\n", (unsigned char)b);

		i = SH_Integer__abs(obj, 0);
		printf("  - abs =: %lld\n", (long long)i);

		s = SH_Integer__to_s(obj, &err);
		if ((sh_char_t*)0 == s || err) {
			printf("  * unable to to_s: [%llX] 0x%08X\n", (long long)s, err);
		} else {
			printf("  - to_s =:\n");
			hexdump_string(s);
			free(s);
		}

		bi = SH_BareItem__init_integer(obj, &err);
		if ((SH_BareItem*)0 == bi || err) {
			printf("  * unable to init SH_BareItem: [%llX] 0x%08X\n", (long long)bi, err);
		} else {
			printf("  + init SH_BareItem: [%llX]\n", (long long)bi);
			do_sh_bareitem(bi);
			SH_BareItem__destroy(bi, SH_FALSE, 0);
		}

		SH_Integer__destroy(obj, 0);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
movq %r15, %rsi
callq 0x292c
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r15), %ecx
testl %ecx, %ecx
setne %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x1515
leaq 0x3c7b(%rip), %rdi      # 0x517e
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x163b
leaq 0x3c94(%rip), %rdi      # 0x51b0
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29b2
leaq 0x3c97(%rip), %rdi      # 0x51d1
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29c9
movzbl %al, %esi
leaq 0x3c8a(%rip), %rdi      # 0x51e2
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29e4
leaq 0x3c88(%rip), %rdi      # 0x51f8
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a27
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x15b5
leaq 0x3b65(%rip), %rdi      # 0x510e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x15d1
leaq 0x4214(%rip), %rdi      # 0x57d0
callq 0x1040
movq %r14, %rdi
callq 0x131d
movq %r14, %rdi
callq 0x1030
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x385f
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x160c
leaq 0x3b31(%rip), %rdi      # 0x5131
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1631
leaq 0x3b4d(%rip), %rdi      # 0x5160
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
callq 0x11ce
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a6c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2993
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq