LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::SetOp()
void RegEx::SetOp()
	{
		delete m_pOp;
		m_pOp = 0;
		switch(m_op) {
			case REGEX_MATCH: m_pOp = new MatchOperator; break;
			case REGEX_RANGE: m_pOp = new RangeOperator; break;
			case REGEX_OR: m_pOp = new OrOperator; break;
			case REGEX_AND: m_pOp = new AndOperator; break;
			case REGEX_NOT: m_pOp = new NotOperator; break;
			case REGEX_SEQ: m_pOp = new SeqOperator; break;
			default: break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3beac
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x3bfbd
movq -0x20(%rbp), %rax
leaq 0xffe2(%rip), %rcx      # 0x4beb8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3d1e0
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bfbf
movl $0x8, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3d220
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bfbf
movl $0x8, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3d260
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bfbf
movl $0x8, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3d2a0
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bfbf
movl $0x8, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3d2e0
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bfbf
movl $0x8, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3d320
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bfbf
jmp 0x3bfbf
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3cee0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movb 0x10(%rcx), %cl
movb %cl, 0x10(%rax)
movq -0x10(%rbp), %rcx
movb 0x11(%rcx), %cl
movb %cl, 0x11(%rax)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x3cf60
jmp 0x3c030
movq -0x30(%rbp), %rdi
callq 0x3be80
jmp 0x3c03b
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3cf00
movq -0x18(%rbp), %rdi
callq 0x56c0
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3c320
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rdi
movq $0x0, 0x8(%rdi)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
movb %al, 0x10(%rdi)
movq -0x10(%rbp), %rax
movb 0x11(%rax), %al
movb %al, 0x11(%rdi)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x3cf60
movq -0x20(%rbp), %rdi
callq 0x3be80
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x3c4c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3c538
movq -0x18(%rbp), %rdi
callq 0x56b0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31930
movq -0x50(%rbp), %rdx
movl %eax, -0x1c(%rbp)
movq 0x8(%rdx), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x5670
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3d380
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x5510
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x3, %esi
callq 0x3be20
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x3d3c0
jmp 0x3c680
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x3d3c0
jmp 0x3c693
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3c6bf
jmp 0x3c6b6
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3c2b0
jmp 0x3c6c9
movq -0x38(%rbp), %rdi
callq 0x3c2b0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x4, %esi
callq 0x3be20
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x3d3c0
jmp 0x3c720
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x3d3c0
jmp 0x3c733
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3c75f
jmp 0x3c756
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3c2b0
jmp 0x3c769
movq -0x38(%rbp), %rdi
callq 0x3c2b0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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_SEQ);
		ret.m_params.push_back(ex1);
		ret.m_params.push_back(ex2);
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x6, %esi
callq 0x3be20
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x3d3c0
jmp 0x3c7c0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x3d3c0
jmp 0x3c7d3
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3c7ff
jmp 0x3c7f6
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3c2b0
jmp 0x3c809
movq -0x38(%rbp), %rdi
callq 0x3c2b0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d430
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ca67
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3d460
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c420
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x3ca5a
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ca6e
jmp 0x3ca5c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3ca0b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d430
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3caf7
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3d460
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c4a0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x3caea
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3cafe
jmp 0x3caec
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3ca9b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d430
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3cb9b
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x3d460
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c420
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x3cb82
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cba1
cmpl $0x0, -0x28(%rbp)
jne 0x3cb8e
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3cb90
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3cb32
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d430
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3cc3b
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x3d460
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c4a0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x3cc22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cc41
cmpl $0x0, -0x28(%rbp)
jne 0x3cc2e
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3cc30
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3cbd2
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d480
testb $0x1, %al
jne 0x3cc77
jmp 0x3cc80
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ccb2
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d460
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c420
cmpl $0x0, %eax
jl 0x3ccab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ccb2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::NotOperator::Match(std::istream&, YAML::RegEx const&) const
int RegEx::NotOperator::Match(std::istream& in, const RegEx& regex) const
	{
		if(regex.m_params.empty())
			return -1;
		if(regex.m_params[0].Match(in) >= 0)
			return -1;
		return 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d480
testb $0x1, %al
jne 0x3cce7
jmp 0x3ccf0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cd22
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d460
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c4a0
cmpl $0x0, %eax
jl 0x3cd1b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cd22
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d430
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ce09
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x3d460
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rsi
movslq -0x24(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq $-0x1, %rcx
callq 0x53d0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3c420
movl %eax, -0x6c(%rbp)
jmp 0x3cdbd
leaq -0x50(%rbp), %rdi
callq 0x5788
movl -0x6c(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x3cdf2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ce0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5788
jmp 0x3ce1b
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3cd55
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3d430
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3cec3
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x3d460
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c4a0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x3cea2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cec9
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x5090
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3ce52
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %cl
movb %cl, -0x15(%rbp)
andb $0x1, %al
movb %al, -0x16(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcb76(%rip), %rsi      # 0x4bdba
callq 0x5390
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x5290
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3f32f
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x5770
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x9, %eax
je 0x3f2c3
jmp 0x3f293
movl -0x34(%rbp), %eax
subl $0xa, %eax
je 0x3f2d5
jmp 0x3f29d
movl -0x34(%rbp), %eax
subl $0xd, %eax
je 0x3f2e7
jmp 0x3f2a7
movl -0x34(%rbp), %eax
subl $0x5c, %eax
jne 0x3f2f9
jmp 0x3f2b1
movq -0x10(%rbp), %rdi
leaq 0xccea(%rip), %rsi      # 0x4bfa6
callq 0x5390
jmp 0x3f31f
movq -0x10(%rbp), %rdi
leaq 0xccdb(%rip), %rsi      # 0x4bfa9
callq 0x5390
jmp 0x3f31f
movq -0x10(%rbp), %rdi
leaq 0xcccc(%rip), %rsi      # 0x4bfac
callq 0x5390
jmp 0x3f31f
movq -0x10(%rbp), %rdi
leaq 0xccbd(%rip), %rsi      # 0x4bfaf
callq 0x5390
jmp 0x3f31f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x5770
movq -0x40(%rbp), %rdi
movsbl (%rax), %esi
callq 0x5490
jmp 0x3f321
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f250
movq -0x10(%rbp), %rdi
leaq 0xcc78(%rip), %rsi      # 0x4bfb2
callq 0x5390
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/scalar.cpp
// Function: YAML::(anonymous namespace)::IsFlexibleCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsFlexibleCase(const std::string& str)
		{
			if(str.empty())
				return true;

			if(IsEntirely(str, IsLower))
				return true;

			bool firstcaps = IsUpper(str[0]);
			std::string rest = str.substr(1);
			return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5660
testb $0x1, %al
jne 0x3fe5b
jmp 0x3fe64
movb $0x1, -0x1(%rbp)
jmp 0x3ff32
movq -0x10(%rbp), %rdi
leaq 0x2c1(%rip), %rsi       # 0x40130
callq 0x400b0
testb $0x1, %al
jne 0x3fe7a
jmp 0x3fe83
movb $0x1, -0x1(%rbp)
jmp 0x3ff32
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5450
movsbl (%rax), %edi
callq 0x40160
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x53d0
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x45(%rbp)
je 0x3ff08
leaq 0x268(%rip), %rsi       # 0x40130
leaq -0x38(%rbp), %rdi
callq 0x400b0
movb %al, -0x46(%rbp)
jmp 0x3fed6
movb -0x46(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x47(%rbp)
jne 0x3ff02
jmp 0x3fee5
leaq 0x274(%rip), %rsi       # 0x40160
leaq -0x38(%rbp), %rdi
callq 0x400b0
movb %al, -0x48(%rbp)
jmp 0x3fefa
movb -0x48(%rbp), %al
movb %al, -0x47(%rbp)
jmp 0x3ff02
movb -0x47(%rbp), %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5788
jmp 0x3ff32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5788
jmp 0x3ff3d
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x3a880
testb $0x1, %al
jne 0x4006f
jmp 0x40078
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x400a3
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x401d0
testb $0x1, %al
jne 0x40093
jmp 0x4009c
movl $0x1, -0x4(%rbp)
jmp 0x400a3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/yaml/scalar.cpp
// Function: bool YAML::(anonymous namespace)::IsEntirely<bool (*)(char)>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (*)(char))
bool IsEntirely(const std::string& str, T func)
		{
			for(unsigned i=0;i<str.size();i++)
				if(!func(str[i]))
					return false;

			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5290
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4011c
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x5450
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsbl (%rcx), %edi
callq *%rax
testb $0x1, %al
jne 0x4010f
movb $0x0, -0x1(%rbp)
jmp 0x40120
jmp 0x40111
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x400c7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x40ef0
testb $0x1, %al
jne 0x404eb
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x40f30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x404d1
jmp 0x40502
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x404e9
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x40f10
jmp 0x404a4
jmp 0x404eb
movq -0x18(%rbp), %rax
testb $0x1, 0x61(%rax)
je 0x404f7
jmp 0x40502
movq -0x18(%rbp), %rdi
callq 0x405c0
jmp 0x404a4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x409a6
movq -0x18(%rbp), %rdi
callq 0x4a840
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x40bd0
testb $0x1, %al
jne 0x409c1
jmp 0x409d1
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4a9a0
jmp 0x409a6
movq -0x18(%rbp), %rsi
leaq 0x2bb74(%rip), %rdi     # 0x6c550
callq 0x3c550
testb $0x1, %al
jne 0x409e7
jmp 0x40a30
jmp 0x409e9
movq -0x18(%rbp), %rdi
callq 0x4a860
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x40a00
jmp 0x40a15
movq -0x18(%rbp), %rsi
leaq 0x2b8a5(%rip), %rdi     # 0x6c2b0
callq 0x3c550
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x40a1e
jmp 0x40a2e
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4a9a0
jmp 0x409e9
jmp 0x40a30
movq -0x18(%rbp), %rsi
leaq 0x2b875(%rip), %rdi     # 0x6c2b0
callq 0x3c550
testb $0x1, %al
jne 0x40a46
jmp 0x40a87
movq -0x18(%rbp), %rsi
leaq 0x2b85f(%rip), %rdi     # 0x6c2b0
callq 0x3c580
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
callq 0x4a9a0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x49ba0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x40a82
movq -0x18(%rbp), %rax
movb $0x1, 0x62(%rax)
jmp 0x409a4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpl $0x0, 0x64(%rax)
jle 0x40ab5
jmp 0x40b68
jmp 0x40ab7
movq -0x70(%rbp), %rdi
addq $0xc0, %rdi
callq 0x41080
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x40aee
movq -0x70(%rbp), %rdi
addq $0xc0, %rdi
callq 0x40f80
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setg %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x40af7
jmp 0x40b68
movq -0x70(%rbp), %rdi
addq $0xc0, %rdi
callq 0x410a0
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x88(%rbp)
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x5, %esi
callq 0x41000
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x40fd0
jmp 0x40b43
leaq -0x58(%rbp), %rdi
callq 0x35c00
jmp 0x40ab7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35c00
jmp 0x40b71
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xc(%rax)
jle 0x40ba5
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x40a90
movq -0x10(%rbp), %rdi
callq 0x49d10
movq -0x10(%rbp), %rax
movb $0x0, 0x62(%rax)
movb $0x1, 0x61(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::IsWhitespaceToBeEaten(char)
bool Scanner::IsWhitespaceToBeEaten(char ch)
	{
		if(ch == ' ')
			return true;

		if(ch == '\t' && (m_flowLevel >= 0 || !m_simpleKeyAllowed))
			return true;

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jne 0x40bf5
movb $0x1, -0x1(%rbp)
jmp 0x40c1c
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
jne 0x40c18
movq -0x20(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jge 0x40c12
movq -0x20(%rbp), %rax
testb $0x1, 0x62(%rax)
jne 0x40c18
movb $0x1, -0x1(%rbp)
jmp 0x40c1c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xf0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpl $0x0, 0x64(%rax)
jle 0x40c67
movq $0x0, -0x8(%rbp)
jmp 0x40dab
movq -0xc0(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0xc4(%rbp)
addq $0xc0, %rdi
callq 0x40f80
movq %rax, %rcx
movl -0xc4(%rbp), %eax
cmpl (%rcx), %eax
jg 0x40c9d
movq $0x0, -0x8(%rbp)
jmp 0x40dab
movq -0xc0(%rbp), %rdi
addq $0xc0, %rdi
leaq -0x14(%rbp), %rsi
callq 0x40fa0
testb $0x1, -0x15(%rbp)
je 0x40d27
movq -0xc0(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0xd8(%rbp)
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movl $0x3, %esi
callq 0x41000
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x40fd0
jmp 0x40cff
leaq -0x60(%rbp), %rdi
callq 0x35c00
jmp 0x40d97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35c00
jmp 0x40db8
movq -0xc0(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0xe8(%rbp)
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movl $0x4, %esi
callq 0x41000
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x40fd0
jmp 0x40d6f
leaq -0xb8(%rbp), %rdi
callq 0x35c00
jmp 0x40d97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x35c00
jmp 0x40db8
movq -0xc0(%rbp), %rdi
addq $0x10, %rdi
callq 0x41060
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl 0xc(%rdi), %esi
callq 0x40a90
movq -0x80(%rbp), %rdi
callq 0x49d10
movq -0x80(%rbp), %rdi
movb $0x0, 0x62(%rdi)
movl 0x8(%rdi), %eax
movl %eax, -0xc(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x10(%rbp)
movl $0x3, %esi
callq 0x4a9a0
movq -0x80(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x1, %esi
callq 0x41000
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x40fd0
jmp 0x456b9
leaq -0x58(%rbp), %rdi
callq 0x35c00
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35c00
movq -0x60(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x40a90
movq -0x80(%rbp), %rdi
callq 0x49d10
movq -0x80(%rbp), %rdi
movb $0x0, 0x62(%rdi)
movl 0x8(%rdi), %eax
movl %eax, -0xc(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x10(%rbp)
movl $0x3, %esi
callq 0x4a9a0
movq -0x80(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x2, %esi
callq 0x41000
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x40fd0
jmp 0x4576b
leaq -0x58(%rbp), %rdi
callq 0x35c00
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35c00
movq -0x60(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x49a90
movq -0x88(%rbp), %rdi
movl 0x64(%rdi), %eax
incl %eax
movl %eax, 0x64(%rdi)
movb $0x1, 0x62(%rdi)
movl 0x8(%rdi), %eax
movl %eax, -0xc(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x10(%rbp)
callq 0x4a890
movb %al, %cl
movq -0x88(%rbp), %rax
movb %cl, -0x11(%rbp)
movb -0x11(%rbp), %cl
subb $0x5b, %cl
setne %cl
movzbl %cl, %ecx
addl $0x7, %ecx
movl %ecx, -0x18(%rbp)
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movl -0x18(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x41000
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x40fd0
jmp 0x4582e
leaq -0x60(%rbp), %rdi
callq 0x35c00
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35c00
movq -0x68(%rbp), %rdi
callq 0x56c0
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x0, 0x64(%rax)
jne 0x458da
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq -0x78(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x27e5e(%rip), %rcx     # 0x6d700
callq 0x340e0
jmp 0x458a9
movq -0x80(%rbp), %rdi
leaq 0x21d4c(%rip), %rsi     # 0x67600
leaq -0x1178b(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x52c0
jmp 0x45976
movq -0x78(%rbp), %rdi
movl 0x64(%rdi), %eax
decl %eax
movl %eax, 0x64(%rdi)
movb $0x0, 0x62(%rdi)
movl 0x8(%rdi), %eax
movl %eax, -0x18(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x1c(%rbp)
callq 0x4a890
movb %al, %cl
movq -0x78(%rbp), %rax
movb %cl, -0x1d(%rbp)
movb -0x1d(%rbp), %cl
subb $0x5d, %cl
setne %cl
movzbl %cl, %ecx
addl $0x9, %ecx
movl %ecx, -0x24(%rbp)
addq $0x10, %rax
movq %rax, -0x90(%rbp)
movl -0x24(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x41000
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x40fd0
jmp 0x4594f
leaq -0x70(%rbp), %rdi
callq 0x35c00
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35c00
movq -0x10(%rbp), %rdi
callq 0x56c0
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movb $0x1, 0x62(%rdi)
movl 0x8(%rdi), %eax
movl %eax, -0xc(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x10(%rbp)
movl $0x1, %esi
callq 0x4a9a0
movq -0x80(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0xb, %esi
callq 0x41000
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x40fd0
jmp 0x459e4
leaq -0x58(%rbp), %rdi
callq 0x35c00
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35c00
movq -0x60(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpl $0x0, 0x64(%rax)
jle 0x45a9a
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq -0x70(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x78(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x27cbe(%rip), %rcx     # 0x6d720
callq 0x340e0
jmp 0x45a69
movq -0x78(%rbp), %rdi
leaq 0x21b8c(%rip), %rsi     # 0x67600
leaq -0x1194b(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x52c0
jmp 0x45b9d
movq -0x70(%rbp), %rax
testb $0x1, 0x62(%rax)
jne 0x45b01
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq -0x70(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x27c57(%rip), %rcx     # 0x6d720
callq 0x340e0
jmp 0x45ad0
movq -0x80(%rbp), %rdi
leaq 0x21b25(%rip), %rsi     # 0x67600
leaq -0x119b2(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x52c0
jmp 0x45b9d
movq -0x70(%rbp), %rdi
movl 0xc(%rdi), %esi
movl $0x1, %edx
movl %edx, -0x94(%rbp)
callq 0x40c30
movl -0x94(%rbp), %esi
movq -0x70(%rbp), %rdi
movb $0x1, 0x62(%rdi)
movl 0x8(%rdi), %eax
movl %eax, -0x18(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x1c(%rbp)
callq 0x4a9a0
movq -0x70(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x90(%rbp)
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0x6, %esi
callq 0x41000
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x40fd0
jmp 0x45b76
leaq -0x68(%rbp), %rdi
callq 0x35c00
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35c00
movq -0x10(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpl $0x0, 0x64(%rax)
jne 0x45c42
movq -0x70(%rbp), %rax
testb $0x1, 0x62(%rax)
jne 0x45c34
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq -0x70(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x78(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x27b44(%rip), %rcx     # 0x6d740
callq 0x340e0
jmp 0x45c03
movq -0x78(%rbp), %rdi
leaq 0x219f2(%rip), %rsi     # 0x67600
leaq -0x11ae5(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x52c0
jmp 0x45cd8
movq -0x70(%rbp), %rdi
movl 0xc(%rdi), %esi
xorl %edx, %edx
callq 0x40c30
movq -0x70(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x45c56
movq -0x70(%rbp), %rax
movb $0x1, 0x62(%rax)
jmp 0x45c5e
movq -0x70(%rbp), %rax
movb $0x0, 0x62(%rax)
movq -0x70(%rbp), %rdi
movl 0x8(%rdi), %eax
movl %eax, -0x18(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, %esi
callq 0x4a9a0
movq -0x70(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0xc, %esi
callq 0x41000
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x40fd0
jmp 0x45cb1
leaq -0x68(%rbp), %rdi
callq 0x35c00
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35c00
movq -0x10(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanValue()
void Scanner::ScanValue()
	{
		// does this follow a simple key?
		if(m_isLastKeyValid) {
			// can't follow a simple key with another simple key (dunno why, though - it seems fine)
			m_simpleKeyAllowed = false;
		} else {
			// handle values diffently in the block context (and manage indents)
			if(m_flowLevel == 0) {
				if(!m_simpleKeyAllowed)
					throw ParserException(INPUT.line, INPUT.column, ErrorMsg::MAP_VALUE);

				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_VALUE, line, column));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0x68(%rax)
je 0x45d1a
movq -0x70(%rbp), %rax
movb $0x0, 0x62(%rax)
jmp 0x45db7
movq -0x70(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x45d99
movq -0x70(%rbp), %rax
testb $0x1, 0x62(%rax)
jne 0x45d8b
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq -0x70(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x78(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x27a0d(%rip), %rcx     # 0x6d760
callq 0x340e0
jmp 0x45d5a
movq -0x78(%rbp), %rdi
leaq 0x2189b(%rip), %rsi     # 0x67600
leaq -0x11c3c(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x52c0
jmp 0x45e31
movq -0x70(%rbp), %rdi
movl 0xc(%rdi), %esi
xorl %edx, %edx
callq 0x40c30
movq -0x70(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x45dad
movq -0x70(%rbp), %rax
movb $0x1, 0x62(%rax)
jmp 0x45db5
movq -0x70(%rbp), %rax
movb $0x0, 0x62(%rax)
jmp 0x45db7
movq -0x70(%rbp), %rdi
movl 0x8(%rdi), %eax
movl %eax, -0x18(%rbp)
movl 0xc(%rdi), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, %esi
callq 0x4a9a0
movq -0x70(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0xd, %esi
callq 0x41000
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x40fd0
jmp 0x45e0a
leaq -0x68(%rbp), %rdi
callq 0x35c00
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35c00
movq -0x10(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/sequence.cpp
// Function: YAML::Sequence::Parse(YAML::Scanner*, YAML::ParserState const&)
void Sequence::Parse(Scanner *pScanner, const ParserState& state)
	{
		Clear();

		// split based on start token
		switch(pScanner->peek().type) {
			case TT_BLOCK_SEQ_START: ParseBlock(pScanner, state); break;
			case TT_BLOCK_ENTRY: ParseImplicit(pScanner, state); break;
			case TT_FLOW_SEQ_START: ParseFlow(pScanner, state); break;
			default:
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x48480
movq -0x10(%rbp), %rdi
callq 0x40550
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3, %eax
je 0x4869b
jmp 0x48687
movl -0x1c(%rbp), %eax
subl $0x6, %eax
je 0x486ae
jmp 0x48691
movl -0x1c(%rbp), %eax
subl $0x7, %eax
je 0x486c1
jmp 0x486d4
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x486e0
jmp 0x486d6
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x488e0
jmp 0x486d6
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x489b0
jmp 0x486d6
jmp 0x486d6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)