LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::ParseDirectives()
void Parser::ParseDirectives()
	{
		bool readDirective = false;

		while(1) {
			if(m_pScanner->empty())
				break;

			Token& token = m_pScanner->peek();
			if(token.type != TT_DIRECTIVE)
				break;

			// we keep the directives from the last document if none are specified;
			// but if any directives are specific, then we reset them
			if(!readDirective)
				m_state.Reset();

			readDirective = true;
			HandleDirective(&token);
			m_pScanner->pop();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2aa98
testb %al, %al
jne 0x27be0
leaq 0x8(%rbx), %r14
xorl %r12d, %r12d
movq (%rbx), %rdi
callq 0x2ab2c
cmpl $0x0, 0x4(%rax)
jne 0x27be0
movq %rax, %r15
testb $0x1, %r12b
jne 0x27bbe
movq %r14, %rdi
callq 0x28684
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27bea
movq (%rbx), %rdi
callq 0x2aafa
movq (%rbx), %rdi
callq 0x2aa98
movb $0x1, %r12b
testb %al, %al
je 0x27b9f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::HandleDirective(YAML::Token*)
void Parser::HandleDirective(Token *pToken)
	{
		if(pToken->value == "YAML")
			HandleYamlDirective(pToken);
		else if(pToken->value == "TAG")
			HandleTagDirective(pToken);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r15
leaq 0x91ec(%rip), %rsi      # 0x30df1
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x27c2f
leaq 0x91b3(%rip), %rsi      # 0x30dcb
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x27c44
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x27c5a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x27e72
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::HandleYamlDirective(YAML::Token*)
void Parser::HandleYamlDirective(Token *pToken)
	{
		if(pToken->params.size() != 1)
			throw ParserException(pToken->line, pToken->column, ErrorMsg::YAML_DIRECTIVE_ARGS);

		std::stringstream str(pToken->params[0]);
		str >> m_state.version.major;
		str.get();
		str >> m_state.version.minor;
		if(!str || str.peek() != EOF)
			throw ParserException(pToken->line, pToken->column, ErrorMsg::YAML_VERSION + pToken->params[0]);

		if(m_state.version.major > 1)
			throw ParserException(pToken->line, pToken->column, ErrorMsg::YAML_MAJOR_VERSION);

		// TODO: warning on major == 1, minor > 2?
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rbx
movq 0x30(%rsi), %rsi
movq 0x38(%rbx), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x27d8f
movq %rdi, %r15
leaq -0x1d0(%rbp), %r12
movq %r12, %rdi
movl $0x18, %edx
callq 0x44b0
leaq 0x8(%r15), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x4180
leaq -0x1d0(%rbp), %rdi
callq 0x4390
addq $0xc, %r15
leaq -0x1d0(%rbp), %rdi
movq %r15, %rsi
callq 0x4180
movq -0x1d0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1b0(%rbp,%rax)
jne 0x27d2c
leaq -0x1d0(%rbp), %rdi
callq 0x4100
cmpl $-0x1, %eax
jne 0x27d2c
cmpl $0x2, (%r14)
jge 0x27dc7
movq 0x132a6(%rip), %rsi     # 0x3afa8
leaq -0x1d0(%rbp), %rdi
callq 0x4240
leaq -0x150(%rbp), %rdi
callq 0x40e0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %r15d
movl 0xc(%rbx), %r12d
movq 0x30(%rbx), %rdx
leaq 0x16044(%rip), %rsi     # 0x3dd90
leaq -0x48(%rbp), %rdi
callq 0x2800d
movb $0x1, %r13b
leaq -0x48(%rbp), %rcx
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x1960e
leaq 0x12b4f(%rip), %rax     # 0x3a8c0
movq %rax, (%r14)
xorl %r13d, %r13d
leaq 0x128da(%rip), %rsi     # 0x3a658
leaq -0xe583(%rip), %rdx     # 0x19802
movq %r14, %rdi
callq 0x4510
jmp 0x27e09
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x15fc7(%rip), %rcx     # 0x3dd70
movq %rax, %rdi
callq 0x257ee
leaq 0x128a0(%rip), %rsi     # 0x3a658
leaq -0xe5bd(%rip), %rdx     # 0x19802
movq %r14, %rdi
callq 0x4510
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x15fcf(%rip), %rcx     # 0x3ddb0
movq %rax, %rdi
callq 0x1960e
leaq 0x12ad0(%rip), %rax     # 0x3a8c0
movq %rax, (%r14)
leaq 0x1285e(%rip), %rsi     # 0x3a658
leaq -0xe5ff(%rip), %rdx     # 0x19802
movq %r14, %rdi
callq 0x4510
jmp 0x27e3b
movq %rax, %rbx
movq %r14, %rdi
callq 0x4230
jmp 0x27e6a
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27e34
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
testb %r13b, %r13b
jne 0x27e3e
jmp 0x27e4b
movq %rax, %rbx
movq %r14, %rdi
callq 0x4230
jmp 0x27e4b
movq %rax, %rbx
movq 0x13156(%rip), %rsi     # 0x3afa8
leaq -0x1d0(%rbp), %rdi
callq 0x4240
leaq -0x150(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::HandleTagDirective(YAML::Token*)
void Parser::HandleTagDirective(Token *pToken)
	{
		if(pToken->params.size() != 2)
			throw ParserException(pToken->line, pToken->column, ErrorMsg::TAG_DIRECTIVE_ARGS);

		std::string handle = pToken->params[0], prefix = pToken->params[1];
		m_state.tags[handle] = prefix;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
subq %rax, %rcx
cmpq $0x40, %rcx
jne 0x27f26
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x1967e
movq 0x30(%r14), %rax
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x1967e
addq $0x10, %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x28072
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x4160
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x27f06
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x27f1b
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %r15
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0x15e8e(%rip), %rcx     # 0x3ddd0
movq %rax, %rdi
callq 0x257ee
leaq 0x12707(%rip), %rsi     # 0x3a658
leaq -0xe756(%rip), %rdx     # 0x19802
movq %r15, %rdi
callq 0x4510
movq %rax, %rbx
movq %r15, %rdi
callq 0x4230
jmp 0x27f9f
movq %rax, %rbx
jmp 0x27f8a
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x27f8a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x27f9f
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::PrintTokens(std::ostream&)
void Parser::PrintTokens(std::ostream& out)
	{
		while(1) {
			if(m_pScanner->empty())
				break;

			out << m_pScanner->peek() << "\n";
			m_pScanner->pop();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x2aa98
testb %al, %al
jne 0x28002
leaq 0x8f24(%rip), %r15      # 0x30eef
movq (%r14), %rdi
callq 0x2ab2c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x280f1
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4350
movq (%r14), %rdi
callq 0x2aafa
movq (%r14), %rdi
callq 0x2aa98
testb %al, %al
je 0x27fcb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/token.h
// Function: YAML::operator<<(std::ostream&, YAML::Token const&)
std::ostream& operator << (std::ostream& out, const Token& token) {
			out << TokenNames[token.type] << std::string(": ") << token.value;
			for(unsigned i=0;i<token.params.size();i++)
				out << std::string(" ") << token.params[i];
			return out;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
shlq $0x5, %rax
leaq 0x1607a(%rip), %rcx     # 0x3e190
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
callq 0x4350
movq %rax, %r12
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x80bf(%rip), %rsi      # 0x301f5
leaq 0x80ba(%rip), %rdx      # 0x301f7
leaq -0x48(%rbp), %rdi
callq 0x1973e
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x4350
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rax, %rdi
callq 0x4350
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2817b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq 0x38(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x281fe
movl $0x1, %r12d
xorl %r13d, %r13d
movq %r15, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
leaq 0x8c3a(%rip), %rsi      # 0x30dd7
leaq 0x8c34(%rip), %rdx      # 0x30dd8
callq 0x1973e
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x4350
movq 0x30(%r14), %rcx
shlq $0x5, %r13
movq (%rcx,%r13), %rsi
movq 0x8(%rcx,%r13), %rdx
movq %rax, %rdi
callq 0x4350
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x281e7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
movl %r12d, %r13d
sarq $0x5, %rax
incl %r12d
cmpq %r13, %rax
ja 0x2818e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28214
jmp 0x28219
movq %rax, %rbx
jmp 0x28231
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x28231
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/parserstate.cpp
// Function: YAML::ParserState::Reset()
void ParserState::Reset()
	{
		// version
		version.major = 1;
		version.minor = 2;

		// and tags
		tags.clear();
		tags["!"] = "!";
		tags["!!"] = "tag:yaml.org,2002:";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, (%rdi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x28872
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x8750(%rip), %rsi      # 0x30e0a
leaq 0x874a(%rip), %rdx      # 0x30e0b
leaq -0x30(%rbp), %rdi
callq 0x1973e
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x287f2
movq 0x8(%rax), %rdx
leaq 0x8729(%rip), %rcx      # 0x30e0a
movl $0x1, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x28706
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x42d0
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x86f5(%rip), %rsi      # 0x30e09
leaq 0x86f0(%rip), %rdx      # 0x30e0b
callq 0x1973e
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x287f2
movq 0x8(%rax), %rdx
leaq 0x86bf(%rip), %rcx      # 0x30df6
movl $0x12, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2875c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x28767
movq %rax, %rbx
jmp 0x28786
jmp 0x2876e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x28786
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/parserstate.cpp
// Function: YAML::ParserState::TranslateTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string ParserState::TranslateTag(const std::string& handle) const
	{
		std::map <std::string, std::string>::const_iterator it = tags.find(handle);
		if(it == tags.end())
			return handle;

		return it->second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x289c8
addq $0x10, %r15
cmpq %r15, %rax
je 0x287c7
leaq 0x40(%rax), %r14
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
addq $0x48, %rax
jmp 0x287d2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8(%r14), %rax
movq (%r14), %rsi
movq (%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1967e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::RegEx(YAML::RegEx const&)
RegEx::RegEx(const RegEx& rhs): m_pOp(0)
	{
		m_op = rhs.m_op;
		m_a = rhs.m_a;
		m_z = rhs.m_z;
		m_params = rhs.m_params;

		SetOp();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x18(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq %rax, 0x28(%rdi)
movl (%rsi), %eax
movl %eax, (%rdi)
movb 0x10(%rsi), %al
movb %al, 0x10(%rdi)
movb 0x11(%rsi), %al
movb %al, 0x11(%rdi)
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x295ec
movq %r14, %rdi
callq 0x28aa4
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x29586
movq %r14, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::operator=(YAML::RegEx const&)
RegEx& RegEx::operator = (const RegEx& rhs)
	{
		delete m_pOp;
		m_pOp = 0;

		m_op = rhs.m_op;
		m_a = rhs.m_a;
		m_z = rhs.m_z;
		m_params = rhs.m_params;

		SetOp();

		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x28d2c
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
movb 0x10(%r14), %al
movb %al, 0x10(%rbx)
movb 0x11(%r14), %al
movb %al, 0x11(%rbx)
addq $0x18, %r14
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x295ec
movq %rbx, %rdi
callq 0x28aa4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::Match(std::istream&) const
int RegEx::Match(std::istream& in) const
	{
		if(!m_pOp)
			return -1;

		int pos = in.tellg();
		int ret = m_pOp->Match(in, *this);

		// reset input stream!
		in.clear();
		in.seekg(pos);

		return ret;
	}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x28ea1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4530
movq %rax, %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%rax)
movl %eax, %r14d
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x4500
movslq %r15d, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x43d0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::operator||(YAML::RegEx const&, YAML::RegEx const&)
RegEx operator || (const RegEx& ex1, const RegEx& ex2)
	{
		RegEx ret(REGEX_OR);
		ret.m_params.push_back(ex1);
		ret.m_params.push_back(ex2);
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x3, %esi
callq 0x28a68
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29762
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29762
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x28f78
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x29586
movq %r15, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::operator&&(YAML::RegEx const&, YAML::RegEx const&)
RegEx operator && (const RegEx& ex1, const RegEx& ex2)
	{
		RegEx ret(REGEX_AND);
		ret.m_params.push_back(ex1);
		ret.m_params.push_back(ex2);
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x4, %esi
callq 0x28a68
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29762
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29762
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x28fde
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x29586
movq %r15, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::OrOperator::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, YAML::RegEx const&) const
int RegEx::OrOperator::Match(const std::string& str, const RegEx& regex) const
	{
		for(unsigned i=0;i<regex.m_params.size();i++) {
			int n = regex.m_params[i].Match(str);
			if(n >= 0)
				return n;
		}
		return -1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq 0x18(%rdx), %rdx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq %rdx, 0x20(%r14)
je 0x291bf
movq %rsi, %r15
movl $0x1, %r12d
xorl %eax, %eax
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x8(%rdx,%rax), %rdi
testq %rdi, %rdi
je 0x291b9
addq %rax, %rdx
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
testl %eax, %eax
jns 0x291bd
movl %r12d, %eax
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
subq %rdx, %rcx
sarq $0x4, %rcx
imulq %r13, %rcx
incl %r12d
cmpq %rax, %rcx
ja 0x29177
jmp 0x291bf
xorl %ebx, %ebx
jmp 0x291bf
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::OrOperator::Match(std::istream&, YAML::RegEx const&) const
int RegEx::OrOperator::Match(std::istream& in, const RegEx& regex) const
	{
		for(unsigned i=0;i<regex.m_params.size();i++) {
			int n = regex.m_params[i].Match(in);
			if(n >= 0)
				return n;
		}
		return -1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdx), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq %rax, 0x20(%rdx)
je 0x2923e
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %r12d
xorl %ecx, %ecx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %r15, %rsi
callq 0x28e40
testl %eax, %eax
jns 0x2923c
movl %r12d, %ecx
movq 0x18(%r14), %rax
movq 0x20(%r14), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r13, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x29205
jmp 0x2923e
movl %eax, %ebx
movl %ebx, %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/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::AndOperator::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, YAML::RegEx const&) const
int RegEx::AndOperator::Match(const std::string& str, const RegEx& regex) const
	{
		int first = -1;
		for(unsigned i=0;i<regex.m_params.size();i++) {
			int n = regex.m_params[i].Match(str);
			if(n == -1)
				return -1;
			if(i == 0)
				first = n;
		}
		return first;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq 0x18(%rdx), %rdx
movq 0x20(%r14), %rax
cmpq %rdx, %rax
je 0x292e3
movq %rsi, %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0x1, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq 0x8(%rdx,%rcx), %rdi
testq %rdi, %rdi
je 0x292bc
addq %rcx, %rdx
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
cmpl $-0x1, %eax
je 0x292e3
cmpl $0x1, %r12d
cmovel %eax, %ebx
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rax
jmp 0x292c8
cmpl $0x1, %r12d
movl $0x0, %ecx
cmovel %ecx, %ebx
movl %r12d, %ecx
movq %rax, %rsi
subq %rdx, %rsi
sarq $0x4, %rsi
imulq %r13, %rsi
incl %r12d
cmpq %rcx, %rsi
ja 0x29288
jmp 0x292e8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %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/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::AndOperator::Match(std::istream&, YAML::RegEx const&) const
int RegEx::AndOperator::Match(std::istream& in, const RegEx& regex) const
	{
		int first = -1;
		for(unsigned i=0;i<regex.m_params.size();i++) {
			int n = regex.m_params[i].Match(in);
			if(n == -1)
				return -1;
			if(i == 0)
				first = n;
		}
		return first;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdx), %rax
cmpq %rax, 0x20(%rdx)
je 0x29370
movq %rdx, %rbx
movq %rsi, %r14
movl $0x1, %r12d
xorl %ecx, %ecx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %r14, %rsi
callq 0x28e40
cmpl $-0x1, %eax
je 0x29370
cmpl $0x1, %r12d
cmovel %eax, %r15d
movl %r12d, %ecx
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r13, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x29330
jmp 0x29376
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::NotOperator::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, YAML::RegEx const&) const
int RegEx::NotOperator::Match(const std::string& str, const RegEx& regex) const
	{
		if(regex.m_params.empty())
			return -1;
		if(regex.m_params[0].Match(str) >= 0)
			return -1;
		return 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rax
movq 0x18(%rdx), %rdx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq 0x20(%rax), %rdx
je 0x293b8
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0x293b8
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jns 0x293b8
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::SeqOperator::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, YAML::RegEx const&) const
int RegEx::SeqOperator::Match(const std::string& str, const RegEx& regex) const
	{
		int offset = 0;
		for(unsigned i=0;i<regex.m_params.size();i++) {
			int n = regex.m_params[i].Match(str.substr(offset));
			if(n == -1)
				return -1;
			offset += n;
		}
		return offset;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq 0x18(%rdx), %r13
movq %rdx, -0x30(%rbp)
cmpq %r13, 0x20(%rdx)
je 0x294ae
xorl %eax, %eax
movl $0x1, %r14d
xorl %r15d, %r15d
leaq (%rax,%rax,2), %rbx
shlq $0x4, %rbx
movslq %r15d, %rdx
leaq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq $-0x1, %rcx
callq 0x4300
movq 0x8(%r13,%rbx), %rdi
movl $0x0, %r12d
testq %rdi, %rdi
je 0x2945a
addq %rbx, %r13
movq (%rdi), %rax
leaq -0x58(%rbp), %rsi
movq %r13, %rdx
callq *0x10(%rax)
movl %eax, %r12d
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x29473
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
cmpl $-0x1, %r12d
je 0x294b3
addl %r12d, %r15d
movl %r14d, %eax
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %r13
movq 0x20(%rcx), %rcx
subq %r13, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
incl %r14d
cmpq %rax, %rcx
ja 0x29418
jmp 0x294b9
xorl %r15d, %r15d
jmp 0x294b9
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x294e7
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::SeqOperator::Match(std::istream&, YAML::RegEx const&) const
int RegEx::SeqOperator::Match(std::istream& in, const RegEx& regex) const
	{
		int offset = 0;
		for(unsigned i=0;i<regex.m_params.size();i++) {
			int n = regex.m_params[i].Match(in);
			if(n == -1)
				return -1;

			offset += n;
			in.ignore(n);
		}

		return offset;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdx), %rax
cmpq %rax, 0x20(%rdx)
je 0x29569
movq %rdx, %rbx
movq %rsi, %r14
xorl %ecx, %ecx
movl $0x1, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r15d, %r15d
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %r14, %rsi
callq 0x28e40
cmpl $-0x1, %eax
je 0x2956e
addl %eax, %r15d
movslq %eax, %rsi
movq %r14, %rdi
callq 0x4070
movl %r12d, %ecx
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r13, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x29523
jmp 0x29574
xorl %r15d, %r15d
jmp 0x29574
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scalar.cpp
// Function: YAML::Scalar::Write(std::ostream&, int, bool, bool)
void Scalar::Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine)
	{
		out << "\"";
		for(unsigned i=0;i<m_data.size();i++) {
			switch(m_data[i]) {
				case '\\': out << "\\\\"; break;
				case '\t': out << "\\t"; break;
				case '\n': out << "\\n"; break;
				case '\r': out << "\\r"; break;
				default: out << m_data[i]; break;
			}
		}
		out << "\"\n";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6d7e(%rip), %rsi      # 0x30d0f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4350
cmpq $0x0, 0x10(%r14)
je 0x2a03e
movl $0x1, %r13d
xorl %eax, %eax
leaq 0x6f33(%rip), %r15      # 0x30eeb
leaq 0x6f23(%rip), %r12      # 0x30ee2
movq 0x8(%r14), %rcx
movb (%rcx,%rax), %al
movzbl %al, %ecx
cmpl $0xc, %ecx
jg 0x29fe9
cmpl $0x9, %ecx
je 0x2a011
cmpl $0xa, %ecx
jne 0x2a000
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x6f01(%rip), %rsi      # 0x30ee8
jmp 0x2a02d
cmpl $0xd, %ecx
je 0x2a022
cmpl $0x5c, %ecx
jne 0x2a000
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x2a02d
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
jmp 0x2a02d
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x6ec5(%rip), %rsi      # 0x30ee5
jmp 0x2a02d
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4350
movl %r13d, %eax
incl %r13d
cmpq %rax, 0x10(%r14)
ja 0x29fbf
leaq 0x6ea9(%rip), %rsi      # 0x30eee
movl $0x2, %edx
movq %rbx, %rdi
callq 0x4350
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scalar.cpp
// Function: YAML::Scalar::Compare(YAML::Scalar*)
int Scalar::Compare(Scalar *pScalar)
	{
		if(m_data < pScalar->m_data)
			return -1;
		else if(m_data > pScalar->m_data)
			return 1;
		else
			return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4060
testl %eax, %eax
js 0x2a946
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4060
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x2a94b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2a952
movq %rax, %rdi
callq 0x193dc
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::EnsureTokensInQueue()
void Scanner::EnsureTokensInQueue()
	{
		while(1) {
			if(!m_tokens.empty()) {
				Token& token = m_tokens.front();

				// if this guy's valid, then we're done
				if(token.status == TS_VALID)
					return;

				// here's where we clean up the impossible tokens
				if(token.status == TS_INVALID) {
					m_tokens.pop();
					continue;
				}

				// note: what's left are the unverified tokens
			}

			// no token? maybe we've actually finished
			if(m_endedStream)
				return;

			// no? then scan...
			ScanNextToken();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x20(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x2aadb
movl (%rax), %eax
cmpl $0x1, %eax
je 0x2aaeb
testl %eax, %eax
je 0x2aaf5
cmpb $0x0, 0x61(%rbx)
jne 0x2aaf5
movq %rbx, %rdi
callq 0x2ab6a
jmp 0x2aac6
movq %r14, %rdi
callq 0x2b922
jmp 0x2aac6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::peek()
Token& Scanner::peek()
	{
		EnsureTokensInQueue();
		assert(!m_tokens.empty());  // should we be asserting here? I mean, we really just be checking
		                            // if it's empty before peeking.

		return m_tokens.front();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2aab8
movq 0x20(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x2ab4b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x63c4(%rip), %rdi      # 0x30f16
leaq 0x63cf(%rip), %rsi      # 0x30f28
leaq 0x63d9(%rip), %rcx      # 0x30f39
movl $0x29, %edx
callq 0x41b0
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::ScanToNextToken()
void Scanner::ScanToNextToken()
	{
		while(1) {
			// first eat whitespace
			while(IsWhitespaceToBeEaten(INPUT.peek()))
				INPUT.eat(1);

			// then eat a comment
			if(Exp::Comment.Matches(INPUT)) {
				// eat until line break
				while(INPUT && !Exp::Break.Matches(INPUT))
					INPUT.eat(1);
			}

			// if it's NOT a line break, then we're done!
			if(!Exp::Break.Matches(INPUT))
				break;

			// otherwise, let's eat the line break and keep going
			int n = Exp::Break.Match(INPUT);
			INPUT.eat(n);

			// oh yeah, and let's get rid of that simple key
			VerifySimpleKey();

			// new line - we may be able to accept a simple key now
			if(m_flowLevel == 0)
				m_simpleKeyAllowed = true;
        }
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x145ca(%rip), %r14     # 0x3f480
leaq 0x14323(%rip), %r15     # 0x3f1e0
movq %rbx, %rdi
callq 0x2f2b6
cmpb $0x20, %al
je 0x2af16
movzbl %al, %eax
cmpl $0x9, %eax
jne 0x2aedd
cmpl $0x0, 0x64(%rbx)
jns 0x2af16
cmpb $0x0, 0x62(%rbx)
je 0x2af16
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28ea8
testb %al, %al
je 0x2af25
movq %rbx, %rdi
callq 0x2f2c4
testb %al, %al
je 0x2af25
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28ea8
testb %al, %al
jne 0x2af25
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2f374
jmp 0x2aeec
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2f374
jmp 0x2aebd
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28ea8
testb %al, %al
je 0x2af66
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28ebc
movq %rbx, %rdi
movl %eax, %esi
callq 0x2f374
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2eec8
cmpl $0x0, 0x64(%rbx)
jne 0x2aebd
movb $0x1, 0x62(%rbx)
jmp 0x2aebd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::PopIndentTo(int)
void Scanner::PopIndentTo(int column)
	{
		// are we in flow?
		if(m_flowLevel > 0)
			return;

		// now pop away
		while(!m_indents.empty() && m_indents.top() > column) {
			m_indents.pop();
			m_tokens.push(Token(TT_BLOCK_END, INPUT.line, INPUT.column));
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x0, 0x64(%rdi)
jle 0x2af98
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq 0xf0(%rdi), %rax
cmpq 0xd0(%rdi), %rax
je 0x2af89
movl %esi, %ebx
leaq 0xc0(%r14), %rcx
movq %rcx, -0x38(%rbp)
leaq 0x10(%r14), %rcx
movq %rcx, -0x30(%rbp)
leaq -0x50(%rbp), %r13
xorl %r15d, %r15d
cmpq 0xf8(%r14), %rax
jne 0x2afe3
movq 0x108(%r14), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
cmpl %ebx, -0x4(%rax)
jle 0x2af89
movq -0x38(%rbp), %rdi
callq 0x2c004
movq 0x8(%r14), %rax
movabsq $0x500000000, %rcx      # imm = 0x500000000
movq %rcx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x70(%rbp)
movq %r15, -0x68(%rbp)
movb $0x0, -0x60(%rbp)
movq %r15, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2bd0c
movq %r13, %rdi
callq 0x2670a
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x2b04d
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x42d0
movq 0xf0(%r14), %rax
cmpq 0xd0(%r14), %rax
jne 0x2afc7
jmp 0x2af89
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::EndStream()
void Scanner::EndStream()
	{
		// force newline
		if(INPUT.column > 0)
			INPUT.column = 0;

		PopIndentTo(-1);
		VerifyAllSimpleKeys();

		m_simpleKeyAllowed = false;
		m_endedStream = true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
jle 0x2b090
movl $0x0, 0xc(%rbx)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2af72
movq %rbx, %rdi
callq 0x2eff8
movw $0x1, 0x61(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::PushIndentTo(int, bool)
Token *Scanner::PushIndentTo(int column, bool sequence)
	{
		// are we in flow?
		if(m_flowLevel > 0)
			return 0;

		// is this actually an indentation?
		if(column <= m_indents.top())
			return 0;

		// now push
		m_indents.push(column);
		if(sequence)
			m_tokens.push(Token(TT_BLOCK_SEQ_START, INPUT.line, INPUT.column));
		else
			m_tokens.push(Token(TT_BLOCK_MAP_START, INPUT.line, INPUT.column));

		return &m_tokens.back();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, -0x1c(%rbp)
cmpl $0x0, 0x64(%rdi)
jg 0x2b135
movl %edx, %r14d
movq %rdi, %rbx
movq 0xf0(%rdi), %rax
movq %rax, %rcx
cmpq 0xf8(%rdi), %rax
jne 0x2b111
movq 0x108(%rbx), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
cmpl %esi, -0x4(%rcx)
jge 0x2b135
movq 0x100(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x2b142
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0xf0(%rbx)
jmp 0x2b152
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc0(%rbx), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x2bc44
leaq 0x10(%rbx), %rdi
testb %r14b, %r14b
je 0x2b19a
movq 0x8(%rbx), %rax
movabsq $0x300000000, %rcx      # imm = 0x300000000
leaq -0x48(%rbp), %r15
movq %rcx, -0x20(%r15)
movq %rax, -0x18(%r15)
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq -0x68(%rbp), %rsi
callq 0x2bd0c
jmp 0x2b1d7
movq 0x8(%rbx), %rax
movabsq $0x400000000, %rcx      # imm = 0x400000000
leaq -0x48(%rbp), %r15
movq %rcx, -0x20(%r15)
movq %rax, -0x18(%r15)
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq -0x68(%rbp), %rsi
callq 0x2bd0c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x2670a
movq -0x20(%r14), %rdi
cmpq %r15, %rdi
je 0x2b1f8
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
jne 0x2b20f
movq 0x58(%rbx), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
addq $-0x48, %rax
jmp 0x2b137
jmp 0x2b21a
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanDocStart()
void Scanner::ScanDocStart()
	{
		PopIndentTo(INPUT.column);
		VerifyAllSimpleKeys();
		m_simpleKeyAllowed = false;

		// eat
		int line = INPUT.line, column = INPUT.column;
		INPUT.eat(3);
		m_tokens.push(Token(TT_DOC_START, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %esi
callq 0x2af72
movq %rbx, %rdi
callq 0x2eff8
xorl %r15d, %r15d
movb %r15b, 0x62(%rbx)
movq 0x8(%rbx), %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x2f374
addq $0x10, %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq -0x48(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r12, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %r15, -0x8(%r14)
movb %r15b, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r15, 0x20(%r14)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x2bd0c
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2670a
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2c8f4
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanDocEnd()
void Scanner::ScanDocEnd()
	{
		PopIndentTo(-1);
		VerifyAllSimpleKeys();
		m_simpleKeyAllowed = false;

		// eat
		int line = INPUT.line, column = INPUT.column;
		INPUT.eat(3);
		m_tokens.push(Token(TT_DOC_END, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2af72
movq %rbx, %rdi
callq 0x2eff8
xorl %r15d, %r15d
movb %r15b, 0x62(%rbx)
movq 0x8(%rbx), %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x2f374
addq $0x10, %rbx
movabsq $0x200000000, %rax      # imm = 0x200000000
leaq -0x48(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r12, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %r15, -0x8(%r14)
movb %r15b, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r15, 0x20(%r14)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x2bd0c
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2670a
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2c9b0
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanFlowStart()
void Scanner::ScanFlowStart()
	{
		// flows can be simple keys
		InsertSimpleKey();
		m_flowLevel++;
		m_simpleKeyAllowed = true;

		// eat
		int line = INPUT.line, column = INPUT.column;
		char ch = INPUT.get();
		TOKEN_TYPE type = (ch == Keys::FlowSeqStart ? TT_FLOW_SEQ_START : TT_FLOW_MAP_START);
		m_tokens.push(Token(type, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x2ed96
incl 0x64(%rbx)
movb $0x1, 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
callq 0x2f2dc
xorl %ecx, %ecx
cmpb $0x5b, %al
setne %cl
addl $0x7, %ecx
addq $0x10, %rbx
leaq -0x40(%rbp), %r14
movl $0x0, -0x20(%r14)
movl %ecx, -0x1c(%r14)
movq %r15, -0x18(%r14)
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2bd0c
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2670a
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2ca63
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanFlowEnd()
void Scanner::ScanFlowEnd()
	{
		if(m_flowLevel == 0)
			throw ParserException(INPUT.line, INPUT.column, ErrorMsg::FLOW_END);

		m_flowLevel--;
		m_simpleKeyAllowed = false;

		// eat
		int line = INPUT.line, column = INPUT.column;
		char ch = INPUT.get();
		TOKEN_TYPE type = (ch == Keys::FlowSeqEnd ? TT_FLOW_SEQ_END : TT_FLOW_MAP_END);
		m_tokens.push(Token(type, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x2cb2a
decl %eax
movl %eax, 0x64(%rbx)
xorl %r15d, %r15d
movb %r15b, 0x62(%rbx)
movq 0x8(%rbx), %r12
movq %rbx, %rdi
callq 0x2f2dc
xorl %ecx, %ecx
cmpb $0x5d, %al
setne %cl
addl $0x9, %ecx
addq $0x10, %rbx
leaq -0x48(%rbp), %r14
movl $0x0, -0x20(%r14)
movl %ecx, -0x1c(%r14)
movq %r12, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %r15, -0x8(%r14)
movb %r15b, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r15, 0x20(%r14)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x2bd0c
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2670a
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2cb1d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13aec(%rip), %rcx     # 0x40630
movq %rax, %rdi
callq 0x257ee
leaq 0xdb05(%rip), %rsi      # 0x3a658
leaq -0x13358(%rip), %rdx    # 0x19802
movq %r14, %rdi
callq 0x4510
movq %rax, %rbx
movq %r14, %rdi
callq 0x4230
jmp 0x2cb7b
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanFlowEntry()
void Scanner::ScanFlowEntry()
	{
		m_simpleKeyAllowed = true;

		// eat
		int line = INPUT.line, column = INPUT.column;
		INPUT.eat(1);
		m_tokens.push(Token(TT_FLOW_ENTRY, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movb $0x1, 0x62(%rdi)
movq 0x8(%rdi), %r15
movl $0x1, %esi
callq 0x2f374
addq $0x10, %rbx
movabsq $0xb00000000, %rax      # imm = 0xB00000000
leaq -0x40(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r15, -0x18(%r14)
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2bd0c
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2670a
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2cc07
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanBlockEntry()
void Scanner::ScanBlockEntry()
	{
		// we better be in the block context!
		if(m_flowLevel > 0)
			throw ParserException(INPUT.line, INPUT.column, ErrorMsg::BLOCK_ENTRY);

		// can we put it here?
		if(!m_simpleKeyAllowed)
			throw ParserException(INPUT.line, INPUT.column, ErrorMsg::BLOCK_ENTRY);

		PushIndentTo(INPUT.column, true);
		m_simpleKeyAllowed = true;

		// eat
		int line = INPUT.line, column = INPUT.column;
		INPUT.eat(1);
		m_tokens.push(Token(TT_BLOCK_ENTRY, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x64(%rdi)
jg 0x2ccdb
cmpb $0x0, 0x62(%rbx)
je 0x2ccff
movl 0xc(%rbx), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2b0d2
movb $0x1, 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2f374
addq $0x10, %rbx
movabsq $0x600000000, %rax      # imm = 0x600000000
leaq -0x40(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r15, -0x18(%r14)
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2bd0c
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2670a
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2ccd0
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x1395b(%rip), %rcx     # 0x40650
movq %rax, %rdi
callq 0x257ee
jmp 0x2cd21
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13937(%rip), %rcx     # 0x40650
movq %rax, %rdi
callq 0x257ee
leaq 0xd930(%rip), %rsi      # 0x3a658
leaq -0x1352d(%rip), %rdx    # 0x19802
movq %r14, %rdi
callq 0x4510
jmp 0x2cd39
movq %rax, %rbx
movq %r14, %rdi
callq 0x4230
jmp 0x2cd52
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanKey()
void Scanner::ScanKey()
	{
		// handle keys diffently in the block context (and manage indents)
		if(m_flowLevel == 0) {
			if(!m_simpleKeyAllowed)
				throw ParserException(INPUT.line, INPUT.column, ErrorMsg::MAP_KEY);

			PushIndentTo(INPUT.column, false);
		}

		// can only put a simple key here if we're in block context
		if(m_flowLevel == 0)
			m_simpleKeyAllowed = true;
		else
			m_simpleKeyAllowed = false;

		// eat
		int line = INPUT.line, column = INPUT.column;
		INPUT.eat(1);
		m_tokens.push(Token(TT_KEY, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x64(%rdi)
jne 0x2cd91
cmpb $0x0, 0x62(%rbx)
je 0x2ce1b
movl 0xc(%rbx), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2b0d2
cmpl $0x0, 0x64(%rbx)
je 0x2ce12
movb $0x0, 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2f374
addq $0x10, %rbx
movabsq $0xc00000000, %rax      # imm = 0xC00000000
leaq -0x40(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r15, -0x18(%r14)
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2bd0c
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2670a
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2ce07
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x62(%rbx)
jmp 0x2cd95
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x1383b(%rip), %rcx     # 0x40670
movq %rax, %rdi
callq 0x257ee
leaq 0xd814(%rip), %rsi      # 0x3a658
leaq -0x13649(%rip), %rdx    # 0x19802
movq %r14, %rdi
callq 0x4510
movq %rax, %rbx
movq %r14, %rdi
callq 0x4230
jmp 0x2ce6c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x264de
movq %rbx, %rdi
callq 0x4550