LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/expression.hpp
// Function: expression_t::expression_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, long)
expression_t(std::string literal, std::string disambiguation, long lineno, long colno) {
		if (disambiguation == "int") {
			type = et_integer_literal;
			integer_literal = literal;
		} else if (disambiguation == "str") {
			type = et_string_literal;
			string_literal = literal;
		} else if (disambiguation == "chr") {
			type = et_character_literal;
			character_literal = literal;
		} else if (disambiguation == "id") {
			type = et_identifier;
			identifier = literal;
		}
		this->lineno = lineno;
		this->colno = colno;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x40(%rsp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, 0x38(%rsp)
movq %rdi, %r15
leaq 0x20(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x20(%rdi)
xorl %r12d, %r12d
movq %r12, 0x28(%rdi)
movb %r12b, 0x30(%rdi)
leaq 0x48(%rdi), %rbx
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x48(%rdi)
movq %r12, 0x50(%rdi)
movb %r12b, 0x58(%rdi)
leaq 0x68(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x78(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x68(%rdi)
movq %r12, 0x70(%rdi)
movb %r12b, 0x78(%rdi)
leaq 0x88(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x98(%rdi), %rbp
movq %rbp, 0x88(%rdi)
movq %r12, 0x90(%rdi)
movb %r12b, 0x98(%rdi)
leaq 0xc8(%rdi), %rax
movq %rax, 0xb8(%rdi)
movq %r12, 0xc0(%rdi)
movb %r12b, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movq %r12, 0xe8(%rdi)
leaq 0x9dda(%rip), %rsi      # 0x194da
movq %rdx, %rdi
callq 0x30b0
movq %rbx, 0x30(%rsp)
testl %eax, %eax
je 0xf76f
leaq 0xa29b(%rip), %rsi      # 0x199b3
movq %r13, %rdi
callq 0x30b0
testl %eax, %eax
je 0xf757
leaq 0xa28c(%rip), %rsi      # 0x199b7
movq %r13, %rdi
callq 0x30b0
testl %eax, %eax
je 0xf764
leaq 0xa236(%rip), %rsi      # 0x19974
movq %r13, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xf786
movl $0x3, %r12d
movq 0x18(%rsp), %rbx
jmp 0xf76f
movl $0x1, %r12d
movq 0x28(%rsp), %rbx
jmp 0xf76f
movl $0x2, %r12d
movq 0x20(%rsp), %rbx
leaq 0xb8(%r15), %r13
movl %r12d, (%r15)
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
callq 0x3150
movq %r14, 0x10(%r15)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0xfa02
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq %rbp, %rdi
je 0xf7c6
movq (%rbp), %rsi
incq %rsi
callq 0x3280
movq 0x20(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0xf7e3
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x30(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0xf802
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x28(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0xf821
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_t::symbol_t(type_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<parameter_t, std::allocator<parameter_t>>)
symbol_t(type_t type, identifier_t identifier, std::vector<parameter_t> parameters) {
		this->type = type;
		this->identifier = identifier;
		this->parameters = parameters;
		is_function = true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x31(%rdi)
movq %rsi, (%rdi)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3150
movq %r15, %rdi
movq %r12, %rsi
callq 0x10a78
movb $0x1, 0x40(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x9730
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0xfec3
movq (%r13), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_table_t::exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool exists(identifier_t identifier) {
		// Search the current scope for the specified identifier.
		for (int i = 0; i < symbols.size(); i++) {
			if (symbols[i].identifier == identifier) {
				return true;
			}
		}
		if (parent) {
			// Search the parent scope for the specified identifier.
			return parent->exists(identifier);
		} else {
			return false;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %rax
subq %r12, %rax
je 0xff62
sarq $0x4, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r13
movq 0x8(%rbx), %r15
cmpq $0x1, %r13
adcq $0x0, %r13
addq $0x10, %r12
cmpq %r15, (%r12)
jne 0xff59
movb $0x1, %bpl
testq %r15, %r15
je 0xffb2
movq (%rbx), %rsi
movq -0x8(%r12), %rdi
movq %r15, %rdx
callq 0x3290
testl %eax, %eax
je 0xffb2
addq $0x50, %r12
decq %r13
jne 0xff37
movq (%r14), %r14
testq %r14, %r14
je 0xffb0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x179ce
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfef4
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xffb2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0xffb2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xffdd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_table_t::fetch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
symbol_t& fetch(identifier_t identifier) {
		// Search the current scope for the specified identifier.
		for (int i = 0; i < symbols.size(); i++) {
			if (symbols[i].identifier == identifier) {
				return symbols[i];
			}
		}
		// Search the parent scope for the specified identifier.
		return parent->fetch(identifier);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %rax
subq %rbx, %rax
je 0x141ed
sarq $0x4, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r13
movq 0x8(%r14), %r12
cmpq $0x1, %r13
adcq $0x0, %r13
cmpq %r12, 0x10(%rbx)
jne 0x141e2
testq %r12, %r12
je 0x14235
movq (%r14), %rsi
movq 0x8(%rbx), %rdi
movq %r12, %rdx
callq 0x3290
testl %eax, %eax
je 0x14235
addq $0x50, %rbx
decq %r13
jne 0x141c4
jmp 0x141f1
movq 0x8(%r14), %r12
movq (%r15), %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %rsi, %r12
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x179ce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14186
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14235
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1425f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_table_t::exists_locally(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool exists_locally(identifier_t identifier) {
		// Search the current scope for the specified identifier.
		for (int i = 0; i < symbols.size(); i++) {
			if (symbols[i].identifier == identifier) {
				return true;
			}
		}
		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
subq %r15, %rax
je 0x143e8
sarq $0x4, %rax
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r12
xorl %r13d, %r13d
cmpq $0x1, %r12
sbbq %r12, %r13
movq %rsi, (%rsp)
movq 0x8(%rsi), %r14
addq $0x10, %r15
movb $0x1, %bpl
movl $0x1, %ebx
cmpq %r14, (%r15)
jne 0x143cb
testq %r14, %r14
je 0x143ea
movq (%rsp), %rax
movq (%rax), %rsi
movq -0x8(%r15), %rdi
movq %r14, %rdx
callq 0x3290
testl %eax, %eax
je 0x143ea
cmpq %rbx, %r12
seta %bpl
addq $0x50, %r15
leaq (%rbx,%r13), %rax
incq %rax
incq %rbx
cmpq $0x1, %rax
jne 0x143aa
jmp 0x143ea
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./semantic/semantic_analyzer.hpp
// Function: semantic_analyzer_t::expand_ast(statement_t*&)
void expand_ast(statement_t*& statement) {
		if (statement->type == st_compound) {
			compound_statement_t& stmt = statement->compound_stmt;
			for (int i = 0; i < stmt.statements.size(); i++) {
				expand_ast(stmt.statements[i]);
			}
		} else if (statement->type == st_conditional) {
			expand_ast(statement->conditional_stmt.condition);
			expand_ast(statement->conditional_stmt.body);
		} else if (statement->type == st_while) {
			expand_ast(statement->while_stmt.condition);
			expand_ast(statement->while_stmt.body);
		} else if (statement->type == st_return) {
			expand_ast(statement->return_stmt.value);
		} else if (statement->type == st_variable_declaration) {
			variable_declaration_statement_t& stmt = statement->variable_declaration_stmt;
			if (stmt.initializer) {
				expand_ast(stmt.initializer);
			}
		} else if (statement->type == st_expression) {
			expand_ast(statement->expression_stmt.expression);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x48a6(%rip), %r12      # 0x19220
movq (%r15), %r14
movl (%r14), %eax
cmpq $0x6, %rax
ja 0x14a22
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movl $0x28, %r13d
movl $0x20, %eax
jmp 0x149ab
movl $0x38, %r13d
movl $0x30, %eax
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a2c
addq (%r15), %r13
movq %r13, %r15
jmp 0x1497a
cmpq $0x0, 0x70(%r14)
je 0x14a22
addq $0x70, %r14
jmp 0x149d8
addq $0x78, %r14
jmp 0x149d8
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x14a2c
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
je 0x14a22
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rsi
movq %rbx, %rdi
callq 0x14964
incq %r12
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %r15
cmpq %r12, %rax
ja 0x149fc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::pack_strings(statement_t*)
void pack_strings(statement_t* statement) {
		if (statement->type == st_compound) {
			compound_statement_t stmt = statement->compound_stmt;
			for (int i = 0; i < stmt.statements.size(); i++) {
				pack_strings(stmt.statements[i]);
			}
		} else if (statement->type == st_conditional) {
			pack_strings(statement->conditional_stmt.condition);
			pack_strings(statement->conditional_stmt.body);
		} else if (statement->type == st_while) {
			pack_strings(statement->while_stmt.condition);
			pack_strings(statement->while_stmt.body);
		} else if (statement->type == st_return) {
			pack_strings(statement->return_stmt.value);
		} else if (statement->type == st_variable_declaration) {
			variable_declaration_statement_t stmt = statement->variable_declaration_stmt;
			if (stmt.initializer) {
				pack_strings(stmt.initializer);
			}
		} else if (statement->type == st_expression) {
			pack_strings(statement->expression_stmt.expression);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3282(%rip), %r15      # 0x19298
movl (%r14), %eax
cmpq $0x6, %rax
ja 0x16119
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl $0x28, %r12d
movl $0x20, %eax
jmp 0x16044
movl $0x38, %r12d
movl $0x30, %eax
movq (%r14,%rax), %rsi
movq %rbx, %rdi
callq 0x1615e
movq (%r14,%r12), %r14
jmp 0x16016
movq 0x48(%r14), %rax
leaq 0x10(%rsp), %rdi
movq %rax, -0x8(%rdi)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
addq %rsi, %rdx
callq 0x179ce
movq 0x70(%r14), %rsi
movq %rsi, 0x10(%r15)
testq %rsi, %rsi
je 0x16091
movq %rbx, %rdi
callq 0x1615e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x16119
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x16114
movq 0x78(%r14), %rsi
jmp 0x160af
movq 0x40(%r14), %rsi
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1615e
addq $0x8, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb076
movq (%r15), %rdi
cmpq %rdi, 0x8(%r15)
je 0x16107
xorl %r14d, %r14d
movq (%rdi,%r14,8), %rsi
movq %rbx, %rdi
callq 0x15ffe
incq %r14
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x160e2
testq %rdi, %rdi
je 0x16119
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x16156
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x16151
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16156
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::pack_strings(expression_t*)
void pack_strings(expression_t* expression) {
		if (expression->type == et_string_literal) {
			long string_label = label++;
			expression->string_label = string_label;
			emit("S%ld:\n", string_label);
			for (int i = 0; i < expression->string_literal.size(); i++) {
				emit("    .quad   %u\n", (unsigned char)expression->string_literal[i]);
			}
			emit("    .quad   0\n");
		} else if (expression->type == et_function_call) {
			function_call_expression_t expr = expression->function_call;
			for (int i = 0; i < expr.arguments.size(); i++) {
				pack_strings(expr.arguments[i]);
			}
		} else if (expression->type == et_binary) {
			pack_strings(expression->binary.left_operand);
			pack_strings(expression->binary.right_operand);
		} else if (expression->type == et_unary) {
			pack_strings(expression->unary.operand);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x313e(%rip), %r15      # 0x192b4
movl (%r14), %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0x1623e
movl $0x108, %eax            # imm = 0x108
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
callq 0x1615e
movl $0xf8, %eax
movq (%r14,%rax), %r14
jmp 0x16176
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0xb8(%r14), %rsi
movq 0xc0(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x179ce
leaq 0x20(%rsp), %rdi
addq $0xd8, %r14
movq %r14, %rsi
callq 0xf82a
movq 0x20(%rsp), %rdi
cmpq %rdi, 0x28(%rsp)
je 0x16216
xorl %r14d, %r14d
movq (%rdi,%r14,8), %rsi
movq %rbx, %rdi
callq 0x1615e
incq %r14
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x161f1
testq %rdi, %rdi
je 0x16228
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1623e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rdx
leaq 0x1(%rdx), %rax
movq %rax, 0x20(%rbx)
movq %rdx, 0x40(%r14)
leaq 0x3a21(%rip), %rsi      # 0x19c82
movq %rbx, %rdi
xorl %eax, %eax
callq 0x162e6
cmpq $0x0, 0x28(%r14)
je 0x1629b
leaq 0x3a10(%rip), %r15      # 0x19c89
xorl %r12d, %r12d
movq 0x20(%r14), %rax
movzbl (%rax,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x162e6
incq %r12
cmpq %r12, 0x28(%r14)
ja 0x1627c
leaq 0x39f7(%rip), %rsi      # 0x19c99
movq %rbx, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x162e6
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x162dd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x162dd
movq %rax, %rbx
movq %rsp, %rdi
callq 0xfa02
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::aligned_offset(function_t, symbol_table_t&)
long aligned_offset(function_t function, symbol_table_t& symbols) {
		symbol_table_t new_symbols(&symbols);
		long lowest_offset = 0;
		for (int i = 0; i < function.body.size(); i++) {
			aligned_offset_statement(function.body[i], new_symbols, lowest_offset);
		}

		long params_offset;
		if (function.parameters.size() >= 6) {
			params_offset = 48;
		} else {
			params_offset = function.parameters.size() * 8;
		}

		long highest_offset = -lowest_offset + params_offset;
		int remainder = highest_offset % 8;
		if (!remainder) {
			return highest_offset;
		}
		return highest_offset + 8 - remainder;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
leaq 0x10(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rdx, -0x8(%rbx)
movb 0x20(%rdx), %cl
movb %cl, 0x18(%rbx)
movups 0x28(%rdx), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x38(%rdx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, (%rsp)
movq 0x40(%rsi), %rcx
cmpq %rcx, 0x48(%rsi)
je 0x163f2
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq (%rcx,%rbp,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x169da
incq %rbp
movq 0x40(%r14), %rcx
movq 0x48(%r14), %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rbp, %rax
ja 0x163c5
movq (%rsp), %rax
movq 0x30(%r14), %rcx
subq 0x28(%r14), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
leaq (,%rdx,8), %rcx
cmpq $0x6, %rdx
movl $0x30, %edx
cmovbq %rcx, %rdx
subq %rax, %rdx
leaq 0x7(%rdx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
andq $-0x8, %rax
leaq 0x8(%rax), %r14
cmpq %rax, %rdx
cmoveq %rdx, %r14
movq %rbx, %rdi
callq 0x1553e
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1553e
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::check_PC(int)
bool Emulator::check_PC(int a)
{
    if(a<0 || a>pc_upper)
    {
        fault = true;
        string tmp = faults.find(0)->second;
        PC--;
        string tmp2 = current_state();
        PC++;

        fault_cause = tmp + " when executing " + tmp2;

        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebx
cmpl $0x400, %esi            # imm = 0x400
jb 0x52bc
movq %rdi, %r14
movb $0x1, 0x51(%rdi)
movq 0x5061(%rip), %rax      # 0xa1b8
testq %rax, %rax
je 0x5185
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x515c
leaq 0x5041(%rip), %rax      # 0xa1b0
cmpq %rax, %rcx
je 0x518c
cmpl $0x0, 0x20(%rcx)
leaq 0x5031(%rip), %rax      # 0xa1b0
cmoveq %rcx, %rax
jmp 0x518c
leaq 0x5024(%rip), %rax      # 0xa1b0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x431c
decl 0x28(%r14)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4e0c
incl 0x28(%r14)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x431c
leaq 0x22fb(%rip), %rsi      # 0x74e2
leaq 0x8(%rsp), %rdi
callq 0x2290
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x522c
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x5233
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq $0x58, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x5273
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x528a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52a5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x52bc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
cmpl $0x400, %ebx            # imm = 0x400
setb %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52d9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x52f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x52f8
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5318
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x5318
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x532f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::check_SP(int)
bool Emulator::check_SP(int a)
{
    if(a>end_address || a<=data_upper)
    {
        fault = true;
        string tmp = faults.find(1)->second;
        PC--;
        string tmp2 = current_state();
        PC++;

        fault_cause = tmp + " when executing " + tmp2;
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0x10000, %esi          # imm = 0x10000
setb %al
cmpl %esi, 0x38(%rdi)
setl %bl
andb %al, %bl
jne 0x577b
movq %rdi, %r14
movb $0x1, 0x51(%rdi)
movq 0x4bb4(%rip), %rcx      # 0xa1b8
testq %rcx, %rcx
je 0x5644
leaq 0x4ba0(%rip), %rax      # 0xa1b0
xorl %edx, %edx
cmpl $0x0, 0x20(%rcx)
sete %dl
cmovneq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x5610
leaq 0x4b82(%rip), %rcx      # 0xa1b0
cmpq %rcx, %rax
je 0x564b
cmpl $0x2, 0x20(%rax)
leaq 0x4b72(%rip), %rcx      # 0xa1b0
cmovbq %rax, %rcx
jmp 0x564b
leaq 0x4b65(%rip), %rcx      # 0xa1b0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rcx), %rsi
movq 0x30(%rcx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x431c
decl 0x28(%r14)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4e0c
incl 0x28(%r14)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x431c
leaq 0x1e3c(%rip), %rsi      # 0x74e2
leaq 0x8(%rsp), %rdi
callq 0x2290
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x56eb
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x56f2
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq $0x58, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x5732
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5749
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5764
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x577b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5791
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x57b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x57b0
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57d0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x57d0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x57e7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::reverse_decode[abi:cxx11](unsigned int) const
string Emulator::reverse_decode(unsigned a) const
{
    unsigned opcode = (a<<24)>>24;

    ostringstream oss;

    map<unsigned, pair<unsigned, string> >::const_iterator mt = decoder.find(opcode);

    string mnem = mt->second.second;    // storing the mnemonic

    oss<<mnem;

    if(mt->second.first==1)     // operand also present
    {
        int tmp = a & 0xffffff00;
        tmp /= 256;

        oss<<" "<<tmp;
    }

    return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2200
movq 0x495f(%rip), %rdx      # 0xa188
testq %rdx, %rdx
je 0x586c
movzbl %bpl, %ecx
leaq 0x4947(%rip), %rax      # 0xa180
xorl %esi, %esi
cmpl %ecx, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rax
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x5839
leaq 0x4929(%rip), %r15      # 0xa180
cmpq %r15, %rax
je 0x5873
cmpl 0x20(%rax), %ecx
leaq 0x491a(%rip), %r15      # 0xa180
cmovaeq %rax, %r15
jmp 0x5873
leaq 0x490d(%rip), %r15      # 0xa180
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x431c
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x21b0
cmpl $0x1, 0x28(%r15)
jne 0x58ce
leaq 0x1c4b(%rip), %rsi      # 0x74fb
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
callq 0x21b0
sarl $0x8, %ebp
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x2260
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2230
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x58f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x46d0(%rip), %rsi      # 0x9fc8
leaq 0x20(%rsp), %rdi
callq 0x20d0
leaq 0x90(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5927
movq %rax, %rbx
jmp 0x5940
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x5940
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x4681(%rip), %rsi      # 0x9fc8
leaq 0x20(%rsp), %rdi
callq 0x20d0
leaq 0x90(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/hm3/flushlist.h
// Function: bool hm3::FlushList<hm3::SkipList, hm3::flusher::DiskFileFlusher<hm3::idgenerator::IDGeneratorDate>, std::nullptr_t>::putT_<hm3::Pair>(hm3::Pair&&)
bool putT_(UPAIR &&data){
		bool const result = list_.put( std::forward<UPAIR>(data) );

		if (list_.getBytes() > maxSize_){
			flush();
			list_.removeAll();
			notifyLoader_(loader_);
		}

		return result;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x37b4
movl %eax, %ebp
movq (%rbx), %rsi
movq 0x210(%rsi), %rax
cmpq 0x60(%rbx), %rax
jbe 0x3339
leaq 0x8(%rbx), %rdi
callq 0x2b86
movq (%rbx), %rdi
callq 0x3562
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: CaptureInteger(gaps::R2Grid&)
static int
CaptureInteger(R2Grid& image)
{
  // Allocate pixel buffer
  unsigned char *pixels = new unsigned char [ 3 * width * height ];

  // Set packing parameters for glReadPixels
  if ((width % 4) != 0) glPixelStorei(GL_PACK_ALIGNMENT, 1);

  // Run main loop  -- never returns   // Read pixels
  glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels);

  // Fill image
  unsigned char *pixelp = pixels;
  for (int iy = 0; iy < height; iy++) {
    for (int ix = 0; ix < width; ix++) {
      unsigned int red = *pixelp++;
      unsigned int green = *pixelp++;
      unsigned int blue = *pixelp++;
      unsigned int value = 0;
      value |= red << 16;
      value |= green <<  8;
      value |= blue;
      image.SetGridValue(ix, iy, value);
    }
  }

  // Delete pixels
  delete [] pixels;
  
  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x12c8ed(%rip), %ebp    # 0x1549a0
movl 0x12c8ea(%rip), %r15d   # 0x1549a4
movl %ebp, %eax
imull %r15d, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rdi
callq 0x22040
movq %rax, %rbx
testb $0x3, %bpl
je 0x280f0
movl $0xd05, %edi            # imm = 0xD05
movl $0x1, %esi
callq 0x223f0
movl 0x12c8b7(%rip), %ebp    # 0x1549a0
movl 0x12c8b4(%rip), %r15d   # 0x1549a4
movq %rbx, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %edx
movl %r15d, %ecx
movl $0x1907, %r8d           # imm = 0x1907
movl $0x1401, %r9d           # imm = 0x1401
callq 0x223a0
movslq 0x12c88f(%rip), %rax    # 0x1549a4
testq %rax, %rax
jle 0x2817f
movl 0x12c880(%rip), %ecx    # 0x1549a0
movq 0xb8(%r14), %rdx
movslq 0xc8(%r14), %rsi
shlq $0x3, %rsi
xorl %edi, %edi
movq %rbx, %r8
testl %ecx, %ecx
jle 0x28174
xorl %r9d, %r9d
movzbl (%r8), %r10d
movzbl 0x1(%r8), %r11d
movzbl 0x2(%r8), %ebp
shll $0x10, %r10d
shll $0x8, %r11d
orl %r10d, %r11d
orl %ebp, %r11d
xorps %xmm0, %xmm0
cvtsi2sd %r11d, %xmm0
addq $0x3, %r8
movsd %xmm0, (%rdx,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x2813e
incq %rdi
addq %rsi, %rdx
cmpq %rax, %rdi
jne 0x28137
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22c00
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: DrawRootWithOpenGL(gaps::R3Camera const&, gaps::R3Scene*, int, int)
static void
DrawRootWithOpenGL(const R3Camera& camera, R3Scene *scene, int color_scheme, RNBoolean omit_objects = FALSE)
{
  // This is a hack to account for coincident front and back faces
  glDepthRange(0, 0.999999);
  glEnable(GL_CULL_FACE);
  R3null_material.Draw();
  DrawNodeWithOpenGL(camera, scene, scene->Root(), color_scheme, omit_objects);
  glDisable(GL_CULL_FACE);
  glDepthRange(0, 1);
  R3null_material.Draw();
  DrawNodeWithOpenGL(camera, scene, scene->Root(), color_scheme, omit_objects);
  R3null_material.Draw();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movsd 0xc1e9d(%rip), %xmm1    # 0xec0b0
xorps %xmm0, %xmm0
callq 0x23030
movl $0xb44, %edi            # imm = 0xB44
callq 0x227e0
leaq 0x12fbb4(%rip), %r12    # 0x159de0
movq %r12, %rdi
xorl %esi, %esi
callq 0x466ee
movq (%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2a292
movl $0xb44, %edi            # imm = 0xB44
callq 0x221e0
movsd 0xc1e15(%rip), %xmm1    # 0xec070
xorps %xmm0, %xmm0
callq 0x23030
movq %r12, %rdi
xorl %esi, %esi
callq 0x466ee
movq (%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2a292
movq %r12, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x466ee
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: EstimateGroundY(gaps::R3Camera const&, gaps::R3Scene*)
static RNScalar
EstimateGroundY(const R3Camera& camera, R3Scene *scene)
{
  // Get convenient variables
  if (!scene) return 0;

  // Check if scene has a node named "Room#*" containing camera
  for (int i = 0; i < scene->NNodes(); i++) {
    R3SceneNode *node = scene->Node(i);
    if (node->Name() && !strncmp(node->Name(), "Room#", 5)) {
      if (R3Contains(node->BBox(), camera.Origin())) {
        return node->BBox().YMin();
      }
    }
  }

#if 0
  // Check first intersection with ray cast straight down
  if (R3Contains(scene->BBox(), camera.Origin())) {
    R3Ray ray(camera.Origin(), R3negy_vector);
    R3Point position;
    R3Vector normal;
    if (scene->Intersects(ray, NULL, NULL, NULL, &position, &normal)) {
      if (normal.Y() > 0.9) return position.Y();
    }
  }
#endif
  
  // If all else fails, return bounding box ymin
  return scene->BBox().YMin();
}

// Assembly:
testq %rsi, %rsi
je 0x2ac55
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x14(%rsi), %ebp
testl %ebp, %ebp
jle 0x2ac36
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0xc177e(%rip), %r15     # 0xec369
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %r12
movq 0x1a0(%r12), %rdi
testq %rdi, %rdi
je 0x2ac2b
movl $0x5, %edx
movq %r15, %rsi
callq 0x223c0
testl %eax, %eax
jne 0x2ac2b
movq %r12, %rdi
callq 0x3ee78
movq %rax, %rdi
movq %r14, %rsi
callq 0x4eb7c
testl %eax, %eax
jne 0x2ac39
movl 0x14(%rbx), %ebp
incq %r13
movslq %ebp, %rax
cmpq %rax, %r13
jl 0x2abeb
movq (%rbx), %r12
movq %r12, %rdi
callq 0x3ee78
movsd 0x10(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: purse(unsigned int*, int*, int*, long)
int purse(unsigned int *T,int *P,int *P_2,long int fsize){ //purse T and set P.
    std::cout << std::endl;
    int tn = -1; //temporary number
    int pn = 1;
    P[0] = 0;
    for (int i = 0 ; i < fsize-1 ; i++){
        if(T[i] > T[i+1]){ //T[i]がL 
            tn = i;
        }
        if(T[i] < T[i+1] && tn != -1){
            P[pn] = tn+1;
            P_2[pn-1] = P[pn] - P[pn-1];
            pn++;
            tn = -1;
        }
    }
    P[pn] = tn+1;
    P_2[pn-1] = fsize - P[pn-1]; //not to left last character
    
    int k = 0;
    for(int i = 0 ; i < fsize ; i++){
        if(P[k]==i){
            if(i+40 > fsize){printf("(%d,%d)",P[k],P_2[k]);}
            k++;
        }
        //if(i > fsize/2){exit(3);}
        if(i+40 > fsize){
            std::cout << std::hex << int(T[i]);
            std::cout << " ";
        }
    }
    return pn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x394d(%rip), %r13      # 0x5fd8
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq %r15, 0x8(%rsp)
movl $0x0, (%r15)
cmpq $0x2, %rbx
jl 0x2715
leaq -0x1(%rbx), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ebp
xorl %edx, %edx
movl %eax, %esi
movl (%r12,%rdx,4), %eax
cmpl 0x4(%r12,%rdx,4), %eax
movl %edx, %eax
cmovbel %esi, %eax
jae 0x2709
cmpl $-0x1, %eax
je 0x2709
incl %eax
movslq %ebp, %rbp
movq 0x8(%rsp), %rsi
movl %eax, (%rsi,%rbp,4)
subl -0x4(%rsi,%rbp,4), %eax
movl %eax, -0x4(%r14,%rbp,4)
incl %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rcx
jne 0x26d5
incl %eax
jmp 0x271c
movl $0x1, %ebp
xorl %eax, %eax
movslq %ebp, %rcx
movq 0x8(%rsp), %rdx
movl %eax, (%rdx,%rcx,4)
movl -0x4(%rdx,%rcx,4), %eax
movl %ebx, %edx
subl %eax, %edx
movq %r14, 0x10(%rsp)
movl %edx, -0x4(%r14,%rcx,4)
testq %rbx, %rbx
jle 0x27c5
xorl %r14d, %r14d
xorl %r13d, %r13d
movslq %r13d, %rax
movq 0x8(%rsp), %rcx
movl (%rcx,%rax,4), %esi
leaq 0x28(%r14), %r15
cmpq %rsi, %r14
jne 0x277a
cmpq %rbx, %r15
jbe 0x2777
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %edx
leaq 0x18d8(%rip), %rdi      # 0x4048
xorl %eax, %eax
callq 0x2040
incl %r13d
cmpq %rbx, %r15
jbe 0x27bd
movq 0x3852(%rip), %r15      # 0x5fd8
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movl (%r12,%r14,4), %esi
movq %r15, %rdi
callq 0x21c0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x1aae(%rip), %rsi      # 0x4266
callq 0x2120
incq %r14
cmpq %r14, %rbx
jne 0x2748
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: pnsort(unsigned int*, int*, int*, int*, int)
void pnsort(unsigned int *T,int *P,int *P_2, int *I,int pn){ //Sort all purses
    nextsort = (int(*)[3])malloc(sizeof(int) * 1000000 * 3);
    sortstack = 0; 
    csort(T,P,P_2,I,0,0,pn); //sort (one time)
    while(sortstack >= 0){
        if(nextsort[sortstack][2]<1000){
            bbsort(T,P,P_2,I,nextsort[sortstack][0],nextsort[sortstack][1],nextsort[sortstack][2]);
        }
        else{
            csort(T,P,P_2,I,nextsort[sortstack][0],nextsort[sortstack][1],nextsort[sortstack][2]);
        }
    }
    free(nextsort);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0xb71b00, %edi         # imm = 0xB71B00
callq 0x2160
movq %rax, 0x3966(%rip)      # 0x6168
movl $0x0, 0x3964(%rip)      # 0x6170
movl %ebp, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x246c
movl 0x3944(%rip), %eax      # 0x6170
testl %eax, %eax
js 0x2878
movq 0x3931(%rip), %rcx      # 0x6168
movl %eax, %eax
leaq (%rax,%rax,2), %rdx
movl 0x8(%rcx,%rdx,4), %eax
movl (%rcx,%rdx,4), %r8d
movl 0x4(%rcx,%rdx,4), %r9d
cmpl $0x3e7, %eax            # imm = 0x3E7
jg 0x2867
movl %eax, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x236c
jmp 0x2826
movl %eax, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
jmp 0x2821
movq 0x38e9(%rip), %rdi      # 0x6168
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: makedic(unsigned int*, int*, int*, int*, unsigned int*, unsigned int*, int*, int*, int)
void makedic(unsigned int *T,int *P,int *P_2,int *K,unsigned int *NS,unsigned int *D,int *D_2,int *D_3,int f){ 
    //make dictionary
    printf("\nf = %d / dcs[%d]=%d dc2s[%d] = %d\n",f,f+1,dcs[f+1],f+1,dc2s[f+1]);
    int t = 0; //the number of the kind of different purse
    int starti = dc2s[f];
    int starts = dcs[f]; 
    int s = starts;
    if(DEBUGFLAG==1){printf("\n%d,%d,%d",dc2s[f+1],dcs[f+1],starts);}
    for(int i = starti;i<=dc2s[f+1];i++){ //t = dc2s[f+1]
        int a = 0;
        D_3[i] = 0;
        D_2[i] = s;
        if(DEBUGFLAG==1){printf("\n[%d]",i);}
        while(a<P_2[K[t]]){
            D[s] = T[P[K[t]]+a];
            if(DEBUGFLAG==1){printf("%x ",D[s]);}
            if(f>0){D_3[i]+= D_3[dc2s[f-1]+T[P[K[t]]+a]];}
            if(f==0){D_3[i]++;}
            s++;
            a++;
        }
        if(DEBUGFLAG==1){printf(" / %d:%d:%d /",i,D_2[i],D_3[i]);}
        t++;
    }
    dc2s[f+1]++;
    D_2[dc2s[f+1]] = s;
    printf("\ns = %d, t = %d, dc2s[f+1] = %d\n",s,t,dc2s[f+1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movslq 0x70(%rsp), %rsi
movq 0x68(%rsp), %r14
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1(%rsi), %rax
movq %rax, 0x10(%rsp)
leal 0x1(%rsi), %edx
leaq 0x38aa(%rip), %rax      # 0x6180
movl 0x4(%rax,%rsi,4), %ecx
leaq 0x38ef(%rip), %rax      # 0x61d0
movl 0x4(%rax,%rsi,4), %r9d
movq %rsi, 0x18(%rsp)
leaq 0x175e(%rip), %rdi      # 0x4050
xorl %ebx, %ebx
movl %edx, %r8d
xorl %eax, %eax
callq 0x2040
movq 0x18(%rsp), %rcx
leaq 0x38c6(%rip), %r11      # 0x61d0
movslq (%r11,%rcx,4), %rax
leaq 0x386b(%rip), %rdx      # 0x6180
movl (%rdx,%rcx,4), %esi
movl 0x4(%r11,%rcx,4), %edx
cmpl %edx, %eax
jle 0x2930
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rdi
jmp 0x29d1
movq %rcx, %r10
decl %ecx
xorl %ebx, %ebx
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rdi
movl $0x0, (%r14,%rax,4)
movl %esi, (%rdi,%rax,4)
movslq (%r15,%rbx,4), %r8
cmpl $0x0, (%r12,%r8,4)
jle 0x29b5
movslq %esi, %rdx
movq 0x20(%rsp), %rdi
leaq (%rdi,%rdx,4), %rdi
xorl %edx, %edx
movslq (%r13,%r8,4), %r8
addq %rdx, %r8
movl (%rbp,%r8,4), %r8d
movl %r8d, (%rdi,%rdx,4)
testl %r10d, %r10d
jle 0x299a
movslq (%r15,%rbx,4), %r8
movslq (%r13,%r8,4), %r8
addq %rdx, %r8
movl (%rbp,%r8,4), %r8d
addl (%r11,%rcx,4), %r8d
movl (%r14,%r8,4), %r8d
addl %r8d, (%r14,%rax,4)
jmp 0x299c
je 0x29ab
movslq (%r15,%rbx,4), %r8
incq %rdx
cmpl (%r12,%r8,4), %edx
jl 0x2965
jmp 0x29b3
movl $0x1, %r8d
jmp 0x2994
addl %edx, %esi
incq %rbx
leaq 0x1(%rax), %rdi
movslq (%r11,%r9,4), %rdx
cmpq %rdx, %rax
movq %rdi, %rax
movq 0x8(%rsp), %rdi
jl 0x2941
leal 0x1(%rdx), %eax
movl %eax, (%r11,%r9,4)
movslq %edx, %rax
movl %esi, 0x4(%rdi,%rax,4)
movl (%r11,%r9,4), %ecx
leaq 0x168a(%rip), %rdi      # 0x4074
movl %ebx, %edx
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: grammarmake(unsigned int*, int*, int*, int*, unsigned int*, int*, int)
int grammarmake(unsigned int *T,int *P,int *P_2,int *I,unsigned int *NS,int *K,int pn){ //文法を表示し，文法の総数tを返す．
    int t = -1; 
    for(int i = 0; i < pn; i++){ //check all purse in lexiorder
        int k = purselcp(T,P,P_2,I,i);
        if(k != P_2[I[i]]){
            codeA += P_2[I[i]];
            codeB += P_2[I[i]] - k;
            t++;
            K[t] = I[i]; //K[t] = t-th smallest purse in current round
        }
        NS[I[i]] = t; //transform T and put it into NS
    }
    printf("\nthe kind of all purse = %d",t+1);
    printf("\nsum of length of rightside characters = %d",codeA);
    printf("\n(when Front Encoding = %d)\n",codeB);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x30(%rsp), %eax
testl %eax, %eax
jle 0x2aae
movl %eax, %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
movl $0x0, %r11d
testq %r10, %r10
je 0x2a6a
movslq -0x4(%rcx,%r10,4), %r15
movl (%rdx,%r15,4), %r14d
movl $0x0, %r11d
testl %r14d, %r14d
jle 0x2a6a
movslq (%rsi,%r15,4), %r11
movslq (%rcx,%r10,4), %r15
movslq (%rsi,%r15,4), %r12
leaq (%rdi,%r11,4), %r15
leaq (%rdi,%r12,4), %r12
xorl %r11d, %r11d
movl (%r15,%r11,4), %ebp
cmpl (%r12,%r11,4), %ebp
jne 0x2a6a
incq %r11
cmpq %r11, %r14
jne 0x2a55
movl %r14d, %r11d
movslq (%rcx,%r10,4), %r14
movl (%rdx,%r14,4), %ebp
cmpl %ebp, %r11d
je 0x2a9c
addl %ebp, 0x36f7(%rip)      # 0x6174
movslq (%rcx,%r10,4), %r14
movl (%rdx,%r14,4), %ebp
subl %r11d, %ebp
addl %ebp, 0x36ea(%rip)      # 0x6178
movslq (%rcx,%r10,4), %r14
movslq %ebx, %r11
incl %ebx
movl %r14d, 0x4(%r9,%r11,4)
movl %ebx, (%r8,%r14,4)
incq %r10
cmpq %rax, %r10
jne 0x2a1f
jmp 0x2ab3
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leal 0x1(%rbx), %esi
leaq 0x15d8(%rip), %rdi      # 0x4095
xorl %eax, %eax
callq 0x2040
movl 0x36aa(%rip), %esi      # 0x6174
leaq 0x15e0(%rip), %rdi      # 0x40b1
xorl %eax, %eax
callq 0x2040
movl 0x369a(%rip), %esi      # 0x6178
leaq 0x15f8(%rip), %rdi      # 0x40dd
xorl %eax, %eax
callq 0x2040
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: write6(unsigned int*, int*, int*, unsigned int*, int)
int write6(unsigned int *D,int *D_2,int *D_3,unsigned int *NS,int NSsize){
    FILE *fp;
    //unsigned char chr;
    //unsigned int a;
    fp = fopen(wname, "w"); // open file or return null
    fwrite(&loops, sizeof(int),1, fp); //0:loops
    fwrite(&dcs[1], sizeof(int), loops, fp); //1:dcs[1][2][3]...
    fwrite(&dc2s[1], sizeof(int), loops, fp); //2:dc2s
    fwrite(D, sizeof(unsigned int), dcs[loops], fp); //3:D
    fwrite(D_2, sizeof(unsigned int), dc2s[loops]+1, fp); //4:D_2
    fwrite(D_3, sizeof(unsigned int), dc2s[loops], fp); //5:D_3
    fwrite(&NSsize, sizeof(int),1, fp); //6:NSsize
    fwrite(NS, sizeof(unsigned int),NSsize, fp); //7:NS
    fclose(fp); // open file or return null
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0xc(%rsp), %rax
movl %r8d, (%rax)
movq 0x363e(%rip), %rdi      # 0x6160
leaq 0x15d1(%rip), %rsi      # 0x40fa
callq 0x2130
movq %rax, %r14
leaq 0x35f4(%rip), %rdi      # 0x612c
movl $0x4, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x21f0
movslq 0x35db(%rip), %rdx      # 0x612c
leaq 0x362c(%rip), %rdi      # 0x6184
movl $0x4, %esi
movq %r14, %rcx
callq 0x21f0
leaq 0x3614(%rip), %rbx      # 0x6180
movslq 0x35b9(%rip), %rdx      # 0x612c
leaq 0x365a(%rip), %rdi      # 0x61d4
movl $0x4, %esi
movq %r14, %rcx
callq 0x21f0
leaq 0x3642(%rip), %r15      # 0x61d0
movslq 0x3597(%rip), %rax      # 0x612c
movslq (%rbx,%rax,4), %rdx
movl $0x4, %esi
movq %rbp, %rdi
movq %r14, %rcx
callq 0x21f0
movslq 0x357c(%rip), %rax      # 0x612c
movslq (%r15,%rax,4), %rdx
incq %rdx
movl $0x4, %esi
movq %r13, %rdi
movq %r14, %rcx
callq 0x21f0
movslq 0x355e(%rip), %rax      # 0x612c
movslq (%r15,%rax,4), %rdx
movl $0x4, %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x21f0
movl $0x4, %esi
movl $0x1, %edx
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x21f0
movslq (%rbx), %rdx
movl $0x4, %esi
movq 0x10(%rsp), %rdi
movq %r14, %rcx
callq 0x21f0
movq %r14, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead <file> and make <indexfile>. \n");
    printf(": ./gcis_nep_build -i <file>\n");
    printf("\nYou can set the name of output by using option -o. \n");
    printf(": ./gcis_nep_build -i <file> -o <outputfile>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rax
leaq 0x15f1(%rip), %rdi      # 0x4223
callq 0x21a0
leaq 0x1606(%rip), %rdi      # 0x4244
callq 0x21a0
leaq 0x161e(%rip), %rdi      # 0x4268
callq 0x21a0
leaq 0x162f(%rip), %rdi      # 0x4285
callq 0x21a0
leaq 0x1658(%rip), %rdi      # 0x42ba
callq 0x21a0
movl $0xa, %edi
callq 0x2180
movl $0xa, %edi
callq 0x2180
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/rozpo[P]enemy/data/characters/enemies/goblin/Goblin.cpp
// Function: Goblin::Goblin()
Goblin::Goblin():Enemy(e_enemy_goblin, 20, "Goblin", 25, 10, 10, 10, 60, 0)
{
    skills[0] = e_move_attack;
    skills[1] = e_move_attack;
    skills[2] = e_move_attack;
    skills[3] = e_move_poison;
    uses = {10, 10, 10 ,10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x75f0(%rip), %rsi      # 0xb0b6
leaq 0x75ef(%rip), %rdx      # 0xb0bc
movq %rsp, %r14
movq %r14, %rdi
callq 0x3bdc
movl $0xa, %eax
movq %rbx, %rdi
movl $0x1, %esi
movl $0x14, %edx
movq %r14, %rcx
movl $0x19, %r8d
movl $0xa, %r9d
pushq $0x0
pushq $0x3c
pushq %rax
pushq %rax
callq 0x3854
addq $0x20, %rsp
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3b1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xcbab(%rip), %rax      # 0x106d0
movq %rax, (%rbx)
movaps 0x7531(%rip), %xmm0     # 0xb060
movups %xmm0, 0x1c(%rbx)
movaps 0x7536(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3b61
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rozpo[P]enemy/data/characters/enemies/orc/Orc.cpp
// Function: Orc::Orc()
Orc::Orc():Enemy(e_enemy_orc, 40, "Orc", 50, 15, 10, 5, 20, 0)
{
    skills[0] = e_move_attack;
    skills[1] = e_move_attack;
    skills[2] = e_move_throw;
    skills[3] = e_move_power_attack;
    uses = {10, 10, 10 ,10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x738c(%rip), %rsi      # 0xb0fe
leaq 0x7388(%rip), %rdx      # 0xb101
movq %rsp, %r14
movq %r14, %rdi
callq 0x3bdc
movq %rbx, %rdi
xorl %esi, %esi
movl $0x28, %edx
movq %r14, %rcx
movl $0x32, %r8d
movl $0xf, %r9d
pushq $0x0
pushq $0x14
pushq $0x5
pushq $0xa
callq 0x3854
addq $0x20, %rsp
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3dc4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xc945(%rip), %rax      # 0x10710
movq %rax, (%rbx)
movaps 0x72fb(%rip), %xmm0     # 0xb0d0
movups %xmm0, 0x1c(%rbx)
movaps 0x7290(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3e07
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
nop