LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x929d
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x2b(%r12), %eax
cmpl $0x1, %eax
ja 0x928e
callq 0x9b62
movq %rbx, %rdi
callq 0x929d
movq %rax, %r15
movq %rbx, %rdi
movl $0xe, %esi
callq 0x8a85
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 0x924f
jmp 0x9291
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x930f
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x13(%r12), %eax
cmpl $0x1, %eax
ja 0x9300
callq 0x9b62
movq %rbx, %rdi
callq 0x930f
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8a85
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 0x92c1
jmp 0x9303
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9381
movq %rax, %r14
movq (%rbx), %rdi
movl 0x30(%rdi), %r12d
leal -0x15(%r12), %eax
cmpl $0x2, %eax
ja 0x9372
callq 0x9b62
movq %rbx, %rdi
callq 0x9381
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8a85
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 0x9333
jmp 0x9375
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Encryptr[P]O-plus-plus/opp/parser/parser.c
// Function: opp_parse_block
static struct Opp_Node* opp_parse_block(struct Opp_Parser* parser)
{
	int block_init_size = 64;
	struct Opp_Node* block = opp_new_node(parser, STMT_BLOCK);
	block->block_stmt.stmts = calloc(block_init_size, sizeof(struct Opp_Node*));

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

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

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

		opp_next(parser->lex);
	}

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

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

	return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x12, %esi
callq 0x8a85
movq %rax, %rbx
movl $0x40, %edi
movl $0x8, %esi
callq 0x1130
movq %rax, %r15
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x95d3
leaq 0x1a60(%rip), %rdi      # 0xb027
leaq 0x359e(%rip), %rsi      # 0xcb6c
callq 0x97b3
movl $0x40, %ebp
xorl %r12d, %r12d
movq (%r14), %rdi
callq 0x9b62
movq (%r14), %rax
movl 0x30(%rax), %eax
cmpl $0x28, %eax
je 0x9628
cmpl $0x40, %eax
je 0x9628
movl %ebp, %eax
cmpq %rax, %r12
jne 0x9617
movslq %ebp, %rax
addl $0x40, %ebp
leaq 0x200(,%rax,8), %rsi
movq %r15, %rdi
callq 0x11a0
movq %rax, %r15
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x8c7e
movq %rax, (%r15,%r12,8)
incq %r12
jmp 0x95db
movl %r12d, %eax
movq $0x0, (%r15,%rax,8)
movl %r12d, 0x18(%rbx)
movq (%r14), %rdi
cmpl $0x28, 0x30(%rdi)
je 0x964e
leaq 0x3535(%rip), %rsi      # 0xcb7c
xorl %eax, %eax
callq 0x96c6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8c24
movq %rax, %rbx
movq (%r14), %rdi
cmpl $0x2a, 0x30(%rdi)
je 0x9680
leaq 0x3691(%rip), %rsi      # 0xcd0a
xorl %eax, %eax
callq 0x96c6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x96c3
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 0x9697
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9725
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 0x1ef6(%rip), %rdi      # 0xb64c
xorl %eax, %eax
callq 0x10e0
leaq 0x1a6a(%rip), %rdi      # 0xb1ce
xorl %eax, %eax
callq 0x10e0
leaq 0x3796(%rip), %rdi      # 0xcf08
xorl %eax, %eax
callq 0x10e0
leaq 0x1b0d(%rip), %rdi      # 0xb28d
xorl %eax, %eax
callq 0x10e0
movq 0x6852(%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_O3/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 0x1a0a(%rip), %rdi      # 0xb1ce
xorl %eax, %eax
callq 0x10e0
leaq 0x3740(%rip), %rdi      # 0xcf12
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10e0
leaq 0x1aa7(%rip), %rdi      # 0xb28d
xorl %eax, %eax
callq 0x10e0
movl $0x1, %edi
callq 0x1210
// File: /workspace/github_c_makefile_star2_O3/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 0x3815(%rip), %rdi      # 0xd022
movq %r14, %rsi
callq 0x1140
testl %eax, %eax
je 0x984d
movq $-0x1, %r12
leaq 0x64c9(%rip), %r15      # 0xfcf0
cmpq $0xe, %r12
je 0x985f
movq 0x10(%r15), %rdi
addq $0x10, %r15
movq %r14, %rsi
callq 0x1140
incq %r12
testl %eax, %eax
jne 0x9827
cmpq $0xf, %r12
setb %al
jmp 0x9856
leaq 0x649c(%rip), %r15      # 0xfcf0
movb $0x1, %al
movl 0x8(%r15), %ecx
movl %ecx, 0x30(%rbx)
jmp 0x9861
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9891
movq %rax, 0x38(%rbx)
popq %rbx
retq
leaq 0x3690(%rip), %rdi      # 0xcf28
leaq 0x3695(%rip), %rsi      # 0xcf34
callq 0x97b3
// File: /workspace/github_c_makefile_star2_O3/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 0x2f6f(%rip), %rsi      # 0xc828
movq %rbx, %rdi
callq 0x11e0
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x98d2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3667(%rip), %rdi      # 0xcf40
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movl $0x1, %edi
callq 0x1210
// File: /workspace/github_c_makefile_star2_O3/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 0x991d
movq $0x20, 0x40(%rbx)
popq %rbx
retq
leaq 0x3604(%rip), %rdi      # 0xcf28
leaq 0x362e(%rip), %rsi      # 0xcf59
callq 0x97b3
// File: /workspace/github_c_makefile_star2_O3/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 0x995c
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_O3/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), %al
leal -0x30(%rax), %edx
xorl %ecx, %ecx
cmpb $0xa, %dl
jb 0x998a
cmpb $0x5f, %al
je 0x998a
movl %eax, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x99d7
movl %ecx, %r14d
cmpq %r14, 0x40(%rbx)
jae 0x99a0
movq %rbx, %rdi
callq 0x986d
movq (%rbx), %rax
movb (%rax), %al
movq 0x38(%rbx), %rcx
movb %al, (%rcx,%r14)
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
incl 0x2c(%rbx)
leal 0x1(%r14), %ecx
movb 0x1(%rax), %al
leal -0x30(%rax), %edx
cmpb $0xa, %dl
jb 0x998a
cmpb $0x5f, %al
je 0x998a
movl %eax, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x1a, %dl
jb 0x998a
movl %ecx, %ecx
movq 0x38(%rbx), %rax
movb $0x0, (%rax,%rcx)
movq %rbx, %rdi
callq 0x97f7
testb %al, %al
jne 0x99f2
movl $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a31
cmpb $0x5f, %cl
je 0x9a31
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x9a68
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 0x9a31
cmpb $0x5f, %cl
je 0x9a31
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x1a, %dl
jb 0x9a31
movl %eax, %eax
movq 0x38(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq 0x38(%rbx), %rdi
callq 0x968c
movq %rax, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: opp_lex_numeral
void opp_lex_numeral(struct Opp_Scan* s)
{
	unsigned int idx = 0;
	s->t.id = TINTEGER;
	INCR;
	if (*s->src == 'x' || *s->src == 'X') {
		opp_lex_hex(s);
		return;
	} 
	else {
		DECR;
	} 

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

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

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

		default: break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x30(%rdi)
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movl 0x2c(%rdi), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x2c(%rdi)
movzbl 0x1(%rax), %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x9ab2
movq %rbx, %rdi
popq %rbx
jmp 0x99fa
movq %rax, (%rbx)
xorl %ecx, %ecx
movl %edx, 0x2c(%rbx)
movb (%rax), %sil
leal -0x30(%rsi), %edi
movl %ecx, %edx
cmpb $0xa, %dil
jb 0x9ad8
cmpb $0x2e, %sil
jne 0x9af2
movl $0x3, 0x30(%rbx)
movb (%rax), %sil
movq 0x38(%rbx), %rax
movb %sil, (%rax,%rdx)
incl %ecx
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
movl 0x2c(%rbx), %edx
incl %edx
jmp 0x9ab7
movq 0x38(%rbx), %rax
movb $0x0, (%rax,%rdx)
movl 0x30(%rbx), %eax
cmpl $0x3, %eax
je 0x9b16
cmpl $0x2, %eax
jne 0x9b24
movq 0x38(%rbx), %rdi
callq 0x11c0
movq %rax, 0x48(%rbx)
jmp 0x9b24
movq 0x38(%rbx), %rdi
callq 0x1080
movsd %xmm0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9b4e
movl %esi, %ebp
movq %rbx, %rdi
callq 0x9b62
decl %ebp
jne 0x9b42
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_O3/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 0x9be0
cmpl $0xd, %edx
je 0x9c6d
cmpl $0x20, %edx
je 0x9c6d
cmpl $0x2f, %edx
jne 0x9c88
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movl 0x2c(%rbx), %ecx
incl %ecx
movl %ecx, 0x2c(%rbx)
movzbl 0x1(%rax), %edx
cmpl $0x2a, %edx
je 0x9bfe
cmpl $0x2f, %edx
jne 0x9cae
addq $0x2, %rax
testb %dl, %dl
je 0x9c60
movzbl %dl, %ecx
cmpl $0xa, %ecx
je 0x9c60
movq %rax, (%rbx)
movb (%rax), %dl
incq %rax
jmp 0x9bc2
cmpl $0x9, %edx
je 0x9c6d
cmpl $0xa, %edx
jne 0x9c7b
incl 0x28(%rbx)
movl $0x0, 0x2c(%rbx)
jmp 0x9c6d
leaq 0x2(%rax), %rdx
movq %rdx, (%rbx)
addq $0x3, %rax
movl $0x1, %edx
movzbl -0x1(%rax), %esi
cmpl $0x29, %esi
jle 0x9c2e
cmpl $0x2f, %esi
je 0x9c3a
cmpl $0x2a, %esi
jne 0x9c4f
xorl %esi, %esi
cmpb $0x2f, (%rax)
sete %sil
subl %esi, %edx
jmp 0x9c4f
cmpl $0xa, %esi
jne 0x9c47
incl 0x28(%rbx)
xorl %ecx, %ecx
jmp 0x9c4f
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addl %esi, %edx
jmp 0x9c4f
testl %esi, %esi
je 0x9cdf
movq %rax, (%rbx)
incl %ecx
movl %ecx, 0x2c(%rbx)
incq %rax
testl %edx, %edx
jne 0x9c0e
jmp 0x9c6a
movl $0x0, 0x2c(%rbx)
incl 0x28(%rbx)
decq %rax
incl 0x2c(%rbx)
incq %rax
movq %rax, (%rbx)
jmp 0x9b78
testl %edx, %edx
jne 0x9c88
movl $0x40, 0x30(%rbx)
jmp 0x9cdd
cmpb $0x5f, %cl
je 0x9ca5
movl %ecx, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x9ca5
cmpb $0x22, %cl
jne 0x9cb7
movq %rbx, %rdi
popq %rbx
jmp 0x9d07
movq %rbx, %rdi
popq %rbx
jmp 0x9963
movl $0x15, 0x30(%rbx)
jmp 0x9cdd
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x9cc8
movq %rbx, %rdi
popq %rbx
jmp 0x9a7f
movq %rbx, %rdi
callq 0x9e07
testl %eax, %eax
je 0x9cf0
movl %eax, 0x30(%rbx)
incq (%rbx)
incl 0x2c(%rbx)
popq %rbx
retq
leaq 0x337c(%rip), %rsi      # 0xd062
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96c6
movq (%rbx), %rax
movsbl (%rax), %edx
leaq 0x32ce(%rip), %rsi      # 0xcfcb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96c6
// File: /workspace/github_c_makefile_star2_O3/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), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, (%rdi)
movl 0x2c(%rdi), %edi
leal 0x1(%rdi), %eax
movl %eax, 0x2c(%rbx)
movb 0x1(%rsi), %al
xorl %edx, %edx
cmpb $0x22, %al
je 0x9dbe
movl %edx, %r14d
cmpq %r14, 0x40(%rbx)
ja 0x9d44
movq %rbx, %rdi
callq 0x986d
movq (%rbx), %rcx
movb (%rcx), %al
cmpb $0x5c, %al
je 0x9d61
movzbl %al, %ecx
cmpl $0xff, %ecx
je 0x9de2
cmpl $0xa, %ecx
jne 0x9d92
jmp 0x9de2
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
incl 0x2c(%rbx)
movb 0x1(%rcx), %cl
movzbl %cl, %edx
cmpl $0x6d, %edx
jg 0x9d84
cmpl $0x22, %edx
je 0x9d80
cmpl $0x5c, %edx
jne 0x9df3
movl %ecx, %eax
jmp 0x9d92
movb $0xa, %al
cmpl $0x6e, %edx
je 0x9d92
cmpl $0x74, %edx
jne 0x9df3
movb $0x9, %al
movq 0x38(%rbx), %rcx
movb %al, (%rcx,%r14)
leal 0x1(%r14), %edx
movq (%rbx), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, (%rbx)
movl 0x2c(%rbx), %edi
leal 0x1(%rdi), %eax
movl %eax, 0x2c(%rbx)
movb 0x1(%rsi), %al
cmpb $0x22, %al
jne 0x9d2e
movl %edx, %edx
addq $0x2, %rsi
movq %rsi, (%rbx)
addl $0x2, %edi
movl %edi, 0x2c(%rbx)
movq 0x38(%rbx), %rax
movb $0x0, (%rax,%rdx)
movl $0x5, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x317d(%rip), %rsi      # 0xcf66
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96c6
movsbl %cl, %edx
leaq 0x318c(%rip), %rsi      # 0xcf89
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96c6
// File: /workspace/github_c_makefile_star2_O3/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 0x2ec4(%rip), %r14      # 0xcfe4
leaq 0x2dcd(%rip), %r12      # 0xcef4
leaq 0x2ecb(%rip), %r13      # 0xcff9
leaq 0x2eb9(%rip), %rbp      # 0xcfee
leaq 0x2ed0(%rip), %r15      # 0xd00c
movq %rbx, %rdi
callq 0x9b62
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 0xa1ab
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x38(%rbx), %rsi
leaq 0x2e8b(%rip), %rdi      # 0xd002
jmp 0xa19a
movsd 0x48(%rbx), %xmm0
movq %rbp, %rdi
movb $0x1, %al
callq 0x10e0
jmp 0xa1a1
movq 0x48(%rbx), %rsi
movq %r13, %rdi
jmp 0xa19a
movq 0x38(%rbx), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10e0
movl 0x30(%rbx), %esi
cmpl $0x40, %esi
jne 0xa13c
jmp 0xa1c3
leal -0x6(%rsi), %eax
cmpl $0x20, %eax
ja 0xa1a4
leaq 0x2e5f(%rip), %rdi      # 0xd019
xorl %eax, %eax
callq 0x10e0
jmp 0xa1a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xa1f6
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 0xa1df
jmp 0xa1f8
xorl %eax, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa22c
leaq 0x1370(%rip), %rdi      # 0xb590
leaq 0x2e55(%rip), %rsi      # 0xd07c
callq 0x97b3
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0xa00, %edi            # imm = 0xA00
callq *%r14
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xa258
leaq 0x1344(%rip), %rdi      # 0xb590
leaq 0x2e29(%rip), %rsi      # 0xd07c
callq 0x97b3
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 0xa261
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa2b4
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 0xa29d
jmp 0xa2b6
xorl %eax, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0xa326
xorl %r15d, %r15d
movq %rax, %r12
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0xa35d
movq 0x30(%r12), %rax
testq %rax, %rax
jne 0xa2cd
movl $0x38, %edi
callq *0x18(%r14)
movq %rax, 0x30(%r12)
testq %rax, %rax
jne 0xa314
leaq 0xd24(%rip), %rdi       # 0xb027
leaq 0x2d81(%rip), %rsi      # 0xd08b
callq 0x97b3
movq 0x30(%r12), %rax
movq %rbx, (%rax)
movq $0x0, 0x30(%rax)
movq 0x30(%r12), %r15
jmp 0xa35d
movl $0x38, %edi
callq *0x18(%r14)
movq %rax, %r15
testq %rax, %rax
jne 0xa34a
leaq 0xce9(%rip), %rdi       # 0xb027
leaq 0x2d46(%rip), %rsi      # 0xd08b
callq 0x97b3
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_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movb (%rsi), %dl
testb %dl, %dl
je 0xa39f
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 0xa388
jmp 0xa3a1
xorl %eax, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %r12
testq %r12, %r12
je 0xa3cc
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0xa3d8
movq 0x30(%r12), %r12
jmp 0xa3b0
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0xa3a8
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcde(%rip), %rdi       # 0x2004
callq 0x1030
testq %rax, %rax
leaq 0xcd4(%rip), %rcx       # 0x2009
cmovneq %rax, %rcx
movq %rcx, 0x2df0(%rip)      # 0x4130
leaq 0x2df9(%rip), %rdi      # 0x4140
movl $0x100, %esi            # imm = 0x100
callq 0x11e0
cmpl $-0x1, %eax
je 0x1469
xorl %edi, %edi
callq 0x1170
movq %rax, 0x8(%rsp)
cmpq $-0x1, %rax
je 0x1472
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10e0
testq %rax, %rax
je 0x1485
leaq 0x2eb1(%rip), %rdi      # 0x4240
leaq 0xca4(%rip), %rdx       # 0x203a
leaq 0x10(%rsp), %rcx
movl $0x20, %esi
callq 0x11a0
testq %rax, %rax
je 0x148e
cmpl $0x1, %ebp
jne 0x13cb
movq 0x2c26(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xd79(%rip), %rsi       # 0x213d
callq 0x14a1
jmp 0x1430
jle 0x1430
movl %ebp, %r13d
movl $0x1, %ebp
leaq 0xc97(%rip), %r14       # 0x2073
movq (%rbx,%rbp,8), %rdi
movq %r14, %rsi
callq 0x11b0
movq (%rbx,%rbp,8), %r12
testq %rax, %rax
je 0x1441
movq %rax, %r15
movq %r12, %rdi
movl $0x2f, %esi
callq 0x10d0
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r12, %rsi
movq %r15, %rdi
callq 0x14a1
movq %r15, %rdi
callq 0x1060
testl %eax, %eax
jne 0x1452
movq %r15, %rdi
callq 0x1070
incq %rbp
cmpq %rbp, %r13
jne 0x13dc
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2d(%rip), %rsi       # 0x2075
movl $0x1, %edi
movq %r12, %rdx
jmp 0x1462
movq (%rbx,%rbp,8), %rdx
leaq 0xc22(%rip), %rsi       # 0x207f
movl $0x1, %edi
xorl %eax, %eax
callq 0x1190
leaq 0xb9d(%rip), %rsi       # 0x200d
jmp 0x1479
leaq 0xbf5(%rip), %rsi       # 0x206e
movl $0x1, %edi
xorl %eax, %eax
callq 0x1190
leaq 0xb8d(%rip), %rsi       # 0x2019
jmp 0x1495
leaq 0xbba(%rip), %rsi       # 0x204f
movl $0x1, %edi
xorl %eax, %eax
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/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 0x1633
leaq 0x1a65(%rip), %rdi      # 0x3080
callq 0x1060
leaq 0x1a67(%rip), %rdi      # 0x308e
callq 0x1060
movl $0x1, %eax
popq %rcx
retq
movq %rsi, %rdi
callq 0x11f0
xorl %eax, %eax
jmp 0x1631
nop
// File: /workspace/github_c_makefile_star2_O3/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
xorl %eax, %eax
callq 0x11e7
movq %rsp, %r13
movl %eax, 0x8(%r13)
leaq 0xdf5(%rip), %rax       # 0x205b
movq %rax, 0x10(%r13)
xorl %eax, %eax
callq 0x11ea
movl %eax, 0x18(%r13)
leaq 0xdf6(%rip), %rax       # 0x2072
movq %rax, 0x20(%r13)
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(%r13)
movq $0x0, 0x30(%r13)
movl $0x0, 0x38(%r13)
leaq 0xd8e(%rip), %rdx       # 0x2044
leaq 0xdcf(%rip), %r14       # 0x208c
leaq 0xe12(%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 0x137a
xorl %eax, %eax
callq 0x11e7
movl %eax, %r12d
xorl %eax, %eax
callq 0x11ea
cmpl %eax, %r12d
jg 0x1331
cmpl 0x8(%r13), %r12d
je 0x131d
movl %r12d, %edi
callq 0x1224
testl %eax, %eax
jne 0x135b
leal 0x1(%r12), %ebp
xorl %eax, %eax
callq 0x11ea
cmpl %eax, %r12d
movl %ebp, %r12d
jl 0x130b
movq %r15, %rdi
callq 0x1040
movq 0x10(%r13), %rdx
addq $0x10, %r13
testq %rdx, %rdx
jne 0x12c4
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd69(%rip), %rdi       # 0x20cb
leaq 0xd3d(%rip), %rsi       # 0x20a6
leaq 0xd44(%rip), %rcx       # 0x20b4
movl $0x29, %edx
callq 0x1060
leaq 0xd16(%rip), %rdi       # 0x2097
leaq 0xd1e(%rip), %rsi       # 0x20a6
leaq 0xd25(%rip), %rcx       # 0x20b4
movl $0x25, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/hoomanist[P]carrot/rm.c
// Function: main
int 
main(int argc, char **argv)
{
	if(argc <= 1)
	{
		fprintf(stderr, "usage : %s filename[s]...\n", argv[0]);
		return 1;
	}
	
	for(int i = 1; i < argc; i++)
		if(remove(argv[i]) == -1)
			fprintf(stderr, "oops something went wrong.");
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x2, %edi
jl 0x11d9
movl %edi, %r14d
movl $0x1, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x1030
cmpl $-0x1, %eax
je 0x11ca
incq %r15
cmpq %r15, %r14
jne 0x11b2
jmp 0x11d1
callq 0x1070
jmp 0x11c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x108c
movl $0x1, %eax
jmp 0x11d3
// File: /workspace/github_c_makefile_star2_O3/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 0x3ce4
leaq 0x3e39(%rip), %rdi      # 0x502c
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ce7
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 0x3d11
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 0x3d3b
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 0x3d65
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 0x3d8f
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 0x3db9
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 0x3e0d
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_O3/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 0x1417
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x1420
leaq 0x4529(%rip), %rbx      # 0x5870
movq %rbx, %rdi
callq 0x1040
movb (%r14), %dl
testb %dl, %dl
je 0x1445
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
je 0x13ed
movb (%r14), %dl
testb %dl, %dl
jne 0x1404
jmp 0x1429
movq %rbp, %rdi
callq 0x1040
movl $0x2e, %r9d
movb (%r14), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x143e
addl $0x3, %ebx
addl %r12d, %r15d
incl %r15d
incq %r14
movl %ebx, %ecx
jmp 0x136f
leaq 0x43c1(%rip), %rbx      # 0x57df
jmp 0x1445
leaq 0x43b5(%rip), %rbx      # 0x57dc
jmp 0x1445
testl %eax, %eax
leaq 0x443e(%rip), %rbx      # 0x5870
je 0x1445
movq %rsp, %rdi
callq 0x1040
jmp 0x1445
leaq 0x442b(%rip), %rbx      # 0x5870
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_O3/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 0x4372(%rip), %rdi      # 0x57e4
callq 0x1040
movq %r14, %rdi
callq 0x38f8
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r14), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x14aa
leaq 0x3c93(%rip), %rdi      # 0x5131
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x14cf
leaq 0x3caf(%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 0x3bfc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2940
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r15), %ecx
testl %ecx, %ecx
setne %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x1528
leaq 0x3c68(%rip), %rdi      # 0x517e
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x164e
leaq 0x3c81(%rip), %rdi      # 0x51b0
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29f4
leaq 0x3c84(%rip), %rdi      # 0x51d1
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2a05
movzbl %al, %esi
leaq 0x3c77(%rip), %rdi      # 0x51e2
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2a1a
leaq 0x3c75(%rip), %rdi      # 0x51f8
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a3f
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x15c8
leaq 0x3b52(%rip), %rdi      # 0x510e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x15e4
leaq 0x4201(%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 0x394e
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x161f
leaq 0x3b1e(%rip), %rdi      # 0x5131
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1644
leaq 0x3b3a(%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 0x3bfc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29d5
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq