LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/regex.cpp
// Function: YAML::RegEx::SeqOperator::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, YAML::RegEx const&) const
int RegEx::SeqOperator::Match(const std::string& str, const RegEx& regex) const
	{
		int offset = 0;
		for(unsigned i=0;i<regex.m_params.size();i++) {
			int n = regex.m_params[i].Match(str.substr(offset));
			if(n == -1)
				return -1;
			offset += n;
		}
		return offset;
	}

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

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

		return offset;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdx), %rax
cmpq %rax, 0x20(%rdx)
je 0x2ab3e
movq %rdx, %rbx
movq %rsi, %r14
xorl %ecx, %ecx
movl $0x1, %r13d
xorl %r15d, %r15d
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %r14, %rsi
callq 0x2a41a
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x2ab0e
addl %r12d, %r15d
movslq %r12d, %rsi
movq %r14, %rdi
callq 0x5070
cmpl $-0x1, %r12d
je 0x2ab43
movl %r13d, %ecx
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
incl %r13d
cmpq %rcx, %rdx
ja 0x2aae5
jmp 0x2ab49
xorl %r15d, %r15d
jmp 0x2ab49
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x680e(%rip), %rsi      # 0x31d07
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5360
cmpq $0x0, 0x10(%r14)
je 0x2b5a6
movl $0x1, %r13d
xorl %eax, %eax
leaq 0x69c3(%rip), %r15      # 0x31ee3
leaq 0x69b3(%rip), %r12      # 0x31eda
movq 0x8(%r14), %rcx
movb (%rcx,%rax), %al
movzbl %al, %ecx
cmpl $0xc, %ecx
jg 0x2b551
cmpl $0x9, %ecx
je 0x2b579
cmpl $0xa, %ecx
jne 0x2b568
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x6991(%rip), %rsi      # 0x31ee0
jmp 0x2b595
cmpl $0xd, %ecx
je 0x2b58a
cmpl $0x5c, %ecx
jne 0x2b568
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x2b595
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
jmp 0x2b595
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x6955(%rip), %rsi      # 0x31edd
jmp 0x2b595
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movl %r13d, %eax
incl %r13d
cmpq %rax, 0x10(%r14)
ja 0x2b527
leaq 0x6939(%rip), %rsi      # 0x31ee6
movl $0x2, %edx
movq %rbx, %rdi
callq 0x5360
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/scalar.cpp
// Function: YAML::Scalar::Compare(YAML::Scalar*)
int Scalar::Compare(Scalar *pScalar)
	{
		if(m_data < pScalar->m_data)
			return -1;
		else if(m_data > pScalar->m_data)
			return 1;
		else
			return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5060
testl %eax, %eax
js 0x2bf34
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5060
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x2bf39
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2bf40
movq %rax, %rdi
callq 0x1a412
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c0ea
movl (%rax), %eax
testl %eax, %eax
je 0x2c0d6
cmpl $0x1, %eax
jne 0x2c0dd
movq %r14, %rdi
callq 0x2cef2
movl $0x2, %eax
jmp 0x2c0df
movl $0x1, %eax
jmp 0x2c0df
xorl %eax, %eax
testl %eax, %eax
je 0x2c0ea
cmpl $0x2, %eax
je 0x2c0b2
jmp 0x2c0fa
cmpb $0x0, 0x61(%rbx)
jne 0x2c0fa
movq %rbx, %rdi
callq 0x2c170
jmp 0x2c0b2
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c0a4
movq 0x20(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x2c151
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5db6(%rip), %rdi      # 0x31f0e
leaq 0x5dc1(%rip), %rsi      # 0x31f20
leaq 0x5dcb(%rip), %rcx      # 0x31f31
movl $0x29, %edx
callq 0x51b0
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::ScanToNextToken()
void Scanner::ScanToNextToken()
	{
		while(1) {
			// first eat whitespace
			while(IsWhitespaceToBeEaten(INPUT.peek()))
				INPUT.eat(1);

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13fe0(%rip), %r14     # 0x40490
leaq 0x13d39(%rip), %r15     # 0x401f0
movq %rbx, %rdi
callq 0x308de
cmpb $0x20, %al
je 0x2c510
movzbl %al, %eax
cmpl $0x9, %eax
jne 0x2c4d7
cmpl $0x0, 0x64(%rbx)
jns 0x2c510
cmpb $0x1, 0x62(%rbx)
jne 0x2c510
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a482
testb %al, %al
je 0x2c51f
movq %rbx, %rdi
callq 0x308ec
testb %al, %al
je 0x2c51f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a482
testb %al, %al
jne 0x2c51f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3099c
jmp 0x2c4e6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3099c
jmp 0x2c4b7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a482
testb %al, %al
je 0x2c560
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a496
movq %rbx, %rdi
movl %eax, %esi
callq 0x3099c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x304f4
cmpl $0x0, 0x64(%rbx)
jne 0x2c4b7
movb $0x1, 0x62(%rbx)
jmp 0x2c4b7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c592
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq 0xf0(%rdi), %rax
cmpq 0xd0(%rdi), %rax
je 0x2c583
movl %esi, %ebx
leaq 0xc0(%r14), %rcx
movq %rcx, -0x38(%rbp)
leaq 0x10(%r14), %rcx
movq %rcx, -0x30(%rbp)
leaq -0x50(%rbp), %r13
xorl %r15d, %r15d
cmpq 0xf8(%r14), %rax
jne 0x2c5dd
movq 0x108(%r14), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
cmpl %ebx, -0x4(%rax)
jle 0x2c583
movq -0x38(%rbp), %rdi
callq 0x2d5ce
movq 0x8(%r14), %rax
movabsq $0x500000000, %rcx      # imm = 0x500000000
movq %rcx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x70(%rbp)
movq %r15, -0x68(%rbp)
movb $0x0, -0x60(%rbp)
movq %r15, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2d2dc
movq %r13, %rdi
callq 0x27ca8
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x2c647
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x52e0
movq 0xf0(%r14), %rax
cmpq 0xd0(%r14), %rax
jne 0x2c5c1
jmp 0x2c583
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c68a
movl $0x0, 0xc(%rbx)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2c56c
movq %rbx, %rdi
callq 0x3061e
movw $0x1, 0x61(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/scanner.cpp
// Function: YAML::Scanner::PushIndentTo(int, bool)
Token *Scanner::PushIndentTo(int column, bool sequence)
	{
		// are we in flow?
		if(m_flowLevel > 0)
			return 0;

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

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

		return &m_tokens.back();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, -0x1c(%rbp)
cmpl $0x0, 0x64(%rdi)
jg 0x2c72f
movl %edx, %r14d
movq %rdi, %rbx
movq 0xf0(%rdi), %rax
movq %rax, %rcx
cmpq 0xf8(%rdi), %rax
jne 0x2c70b
movq 0x108(%rbx), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
cmpl %esi, -0x4(%rcx)
jge 0x2c72f
movq 0x100(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x2c73c
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0xf0(%rbx)
jmp 0x2c74c
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc0(%rbx), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x2d214
leaq 0x10(%rbx), %rdi
testb %r14b, %r14b
je 0x2c794
movq 0x8(%rbx), %rax
movabsq $0x300000000, %rcx      # imm = 0x300000000
leaq -0x48(%rbp), %r15
movq %rcx, -0x20(%r15)
movq %rax, -0x18(%r15)
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq -0x68(%rbp), %rsi
callq 0x2d2dc
jmp 0x2c7d1
movq 0x8(%rbx), %rax
movabsq $0x400000000, %rcx      # imm = 0x400000000
leaq -0x48(%rbp), %r15
movq %rcx, -0x20(%r15)
movq %rax, -0x18(%r15)
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq -0x68(%rbp), %rsi
callq 0x2d2dc
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x27ca8
movq -0x20(%r14), %rdi
cmpq %r15, %rdi
je 0x2c7f2
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x52e0
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
jne 0x2c809
movq 0x58(%rbx), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
addq $-0x48, %rax
jmp 0x2c731
jmp 0x2c814
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanDocStart()
void Scanner::ScanDocStart()
	{
		PopIndentTo(INPUT.column);
		VerifyAllSimpleKeys();
		m_simpleKeyAllowed = false;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %esi
callq 0x2c56c
movq %rbx, %rdi
callq 0x3061e
xorl %r15d, %r15d
movb %r15b, 0x62(%rbx)
movq 0x8(%rbx), %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3099c
addq $0x10, %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq -0x48(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r12, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %r15, -0x8(%r14)
movb %r15b, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r15, 0x20(%r14)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d2dc
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x27ca8
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2dedc
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x52e0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanDocEnd()
void Scanner::ScanDocEnd()
	{
		PopIndentTo(-1);
		VerifyAllSimpleKeys();
		m_simpleKeyAllowed = false;

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

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

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

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

		m_flowLevel--;
		m_simpleKeyAllowed = false;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x2e112
decl %eax
movl %eax, 0x64(%rbx)
xorl %r15d, %r15d
movb %r15b, 0x62(%rbx)
movq 0x8(%rbx), %r12
movq %rbx, %rdi
callq 0x30904
xorl %ecx, %ecx
cmpb $0x5d, %al
setne %cl
addl $0x9, %ecx
addq $0x10, %rbx
leaq -0x48(%rbp), %r14
movl $0x0, -0x20(%r14)
movl %ecx, -0x1c(%r14)
movq %r12, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %r15, -0x8(%r14)
movb %r15b, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r15, 0x20(%r14)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d2dc
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x27ca8
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2e105
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x52e0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13514(%rip), %rcx     # 0x41640
movq %rax, %rdi
callq 0x26d60
leaq 0xd51d(%rip), %rsi      # 0x3b658
leaq -0x1390e(%rip), %rdx    # 0x1a834
movq %r14, %rdi
callq 0x5520
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
jmp 0x2e163
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanFlowEntry()
void Scanner::ScanFlowEntry()
	{
		m_simpleKeyAllowed = true;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x64(%rdi)
jg 0x2e2c3
cmpb $0x0, 0x62(%rbx)
je 0x2e2e7
movl 0xc(%rbx), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2c6cc
movb $0x1, 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3099c
addq $0x10, %rbx
movabsq $0x600000000, %rax      # imm = 0x600000000
leaq -0x40(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r15, -0x18(%r14)
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d2dc
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x27ca8
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2e2b8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x52e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13383(%rip), %rcx     # 0x41660
movq %rax, %rdi
callq 0x26d60
jmp 0x2e309
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x1335f(%rip), %rcx     # 0x41660
movq %rax, %rdi
callq 0x26d60
leaq 0xd348(%rip), %rsi      # 0x3b658
leaq -0x13ae3(%rip), %rdx    # 0x1a834
movq %r14, %rdi
callq 0x5520
jmp 0x2e321
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
jmp 0x2e33a
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::ScanKey()
void Scanner::ScanKey()
	{
		// handle keys diffently in the block context (and manage indents)
		if(m_flowLevel == 0) {
			if(!m_simpleKeyAllowed)
				throw ParserException(INPUT.line, INPUT.column, ErrorMsg::MAP_KEY);

			PushIndentTo(INPUT.column, false);
		}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x64(%rdi)
jne 0x2e36f
cmpb $0x0, 0x62(%rbx)
je 0x2e3f4
movl 0xc(%rbx), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2c6cc
cmpl $0x0, 0x64(%rbx)
sete 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3099c
addq $0x10, %rbx
movabsq $0xc00000000, %rax      # imm = 0xC00000000
leaq -0x40(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r15, -0x18(%r14)
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d2dc
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x27ca8
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2e3e9
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x52e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13272(%rip), %rcx     # 0x41680
movq %rax, %rdi
callq 0x26d60
leaq 0xd23b(%rip), %rsi      # 0x3b658
leaq -0x13bf0(%rip), %rdx    # 0x1a834
movq %r14, %rdi
callq 0x5520
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
jmp 0x2e445
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x68(%rdi)
je 0x2e48b
cmpl $0x0, 0x64(%rbx)
jne 0x2e481
cmpb $0x0, 0x62(%rbx)
je 0x2e515
movl 0xc(%rbx), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2c6cc
cmpl $0x0, 0x64(%rbx)
je 0x2e50c
movb $0x0, 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3099c
addq $0x10, %rbx
movabsq $0xd00000000, %rax      # imm = 0xD00000000
leaq -0x40(%rbp), %r14
movq %rax, -0x20(%r14)
movq %r15, -0x18(%r14)
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d2dc
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x27ca8
movq -0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2e501
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x52e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x62(%rbx)
jmp 0x2e48f
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13171(%rip), %rcx     # 0x416a0
movq %rax, %rdi
callq 0x26d60
leaq 0xd11a(%rip), %rsi      # 0x3b658
leaq -0x13d11(%rip), %rdx    # 0x1a834
movq %r14, %rdi
callq 0x5520
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
jmp 0x2e566
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2fa7a
movq %r14, %rdi
callq 0x2c132
movl 0x4(%rax), %eax
cmpl $0x7, %eax
je 0x2fbc6
cmpl $0x6, %eax
je 0x2fbae
cmpl $0x3, %eax
jne 0x2fbde
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2fbea
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2fdfe
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2febc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/sequence.cpp
// Function: YAML::Sequence::ParseBlock(YAML::Scanner*, YAML::ParserState const&)
void Sequence::ParseBlock(Scanner *pScanner, const ParserState& state)
	{
		// eat start token
		pScanner->pop();

		while(1) {
			if(pScanner->empty())
				throw ParserException(-1, -1, ErrorMsg::END_OF_SEQ);

			Token token = pScanner->peek();
			if(token.type != TT_BLOCK_ENTRY && token.type != TT_BLOCK_END)
				throw ParserException(token.line, token.column, ErrorMsg::END_OF_SEQ);

			pScanner->pop();
			if(token.type == TT_BLOCK_END)
				break;

			Node *pNode = new Node;
			m_data.push_back(pNode);
			pNode->Parse(pScanner, state);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2c100
leaq -0x60(%rbp), %r13
leaq 0x8(%r15), %rax
movq %rax, -0x38(%rbp)
movq %r14, %rdi
callq 0x2c084
testb %al, %al
jne 0x2fd14
movq %r14, %rdi
callq 0x2c132
movq %rax, %rbx
movups (%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x1a6b8
addq $0x30, %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x27b32
movl -0x8c(%rbp), %eax
addl $-0x7, %eax
cmpl $-0x3, %eax
jbe 0x2fd50
movq %r14, %rdi
callq 0x2c100
movl -0x8c(%rbp), %r12d
cmpl $0x5, %r12d
je 0x2fcda
movl $0x58, %edi
callq 0x52d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x280a8
movq %rbx, -0x30(%rbp)
movq 0x10(%r15), %rsi
cmpq 0x18(%r15), %rsi
je 0x2fcbd
movq %rbx, (%rsi)
addq $0x8, 0x10(%r15)
jmp 0x2fcca
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3021e
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq -0x40(%rbp), %rdx
callq 0x28164
movq %r13, %rdi
callq 0x27ca8
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x2fcfb
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x52e0
cmpl $0x5, %r12d
jne 0x2fc19
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x5140
movq %rax, %rbx
leaq 0x12028(%rip), %rcx     # 0x41d50
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x26d60
leaq 0xb917(%rip), %rsi      # 0x3b658
leaq -0x15514(%rip), %rdx    # 0x1a834
movq %rbx, %rdi
callq 0x5520
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
movl -0x88(%rbp), %esi
movl -0x84(%rbp), %edx
leaq 0x11fe0(%rip), %rcx     # 0x41d50
movq %rax, %rdi
callq 0x1a648
leaq 0xbb41(%rip), %rax      # 0x3b8c0
movq %rax, (%r14)
leaq 0xb8cf(%rip), %rsi      # 0x3b658
leaq -0x1555c(%rip), %rdx    # 0x1a834
movq %r14, %rdi
callq 0x5520
movq %rax, %r15
movl $0x58, %esi
movq %rbx, %rdi
callq 0x52e0
jmp 0x2fde9
jmp 0x2fde6
movq %rax, %r15
movq %r14, %rdi
callq 0x5230
jmp 0x2fde9
movq %rax, %r15
movq %rbx, %rdi
callq 0x5230
jmp 0x2fdf5
movq %rax, %r15
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x2fdf5
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x52e0
jmp 0x2fdf5
jmp 0x2fde6
movq %rax, %r15
leaq -0x90(%rbp), %rdi
callq 0x27a7c
movq %r15, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/sequence.cpp
// Function: YAML::Sequence::ParseImplicit(YAML::Scanner*, YAML::ParserState const&)
void Sequence::ParseImplicit(Scanner *pScanner, const ParserState& state)
	{
		while(1) {
			// we're actually *allowed* to have no tokens at some point
			if(pScanner->empty())
				break;

			// and we end at anything other than a block entry
			Token& token = pScanner->peek();
			if(token.type != TT_BLOCK_ENTRY)
				break;

			pScanner->pop();

			Node *pNode = new Node;
			m_data.push_back(pNode);
			pNode->Parse(pScanner, state);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %r14, %rdi
callq 0x2c084
testb %al, %al
jne 0x2fe95
movq %r14, %rdi
callq 0x2c132
movl 0x4(%rax), %r12d
cmpl $0x6, %r12d
jne 0x2fe95
movq %r14, %rdi
callq 0x2c100
movl $0x58, %edi
callq 0x52d0
movq %rax, %r13
movq %rax, %rdi
callq 0x280a8
movq %r13, -0x30(%rbp)
movq 0x10(%r15), %rsi
cmpq 0x18(%r15), %rsi
je 0x2fe73
movq %r13, (%rsi)
addq $0x8, 0x10(%r15)
jmp 0x2fe80
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3021e
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x28164
cmpl $0x6, %r12d
je 0x2fe20
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/sequence.cpp
// Function: YAML::Sequence::ParseFlow(YAML::Scanner*, YAML::ParserState const&)
void Sequence::ParseFlow(Scanner *pScanner, const ParserState& state)
	{
		// eat start token
		pScanner->pop();

		while(1) {
			if(pScanner->empty())
				throw ParserException(-1, -1, ErrorMsg::END_OF_SEQ_FLOW);

			// first check for end
			if(pScanner->peek().type == TT_FLOW_SEQ_END) {
				pScanner->pop();
				break;
			}

			// then read the node
			Node *pNode = new Node;
			m_data.push_back(pNode);
			pNode->Parse(pScanner, state);

			// now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node)
			Token& token = pScanner->peek();
			if(token.type == TT_FLOW_ENTRY)
				pScanner->pop();
			else if(token.type != TT_FLOW_SEQ_END)
				throw ParserException(token.line, token.column, ErrorMsg::END_OF_SEQ_FLOW);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2c100
movq %rbx, %rdi
callq 0x2c084
testb %al, %al
jne 0x2ff79
leaq 0x8(%r15), %r12
movq %rbx, %rdi
callq 0x2c132
cmpl $0x9, 0x4(%rax)
je 0x2ffa1
movl $0x58, %edi
callq 0x52d0
movq %rax, %r13
movq %rax, %rdi
callq 0x280a8
movq %r13, -0x30(%rbp)
movq 0x10(%r15), %rsi
cmpq 0x18(%r15), %rsi
je 0x2ff2e
movq %r13, (%rsi)
addq $0x8, 0x10(%r15)
jmp 0x2ff3a
movq %r12, %rdi
leaq -0x30(%rbp), %rdx
callq 0x3021e
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x28164
movq %rbx, %rdi
callq 0x2c132
movq %rax, %r13
movl 0x4(%rax), %eax
cmpl $0x9, %eax
je 0x2ff69
cmpl $0xb, %eax
jne 0x2ffb8
movq %rbx, %rdi
callq 0x2c100
movq %rbx, %rdi
callq 0x2c084
testb %al, %al
je 0x2feef
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
leaq 0x11de3(%rip), %rcx     # 0x41d70
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x26d60
jmp 0x2ffdc
movq %rbx, %rdi
callq 0x2c100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x5140
movq %rax, %r14
movl 0x8(%r13), %esi
movl 0xc(%r13), %edx
leaq 0x11d9c(%rip), %rcx     # 0x41d70
movq %rax, %rdi
callq 0x26d60
leaq 0xb675(%rip), %rsi      # 0x3b658
leaq -0x157b6(%rip), %rdx    # 0x1a834
movq %r14, %rdi
callq 0x5520
jmp 0x2fff4
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
jmp 0x30011
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/sequence.cpp
// Function: YAML::Sequence::Write(std::ostream&, int, bool, bool)
void Sequence::Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine)
	{
		if(startedLine && !onlyOneCharOnLine)
			out << "\n";

		for(unsigned i=0;i<m_data.size();i++) {
			if((startedLine && !onlyOneCharOnLine) || i > 0) {
				for(int j=0;j<indent;j++)
					out  << "  ";
			}

			out << "- ";
			m_data[i]->Write(out, indent + 1, true, i > 0 || !startedLine || onlyOneCharOnLine);
		}

		if(m_data.empty())
			out << "\n";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %rbx
movq %rdi, %r13
movl %ecx, -0x48(%rbp)
movl %ecx, %eax
xorb $0x1, %al
movl %r8d, -0x40(%rbp)
orb %r8b, %al
movb %al, -0x29(%rbp)
jne 0x3005c
leaq 0x1e98(%rip), %rsi      # 0x31ee7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5360
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
cmpq %rax, %rcx
je 0x3012b
movq -0x38(%rbp), %rax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl %ecx, -0x3c(%rbp)
incl %eax
movl %eax, -0x44(%rbp)
xorl %r12d, %r12d
leaq 0x1d40(%rip), %r15      # 0x31dce
cmpb $0x0, -0x48(%rbp)
je 0x300aa
testl %r12d, %r12d
sete %al
cmpl $0x0, -0x38(%rbp)
setle %cl
andb -0x40(%rbp), %al
orb %cl, %al
je 0x300bb
jmp 0x300d4
testl %r12d, %r12d
sete %al
cmpl $0x0, -0x38(%rbp)
setle %cl
orb %al, %cl
jne 0x300d4
movl -0x3c(%rbp), %r14d
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
decl %r14d
jne 0x300bf
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x1ee6(%rip), %rsi      # 0x31fc9
callq 0x5360
movq 0x8(%r13), %rax
movq (%rax,%r12,8), %rdi
testl %r12d, %r12d
setne %al
orb -0x29(%rbp), %al
movzbl %al, %r8d
movq %rbx, %rsi
movl -0x44(%rbp), %edx
movl $0x1, %ecx
callq 0x2859a
incl %r12d
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
ja 0x3008e
cmpq %rcx, %rax
je 0x3013f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1da1(%rip), %rsi      # 0x31ee7
movl $0x1, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5360
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/sequence.cpp
// Function: YAML::Sequence::Compare(YAML::Sequence*)
int Sequence::Compare(Sequence *pSeq)
	{
		unsigned n = m_data.size(), m = pSeq->m_data.size();
		if(n < m)
			return -1;
		else if(n > m)
			return 1;

		for(unsigned i=0;i<n;i++) {
			int cmp = m_data[i]->Compare(*pSeq->m_data[i]);
			if(cmp != 0)
				return cmp;
		}

		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
movq 0x10(%rsi), %rcx
subq 0x8(%rsi), %rcx
shrq $0x3, %rax
shrq $0x3, %rcx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jb 0x301ec
movl $0x1, %r15d
ja 0x301ec
testl %eax, %eax
je 0x301e9
movq %rdi, %rbx
movq %rsi, %r14
movl %eax, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rsi
callq 0x28cf2
testl %eax, %eax
cmovnel %eax, %r15d
jne 0x301ec
incq %r13
cmpq %r13, %r12
jne 0x301c4
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/simplekey.cpp
// Function: YAML::Scanner::SimpleKey::Validate()
void Scanner::SimpleKey::Validate()
	{
		if(pMapStart)
			pMapStart->status = TS_VALID;
		if(pKey)
			pKey->status = TS_VALID;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3038d
movl $0x0, (%rax)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x3039c
movl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/simplekey.cpp
// Function: YAML::Scanner::SimpleKey::Invalidate()
void Scanner::SimpleKey::Invalidate()
	{
		if(pMapStart)
			pMapStart->status = TS_INVALID;
		if(pKey)
			pKey->status = TS_INVALID;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x303b1
movl $0x1, (%rax)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x303c0
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/simplekey.cpp
// Function: YAML::Scanner::InsertSimpleKey()
void Scanner::InsertSimpleKey()
	{
		SimpleKey key(INPUT.pos(), INPUT.line, INPUT.column, m_flowLevel);

		// first add a map start, if necessary
		key.pMapStart = PushIndentTo(INPUT.column, false);
		if(key.pMapStart)
			key.pMapStart->status = TS_UNVERIFIED;

		// then add the (now unverified) key
		m_tokens.push(Token(TT_KEY, INPUT.line, INPUT.column));
		key.pKey = &m_tokens.back();
		key.pKey->status = TS_UNVERIFIED;

		m_simpleKeys.push(key);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x308d0
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %esi
movl 0x64(%rbx), %edx
movl %eax, -0x38(%rbp)
movl %ecx, -0x34(%rbp)
movl %esi, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x28(%rbp)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2c6cc
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x3040c
movl $0x2, (%rax)
leaq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rax
movabsq $0xc00000000, %rcx      # imm = 0xC00000000
leaq -0x60(%rbp), %r15
movq %rcx, -0x20(%r15)
movq %rax, -0x18(%r15)
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq -0x80(%rbp), %rsi
callq 0x2d2dc
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x27ca8
movq -0x20(%r14), %rdi
cmpq %r15, %rdi
je 0x3046e
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x52e0
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
jne 0x30485
movq 0x58(%rbx), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
leaq -0x48(%rax), %rcx
movq %rcx, -0x20(%rbp)
movl $0x2, -0x48(%rax)
movq 0xa0(%rbx), %rax
movq 0xb0(%rbx), %rcx
addq $-0x20, %rcx
cmpq %rcx, %rax
je 0x304c4
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x20, 0xa0(%rbx)
jmp 0x304d4
addq $0x70, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x3065c
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x27a7c
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/simplekey.cpp
// Function: YAML::Scanner::VerifySimpleKey(bool)
bool Scanner::VerifySimpleKey(bool force)
	{
		m_isLastKeyValid = false;
		if(m_simpleKeys.empty())
			return m_isLastKeyValid;

		// grab top key
		SimpleKey key = m_simpleKeys.top();

		// only validate if we're in the correct flow level
		if(key.flowLevel != m_flowLevel) {
			if(force)
				m_simpleKeys.pop();
			return false;
		}

		m_simpleKeys.pop();

		bool isValid = true;

		// needs to be followed immediately by a value
		if(m_flowLevel > 0 && !Exp::ValueInFlow.Matches(INPUT))
			isValid = false;
		if(m_flowLevel == 0 && !Exp::Value.Matches(INPUT))
			isValid = false;

		// also needs to be less than 1024 characters and inline
		if(INPUT.line != key.line || INPUT.pos() - key.pos > 1024)
			isValid = false;

		// invalidate key
		if(isValid)
			key.Validate();
		else
			key.Invalidate();

		// In block style, remember that we've pushed an indent for this potential simple key (if it was starting).
		// If it was invalid, then we need to pop it off.
		// Note: we're guaranteed to be popping the right one (i.e., there couldn't have been anything in
		//       between) since keys have to be inline, and will be invalidated immediately on a newline.
		if(!isValid && m_flowLevel == 0)
			m_indents.pop();

		m_isLastKeyValid = isValid;
		return isValid;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x0, 0x68(%rdi)
movq 0xa0(%rdi), %rax
cmpq 0x80(%rdi), %rax
je 0x30579
movq %rdi, %rbx
cmpq 0xa8(%rdi), %rax
jne 0x30532
movq 0xb8(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
leaq 0x70(%rbx), %rdi
movl -0x14(%rax), %ecx
cmpl 0x64(%rbx), %ecx
jne 0x3056f
movl -0x20(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movl -0x1c(%rax), %r13d
movq -0x10(%rax), %r12
movq -0x8(%rax), %r15
callq 0x30878
cmpl $0x0, 0x64(%rbx)
jle 0x30581
leaq 0x1269e(%rip), %rdi     # 0x42c00
movq %rbx, %rsi
callq 0x2a482
movl %eax, %r14d
jmp 0x30584
testb %sil, %sil
je 0x30579
callq 0x30878
xorl %r14d, %r14d
jmp 0x3060c
movb $0x1, %r14b
cmpl $0x0, 0x64(%rbx)
jne 0x305a6
leaq 0x1263f(%rip), %rdi     # 0x42bd0
movq %rbx, %rsi
callq 0x2a482
movzbl %r14b, %ecx
xorl %r14d, %r14d
testb %al, %al
cmovnel %ecx, %r14d
cmpl %r13d, 0x8(%rbx)
jne 0x305be
movq %rbx, %rdi
callq 0x308d0
subl -0x2c(%rbp), %eax
cmpl $0x401, %eax            # imm = 0x401
jl 0x305c1
xorl %r14d, %r14d
testb %r14b, %r14b
je 0x305d7
testq %r12, %r12
je 0x305d3
movl $0x0, (%r12)
xorl %eax, %eax
jmp 0x305e9
testq %r12, %r12
je 0x305e4
movl $0x1, (%r12)
movl $0x1, %eax
testq %r15, %r15
je 0x305f1
movl %eax, (%r15)
testb %r14b, %r14b
jne 0x30608
cmpl $0x0, 0x64(%rbx)
jne 0x30608
leaq 0xc0(%rbx), %rdi
callq 0x2d5ce
movb %r14b, 0x68(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/stream.cpp
// Function: YAML::Stream::get()
char Stream::get()
	{
		char ch = input.get();
		column++;
		if(ch == '\n') {
			column = 0;
			line++;
		}
		return ch;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x53a0
incl 0xc(%rbx)
cmpb $0xa, %al
jne 0x30926
movl $0x0, 0xc(%rbx)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mhe[P]raytracerframework_cpp/yaml/stream.cpp
// Function: YAML::Stream::get[abi:cxx11](int)
std::string Stream::get(int n)
	{
		std::string ret;
		for(int i=0;i<n;i++)
			ret += get();
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x30971
movl %edx, %r14d
movq %rsi, %r15
movq %r15, %rdi
callq 0x30904
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5290
decl %r14d
jne 0x30959
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x30994
movq (%r12), %rsi
incq %rsi
callq 0x52e0
movq %r14, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/Albuso0[P]support/./commandline.h
// Function: void std::CommandLine::AddValue<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&)
void CommandLine::AddValue (const std::string &name, const std::string &help, T &value)
	{
		UserItem<T> *item = new UserItem<T> ();
		item->m_name = name;
		item->m_help = help;
		item->m_valuePtr = &value;
     
		m_items.push_back (item);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x50, %edi
callq 0x3220
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x8(%rax), %rdi
addq $0x18, %rax
movq %rax, 0x8(%r15)
xorl %eax, %eax
movq %rax, 0x10(%r15)
movb %al, 0x18(%r15)
leaq 0x28(%r15), %rbp
leaq 0x38(%r15), %rcx
movq %rcx, 0x28(%r15)
movq %rax, 0x30(%r15)
movb %al, 0x38(%r15)
leaq 0x40f1(%rip), %rax      # 0x8cc0
movq %rax, (%r15)
movq %r13, %rsi
callq 0x3110
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3110
movq %r14, 0x48(%r15)
movl $0x18, %edi
callq 0x3220
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3050
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop