LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/map.cpp
// Function: YAML::Map::Compare(YAML::Map*)
int Map::Compare(Map *pMap)
	{
		node_map::const_iterator it = m_data.begin(), jt = pMap->m_data.begin();
		while(1) {
			if(it == m_data.end()) {
				if(jt == pMap->m_data.end())
					return 0;
				else
					return -1;
			}
			if(jt == pMap->m_data.end())
				return 1;

			int cmp = it->first->Compare(*jt->first);
			if(cmp != 0)
				return cmp;

			cmp = it->second->Compare(*jt->second);
			if(cmp != 0)
				return cmp;
		}

		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %r14
movq 0x20(%rsi), %rbx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq %rdi, %r14
je 0x19793
cmpq %rsi, %rbx
je 0x1979f
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x1a93e
testl %eax, %eax
jne 0x197a2
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x1a93e
testl %eax, %eax
je 0x1976f
jmp 0x197a2
xorl %eax, %eax
cmpq %rsi, %rbx
setne %al
negl %eax
jmp 0x197a2
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::Parse(YAML::Scanner*, YAML::ParserState const&)
void Node::Parse(Scanner *pScanner, const ParserState& state)
	{
		Clear();

		// save location
		m_line = pScanner->peek().line;
		m_column = pScanner->peek().column;

		ParseHeader(pScanner, state);

		// is this an alias? if so, it can have no content
		if(m_alias)
			return;

		// now split based on what kind of node we should be
		switch(pScanner->peek().type) {
			case TT_SCALAR:
				m_pContent = new Scalar;
				m_pContent->Parse(pScanner, state);
				break;
			case TT_FLOW_SEQ_START:
			case TT_BLOCK_SEQ_START:
			case TT_BLOCK_ENTRY:
				m_pContent = new Sequence;
				m_pContent->Parse(pScanner, state);
				break;
			case TT_FLOW_MAP_START:
			case TT_BLOCK_MAP_START:
				m_pContent = new Map;
				m_pContent->Parse(pScanner, state);
				break;
			default:
				break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x19f1c
movq %r14, %rdi
callq 0x1d548
movl 0x8(%rax), %eax
movl %eax, (%r15)
movq %r14, %rdi
callq 0x1d548
movl 0xc(%rax), %eax
movl %eax, 0x4(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a042
cmpb $0x0, 0x50(%r15)
je 0x19f98
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x1d548
movl 0x4(%rax), %eax
cmpl $0x11, %eax
ja 0x19f8f
movl $0xc8, %ecx
btl %eax, %ecx
jb 0x19fd1
movl $0x110, %ecx            # imm = 0x110
btl %eax, %ecx
jae 0x19fe6
pushq $0x38
popq %rdi
callq 0x42a0
movq %rax, %r12
movq %rax, %rdi
callq 0x19000
jmp 0x19ffe
pushq $0x20
popq %rdi
callq 0x42a0
movq %rax, %r12
movq %rax, %rdi
callq 0x20938
jmp 0x19ffe
cmpl $0x11, %eax
jne 0x19f8f
pushq $0x28
popq %rdi
callq 0x42a0
movq %rax, %r12
movq %rax, %rdi
callq 0x1cc18
movq %r12, 0x48(%r15)
movq (%r12), %rax
movq 0x10(%rax), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rax, %rbx
pushq $0x28
jmp 0x1a030
movq %rax, %rbx
pushq $0x38
jmp 0x1a030
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseHeader(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseHeader(Scanner *pScanner, const ParserState& state)
	{
		while(1) {
			if(pScanner->empty())
				return;

			switch(pScanner->peek().type) {
				case TT_TAG: ParseTag(pScanner, state); break;
				case TT_ANCHOR: ParseAnchor(pScanner, state); break;
				case TT_ALIAS: ParseAlias(pScanner, state); break;
				default: return;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %r14, %rdi
callq 0x1d4b4
testb %al, %al
jne 0x1a0a5
movq %r14, %rdi
callq 0x1d548
movl 0x4(%rax), %eax
cmpl $0xe, %eax
je 0x1a098
cmpl $0xf, %eax
je 0x1a08b
cmpl $0x10, %eax
jne 0x1a0a5
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a0b0
jmp 0x1a055
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a248
jmp 0x1a055
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a1a8
jmp 0x1a055
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseTag(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseTag(Scanner *pScanner, const ParserState& state)
	{
		Token& token = pScanner->peek();
		if(m_tag != "")
			throw ParserException(token.line, token.column, ErrorMsg::MULTIPLE_TAGS);

		m_tag = state.TranslateTag(token.value);

		for(unsigned i=0;i<token.params.size();i++)
			m_tag += token.params[i];
		pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1d548
movq %rax, %rbx
addq $0x28, %r15
leaq 0x8c41(%rip), %rsi      # 0x22d21
movq %r15, %rdi
callq 0x1a971
testb %al, %al
jne 0x1a15e
movq %rbx, %rdx
addq $0x10, %rdx
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1b84a
movq %r15, %rdi
movq %r13, %rsi
callq 0x4380
movq %r13, %rdi
callq 0x45d8
xorl %eax, %eax
movl %eax, %r12d
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x1a147
movq %r12, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r15, %rdi
callq 0x45b0
leal 0x1(%r12), %eax
jmp 0x1a117
movq %r14, %rdi
callq 0x1d516
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x1669a(%rip), %rcx     # 0x30810
movq %rax, %rdi
callq 0x18be0
leaq 0x134bb(%rip), %rsi     # 0x2d640
leaq -0xa5ba(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseAnchor(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseAnchor(Scanner *pScanner, const ParserState& state)
	{
		Token& token = pScanner->peek();
		if(m_anchor != "")
			throw ParserException(token.line, token.column, ErrorMsg::MULTIPLE_ANCHORS);

		m_anchor = token.value;
		m_alias = false;
		pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1d548
movq %rax, %rbx
leaq 0x8(%r15), %r12
leaq 0x8b52(%rip), %rsi      # 0x22d21
movq %r12, %rdi
callq 0x1a971
testb %al, %al
jne 0x1a1ff
addq $0x10, %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4150
movb $0x0, 0x50(%r15)
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d516
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x16619(%rip), %rcx     # 0x30830
movq %rax, %rdi
callq 0x18be0
leaq 0x1341a(%rip), %rsi     # 0x2d640
leaq -0xa65b(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseAlias(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseAlias(Scanner *pScanner, const ParserState& state)
	{
		Token& token = pScanner->peek();
		if(m_anchor != "")
			throw ParserException(token.line, token.column, ErrorMsg::MULTIPLE_ALIASES);
		if(m_tag != "")
			throw ParserException(token.line, token.column, ErrorMsg::ALIAS_CONTENT);

		m_anchor = token.value;
		m_alias = true;
		pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1d548
movq %rax, %r14
leaq 0x8(%r15), %r12
leaq 0x8ab2(%rip), %rsi      # 0x22d21
movq %r12, %rdi
callq 0x1a971
testb %al, %al
jne 0x1a2b3
leaq 0x28(%r15), %rdi
leaq 0x8a9b(%rip), %rsi      # 0x22d21
callq 0x1a971
testb %al, %al
jne 0x1a2d7
addq $0x10, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x4150
movb $0x1, 0x50(%r15)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d516
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %rbx
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0x16583(%rip), %rcx     # 0x30850
movq %rax, %rdi
callq 0x18be0
jmp 0x1a2f9
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %rbx
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0x1657f(%rip), %rcx     # 0x30870
movq %rax, %rdi
callq 0x18be0
leaq 0x13340(%rip), %rsi     # 0x2d640
leaq -0xa735(%rip), %rdx     # 0xfbd2
movq %rbx, %rdi
callq 0x44f0
jmp 0x1a311
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::GetType() const
CONTENT_TYPE Node::GetType() const
	{
		if(!m_pContent)
			return CT_NONE;

		if(m_pContent->IsScalar())
			return CT_SCALAR;
		else if(m_pContent->IsSequence())
			return CT_SEQUENCE;
		else if(m_pContent->IsMap())
			return CT_MAP;
			
		return CT_NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x1a5a0
movq (%rdi), %rax
callq *0x50(%rax)
testb %al, %al
je 0x1a5a4
pushq $0x1
jmp 0x1a5b4
xorl %eax, %eax
jmp 0x1a5c7
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
testb %al, %al
je 0x1a5b7
pushq $0x2
popq %rax
jmp 0x1a5c7
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movzbl %al, %eax
leal (%rax,%rax,2), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::begin() const
Iterator Node::begin() const
	{
		if(!m_pContent)
			return Iterator();

		std::vector <Node *>::const_iterator seqIter;
		if(m_pContent->GetBegin(seqIter))
			return Iterator(new IterPriv(seqIter));

		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
		if(m_pContent->GetBegin(mapIter))
			return Iterator(new IterPriv(mapIter));

		return Iterator();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x1a655
movq %rsi, %r14
leaq -0x20(%rbp), %rsi
andq $0x0, (%rsi)
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x1a617
pushq $0x18
popq %rdi
callq 0x42a0
movq -0x20(%rbp), %rcx
movl $0x1, (%rax)
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
jmp 0x1a648
leaq -0x18(%rbp), %rsi
andq $0x0, (%rsi)
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x1a655
pushq $0x18
popq %rdi
callq 0x42a0
movq -0x18(%rbp), %rcx
movl $0x2, (%rax)
andq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18d22
jmp 0x1a65d
movq %rbx, %rdi
callq 0x18cf8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::end() const
Iterator Node::end() const
	{
		if(!m_pContent)
			return Iterator();

		std::vector <Node *>::const_iterator seqIter;
		if(m_pContent->GetEnd(seqIter))
			return Iterator(new IterPriv(seqIter));

		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
		if(m_pContent->GetEnd(mapIter))
			return Iterator(new IterPriv(mapIter));

		return Iterator();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x1a6f1
movq %rsi, %r14
leaq -0x20(%rbp), %rsi
andq $0x0, (%rsi)
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x1a6b3
pushq $0x18
popq %rdi
callq 0x42a0
movq -0x20(%rbp), %rcx
movl $0x1, (%rax)
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
jmp 0x1a6e4
leaq -0x18(%rbp), %rsi
andq $0x0, (%rsi)
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x1a6f1
pushq $0x18
popq %rdi
callq 0x42a0
movq -0x18(%rbp), %rcx
movl $0x2, (%rax)
andq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18d22
jmp 0x1a6f9
movq %rbx, %rdi
callq 0x18cf8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::operator[](unsigned int) const
const Node& Node::operator [] (unsigned u) const
	{
		if(!m_pContent)
			throw BadDereference();

		Node *pNode = m_pContent->GetNode(u);
		if(pNode)
			return *pNode;

		return GetValue(u);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x1a758
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
jne 0x1a74f
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0x1a98e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %rbx
movq %rax, %rdi
callq 0xfa3c
leaq 0x12efe(%rip), %rsi     # 0x2d670
leaq -0xaba7(%rip), %rdx     # 0xfbd2
movq %rbx, %rdi
callq 0x44f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::operator[](int) const
const Node& Node::operator [] (int i) const
	{
		if(!m_pContent)
			throw BadDereference();

		Node *pNode = m_pContent->GetNode(i);
		if(pNode)
			return *pNode;

		return GetValue(i);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x1a7ce
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
jne 0x1a7c5
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0x1aac8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %rbx
movq %rax, %rdi
callq 0xfa3c
leaq 0x12e88(%rip), %rsi     # 0x2d670
leaq -0xac1d(%rip), %rdx     # 0xfbd2
movq %rbx, %rdi
callq 0x44f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::Compare(YAML::Node const&) const
int Node::Compare(const Node& rhs) const
	{
		// Step 1: no content is the smallest
		if(!m_pContent) {
			if(rhs.m_pContent)
				return -1;
			else
				return 0;
		}
		if(!rhs.m_pContent)
			return 1;

		return m_pContent->Compare(rhs.m_pContent);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x48(%rdi), %rdi
movq 0x48(%rsi), %rsi
testq %rdi, %rdi
je 0x1a961
testq %rsi, %rsi
je 0x1a96a
movq (%rdi), %rax
movq 0xa8(%rax), %rax
popq %rbp
jmpq *%rax
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
jmp 0x1a96f
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::GetNextDocument(YAML::Node&)
void Parser::GetNextDocument(Node& document)
	{
		// clear node
		document.Clear();

		// first read directives
		ParseDirectives();

		// we better have some tokens in the queue
		if(m_pScanner->empty())
			return;

		// first eat doc start (optional)
		if(m_pScanner->peek().type == TT_DOC_START)
			m_pScanner->pop();

		// now parse our root node
		document.Parse(m_pScanner, m_state);

		// and finally eat any doc ends we see
		while(!m_pScanner->empty() && m_pScanner->peek().type == TT_DOC_END)
			m_pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x19f1c
movq %rbx, %rdi
callq 0x1ad84
movq (%rbx), %rdi
callq 0x1d4b4
testb %al, %al
je 0x1ad3a
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
callq 0x1d548
cmpl $0x1, 0x4(%rax)
jne 0x1ad50
movq (%rbx), %rdi
callq 0x1d516
movq (%rbx), %rsi
leaq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x19f44
movq (%rbx), %rdi
callq 0x1d4b4
testb %al, %al
jne 0x1ad35
movq (%rbx), %rdi
callq 0x1d548
cmpl $0x2, 0x4(%rax)
jne 0x1ad35
movq (%rbx), %rdi
callq 0x1d516
jmp 0x1ad5f
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rdi), %r14
xorl %r12d, %r12d
movq (%rbx), %rdi
callq 0x1d4b4
testb %al, %al
jne 0x1addc
movq (%rbx), %rdi
callq 0x1d548
cmpl $0x0, 0x4(%rax)
jne 0x1addc
movq %rax, %r15
testb $0x1, %r12b
jne 0x1adc4
movq %r14, %rdi
callq 0x1b790
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1ade6
movq (%rbx), %rdi
callq 0x1d516
movb $0x1, %r12b
jmp 0x1ad99
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x800f(%rip), %rsi      # 0x22e10
movq %r15, %rdi
callq 0x1a97e
testb %al, %al
je 0x1ae22
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ae56
leaq 0x7fc1(%rip), %rsi      # 0x22dea
movq %r15, %rdi
callq 0x1a97e
testb %al, %al
je 0x1ae4a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1b01c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1af6a
movq %rdi, %r15
leaq -0x1d0(%rbp), %r12
pushq $0x18
popq %rdx
movq %r12, %rdi
callq 0x4480
leaq 0x8(%r15), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x4170
leaq -0x1d0(%rbp), %rdi
callq 0x4360
addq $0xc, %r15
leaq -0x1d0(%rbp), %rdi
movq %r15, %rsi
callq 0x4170
movq -0x1d0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1b0(%rbp,%rax)
jne 0x1af13
leaq -0x1d0(%rbp), %rdi
callq 0x40e0
cmpl $-0x1, %eax
jne 0x1af13
cmpl $0x2, (%r14)
jge 0x1afa0
leaq -0x1d0(%rbp), %rdi
callq 0x4220
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %r15d
movl 0xc(%rbx), %r12d
movq 0x30(%rbx), %rdx
leaq 0x15e5f(%rip), %rsi     # 0x30d90
leaq -0x48(%rbp), %rdi
callq 0x1b150
movb $0x1, %r13b
leaq -0x48(%rbp), %rcx
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x18be0
xorl %r13d, %r13d
leaq 0x126e7(%rip), %rsi     # 0x2d640
leaq -0xb38e(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
jmp 0x1afd6
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x15dee(%rip), %rcx     # 0x30d70
movq %rax, %rdi
callq 0x18be0
leaq 0x126af(%rip), %rsi     # 0x2d640
leaq -0xb3c6(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x15df8(%rip), %rcx     # 0x30db0
movq %rax, %rdi
callq 0x18be0
leaq 0x12679(%rip), %rsi     # 0x2d640
leaq -0xb3fc(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
jmp 0x1aff8
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x1b014
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x45d8
testb %r13b, %r13b
jne 0x1affb
jmp 0x1b008
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x1b008
movq %rax, %rbx
leaq -0x1d0(%rbp), %rdi
callq 0x4220
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
movq 0x38(%r14), %rax
subq %rsi, %rax
cmpq $0x40, %rax
jne 0x1b093
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4410
movq 0x30(%r14), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
callq 0x4410
addq $0x10, %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b188
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x4150
leaq -0x38(%rbp), %rdi
callq 0x45d8
leaq -0x58(%rbp), %rdi
callq 0x45d8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r15
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0x15d23(%rip), %rcx     # 0x30dd0
movq %rax, %rdi
callq 0x18be0
leaq 0x12584(%rip), %rsi     # 0x2d640
leaq -0xb4f1(%rip), %rdx     # 0xfbd2
movq %r15, %rdi
callq 0x44f0
movq %rax, %rbx
movq %r15, %rdi
callq 0x4210
jmp 0x1b0f2
movq %rax, %rbx
jmp 0x1b0e9
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x45d8
leaq -0x58(%rbp), %rdi
callq 0x45d8
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x7bda(%rip), %r15      # 0x22ceb
movq (%r14), %rdi
callq 0x1d4b4
testb %al, %al
jne 0x1b145
movq (%r14), %rdi
callq 0x1d548
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b1f1
movq %rax, %rdi
movq %r15, %rsi
callq 0x4280
movq (%r14), %rdi
callq 0x1d516
jmp 0x1b111
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15f7a(%rip), %rsi     # 0x31190
addq %rax, %rsi
callq 0x4270
movq %rax, %r15
leaq 0x6fcd(%rip), %rsi      # 0x221f5
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0xee22
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
callq 0x4270
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4270
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x45d8
xorl %r12d, %r12d
leaq -0x29(%rbp), %r13
movl %r12d, %r12d
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x1b2b1
movq %r15, %rdi
leaq 0x7b78(%rip), %rsi      # 0x22df6
movq %r13, %rdx
callq 0xee22
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4270
movq %r12, %rsi
shlq $0x5, %rsi
addq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x4270
movq %r15, %rdi
callq 0x45d8
incl %r12d
jmp 0x1b260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b2c7
jmp 0x1b2cc
movq %rax, %rbx
jmp 0x1b2d8
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x45d8
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, (%rdi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x1b8f8
leaq 0x766d(%rip), %rsi      # 0x22e29
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xee22
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b88e
leaq 0x764d(%rip), %rsi      # 0x22e29
movq %rax, %rdi
callq 0x4590
leaq -0x30(%rbp), %rdi
callq 0x45d8
leaq 0x7634(%rip), %rsi      # 0x22e28
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xee22
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b88e
leaq 0x7601(%rip), %rsi      # 0x22e15
movq %rax, %rdi
callq 0x4590
leaq -0x30(%rbp), %rdi
callq 0x45d8
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1b82e
movq %rax, %rbx
jmp 0x1b841
jmp 0x1b835
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x45d8
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x1baa2
addq $0x10, %r14
leaq 0x40(%rax), %rsi
cmpq %r14, %rax
cmoveq %rbx, %rsi
movq %r15, %rdi
callq 0x4410
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x28(%rdi)
movups %xmm0, 0x18(%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 0x1c448
movq %r14, %rdi
callq 0x1bb68
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c41c
movq %r14, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bdb8
movq (%rdi), %rax
callq *0x8(%rax)
andq $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 0x1c448
movq %rbx, %rdi
callq 0x1bb68
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bee9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4510
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 0x44e0
movslq %r15d, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x43a0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r15
xorl %ecx, %ecx
pushq $0x30
popq %r12
pushq $-0x1
popq %rbx
movl %ecx, %r13d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x1c17e
imulq $0x30, %r13, %rax
addq %rax, %rdi
movq %r15, %rsi
callq 0x1be5a
leal 0x1(%r13), %ecx
testl %eax, %eax
js 0x1c14d
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_O2/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 %rdx, %r14
movq %rsi, %r15
xorl %ecx, %ecx
pushq $0x30
popq %r12
pushq $-0x1
popq %rbx
movl %ecx, %r13d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x1c1de
imulq $0x30, %r13, %rax
addq %rax, %rdi
movq %r15, %rsi
callq 0x1be88
leal 0x1(%r13), %ecx
testl %eax, %eax
js 0x1c1ad
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_O2/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 %rsi, %r15
xorl %eax, %eax
pushq $-0x1
popq %rbx
pushq $0x30
popq %r13
movl %eax, %r12d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x1c249
imulq $0x30, %r12, %rax
addq %rax, %rdi
movq %r15, %rsi
callq 0x1be5a
cmpl $-0x1, %eax
je 0x1c246
testq %r12, %r12
cmovel %eax, %ebx
leal 0x1(%r12), %eax
jmp 0x1c20d
pushq $-0x1
popq %rbx
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_O2/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 %rdx, %r14
movq %rsi, %r15
xorl %eax, %eax
pushq $-0x1
popq %rbx
pushq $0x30
popq %r13
movl %eax, %r12d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x1c2b3
imulq $0x30, %r12, %rax
addq %rax, %rdi
movq %r15, %rsi
callq 0x1be88
cmpl $-0x1, %eax
je 0x1c2b0
testq %r12, %r12
cmovel %eax, %ebx
leal 0x1(%r12), %eax
jmp 0x1c277
pushq $-0x1
popq %rbx
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_O2/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 $0x28, %rsp
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
xorl %r15d, %r15d
leaq -0x50(%rbp), %r12
xorl %r14d, %r14d
movl %r15d, %r15d
movq 0x18(%rbx), %r13
movq 0x20(%rbx), %rax
subq %r13, %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0x1c386
imulq $0x30, %r15, %rax
addq %rax, %r13
movslq %r14d, %rdx
movq %r12, %rdi
movq -0x30(%rbp), %rsi
pushq $-0x1
popq %rcx
callq 0x42d0
movq %r13, %rdi
movq %r12, %rsi
callq 0x1be5a
movl %eax, %r13d
movq %r12, %rdi
callq 0x45d8
cmpl $-0x1, %r13d
je 0x1c382
addl %r13d, %r14d
incl %r15d
jmp 0x1c32a
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x45d8
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %r15
xorl %ebx, %ebx
pushq $0x30
popq %r13
xorl %r12d, %r12d
movl %r12d, %r12d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x1c40a
imulq $0x30, %r12, %rax
addq %rax, %rdi
movq %r15, %rsi
callq 0x1be88
cmpl $-0x1, %eax
je 0x1c407
addl %eax, %ebx
movslq %eax, %rsi
movq %r15, %rdi
callq 0x4060
incl %r12d
jmp 0x1c3c9
pushq $-0x1
popq %rbx
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_O2/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 0x604f(%rip), %rsi      # 0x22d2e
movq %rbx, %rdi
callq 0x4280
xorl %r12d, %r12d
leaq 0x6219(%rip), %r13      # 0x22f0a
leaq 0x6209(%rip), %r15      # 0x22f01
movl %r12d, %r12d
cmpq %r12, 0x10(%r14)
jbe 0x1cd5b
movq 0x8(%r14), %rax
movzbl (%rax,%r12), %eax
cmpl $0x9, %eax
je 0x1cd3a
cmpl $0xa, %eax
je 0x1cd26
cmpl $0xd, %eax
je 0x1cd32
cmpl $0x5c, %eax
jne 0x1cd4e
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x1cd44
movq %rbx, %rdi
leaq 0x61d7(%rip), %rsi      # 0x22f07
jmp 0x1cd44
movq %rbx, %rdi
movq %r13, %rsi
jmp 0x1cd44
movq %rbx, %rdi
leaq 0x61c0(%rip), %rsi      # 0x22f04
callq 0x4280
incl %r12d
jmp 0x1ccf8
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4330
jmp 0x1cd49
leaq 0x61ab(%rip), %rsi      # 0x22f0d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d4f7
movl (%rax), %eax
cmpl $0x1, %eax
je 0x1d507
testl %eax, %eax
je 0x1d511
cmpb $0x0, 0x61(%rbx)
jne 0x1d511
movq %rbx, %rdi
callq 0x1d584
jmp 0x1d4e2
movq %r14, %rdi
callq 0x1e456
jmp 0x1d4e2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d4d4
movq 0x20(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x1d567
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x59c7(%rip), %rdi      # 0x22f35
leaq 0x59d2(%rip), %rsi      # 0x22f47
leaq 0x59dc(%rip), %rcx      # 0x22f58
pushq $0x29
popq %rdx
callq 0x41a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
leaq 0x14c11(%rip), %r15     # 0x32480
leaq 0x1496a(%rip), %r12     # 0x321e0
movq %rbx, %rdi
callq 0x21716
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1da26
testb %al, %al
je 0x1d89a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x217c8
jmp 0x1d876
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1beee
testb %al, %al
je 0x1d8d1
movq %rbx, %rdi
callq 0x21724
testb %al, %al
je 0x1d8d1
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1beee
testb %al, %al
jne 0x1d8d1
movq %rbx, %rdi
movl %r14d, %esi
callq 0x217c8
jmp 0x1d8a9
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1beee
testb %al, %al
je 0x1d912
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1befe
movq %rbx, %rdi
movl %eax, %esi
callq 0x217c8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x212dc
cmpl $0x0, 0x64(%rbx)
jne 0x1d876
movb $0x1, 0x62(%rbx)
jmp 0x1d876
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d942
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc0(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rdi), %r12
leaq -0x58(%rbp), %r15
leaq -0x78(%rbp), %r13
movq 0xf0(%r14), %rax
cmpq 0xd0(%r14), %rax
je 0x1d933
cmpq 0xf8(%r14), %rax
jne 0x1d98a
movq 0x108(%r14), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
cmpl %ebx, -0x4(%rax)
jle 0x1d933
movq -0x30(%rbp), %rdi
callq 0x1eae4
movq 0x8(%r14), %rax
movabsq $0x500000000, %rcx      # imm = 0x500000000
movq %rcx, -0x78(%rbp)
movq %rax, -0x70(%rbp)
movq %r15, -0x68(%rbp)
andq $0x0, -0x60(%rbp)
movb $0x0, -0x58(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
andq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r13, %rsi
callq 0x1e800
movq %r13, %rdi
callq 0x19892
jmp 0x1d95e
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1da05
andl $0x0, 0xc(%rbx)
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x1d91c
movq %rbx, %rdi
callq 0x21406
movw $0x1, 0x61(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, -0x14(%rbp)
cmpl $0x0, 0x64(%rdi)
jg 0x1dadf
movl %edx, %r14d
movq %rdi, %rbx
movq 0xf0(%rdi), %rax
cmpq 0xf8(%rdi), %rax
jne 0x1da84
movq 0x108(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
cmpl %esi, -0x4(%rax)
jge 0x1dadf
leaq 0xc0(%rbx), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1e75c
leaq 0x10(%rbx), %rdi
testb %r14b, %r14b
je 0x1daea
movq 0x8(%rbx), %rax
movabsq $0x300000000, %rcx      # imm = 0x300000000
leaq -0x40(%rbp), %rdx
movq %rcx, -0x20(%rdx)
movq %rax, -0x18(%rdx)
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb $0x0, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
andq $0x0, 0x20(%rdx)
leaq -0x60(%rbp), %rsi
callq 0x1e800
jmp 0x1db25
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rbx), %rax
movabsq $0x400000000, %rcx      # imm = 0x400000000
leaq -0x40(%rbp), %rdx
movq %rcx, -0x20(%rdx)
movq %rax, -0x18(%rdx)
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb $0x0, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
andq $0x0, 0x20(%rdx)
leaq -0x60(%rbp), %rsi
callq 0x1e800
leaq -0x60(%rbp), %rdi
callq 0x19892
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
jne 0x1db45
movq 0x58(%rbx), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
addq $-0x48, %rax
jmp 0x1dae1
jmp 0x1db4d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %esi
callq 0x1d91c
movq %rbx, %rdi
callq 0x21406
xorl %r14d, %r14d
movb %r14b, 0x62(%rbx)
movq 0x8(%rbx), %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x217c8
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq -0x40(%rbp), %rcx
movq %rax, -0x20(%rcx)
movq %r15, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
addq $0x10, %rbx
movb %r14b, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x60(%rbp), %rdi
callq 0x19892
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdi, %rbx
pushq $-0x1
popq %rsi
callq 0x1d91c
movq %rbx, %rdi
callq 0x21406
xorl %r14d, %r14d
movb %r14b, 0x62(%rbx)
movq 0x8(%rbx), %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x217c8
movabsq $0x200000000, %rax      # imm = 0x200000000
leaq -0x40(%rbp), %rcx
movq %rax, -0x20(%rcx)
movq %r15, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
addq $0x10, %rbx
movb %r14b, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x60(%rbp), %rdi
callq 0x19892
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x21204
incl 0x64(%rbx)
movb $0x1, 0x62(%rbx)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x2173c
xorl %ecx, %ecx
cmpb $0x5b, %al
setne %cl
leaq -0x38(%rbp), %rax
andl $0x0, -0x20(%rax)
addl $0x7, %ecx
movl %ecx, -0x1c(%rax)
movq %r14, -0x18(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
addq $0x10, %rbx
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x58(%rbp), %rdi
callq 0x19892
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
nop