LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x1f486
decl %eax
movl %eax, 0x64(%rbx)
xorl %r14d, %r14d
movb %r14b, 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
callq 0x2173c
xorl %ecx, %ecx
cmpb $0x5d, %al
setne %cl
leaq -0x40(%rbp), %rax
andl $0x0, -0x20(%rax)
addl $0x9, %ecx
movl %ecx, -0x1c(%rax)
movq %r15, -0x18(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
addq $0x10, %rbx
movb %r14b, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x60(%rbp), %rdi
callq 0x19892
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x14192(%rip), %rcx     # 0x33630
movq %rax, %rdi
callq 0x18be0
leaq 0xe193(%rip), %rsi      # 0x2d640
leaq -0xf8e2(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x1f4d5
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movb $0x1, 0x62(%rdi)
movq 0x8(%rdi), %r14
pushq $0x1
popq %rsi
callq 0x217c8
movabsq $0xb00000000, %rax      # imm = 0xB00000000
leaq -0x38(%rbp), %rcx
movq %rax, -0x20(%rcx)
movq %r14, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
addq $0x10, %rbx
movb $0x0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x58(%rbp), %rdi
callq 0x19892
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f5fb
cmpb $0x0, 0x62(%rbx)
je 0x1f61d
movl 0xc(%rbx), %esi
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %edx
callq 0x1da46
movb $0x1, 0x62(%rbx)
movq 0x8(%rbx), %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x217c8
movabsq $0x600000000, %rax      # imm = 0x600000000
leaq -0x40(%rbp), %rcx
movq %rax, -0x20(%rcx)
movq %r15, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
addq $0x10, %rbx
movb $0x0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x60(%rbp), %rdi
callq 0x19892
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x1403d(%rip), %rcx     # 0x33650
movq %rax, %rdi
callq 0x18be0
jmp 0x1f63d
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x1401b(%rip), %rcx     # 0x33650
movq %rax, %rdi
callq 0x18be0
leaq 0xdffc(%rip), %rsi      # 0x2d640
leaq -0xfa79(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
jmp 0x1f655
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x1f66e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x64(%rdi)
jne 0x1f6a3
cmpb $0x0, 0x62(%rbx)
je 0x1f70c
movl 0xc(%rbx), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1da46
cmpl $0x0, 0x64(%rbx)
je 0x1f706
movb $0x0, 0x62(%rbx)
movq 0x8(%rbx), %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x217c8
movabsq $0xc00000000, %rax      # imm = 0xC00000000
leaq -0x38(%rbp), %rcx
movq %rax, -0x20(%rcx)
movq %r14, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
addq $0x10, %rbx
movb $0x0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x58(%rbp), %rdi
callq 0x19892
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, 0x62(%rbx)
jmp 0x1f6a7
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13f4c(%rip), %rcx     # 0x33670
movq %rax, %rdi
callq 0x18be0
leaq 0xdf0d(%rip), %rsi      # 0x2d640
leaq -0xfb68(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x1f75b
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/scantoken.cpp
// Function: YAML::Scanner::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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x68(%rdi)
je 0x1f797
cmpl $0x0, 0x64(%rbx)
jne 0x1f797
cmpb $0x0, 0x62(%rbx)
je 0x1f800
movl 0xc(%rbx), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1da46
cmpl $0x0, 0x64(%rbx)
je 0x1f7fa
movb $0x0, 0x62(%rbx)
movq 0x8(%rbx), %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x217c8
movabsq $0xd00000000, %rax      # imm = 0xD00000000
leaq -0x38(%rbp), %rcx
movq %rax, -0x20(%rcx)
movq %r14, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
addq $0x10, %rbx
movb $0x0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e800
leaq -0x58(%rbp), %rdi
callq 0x19892
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, 0x62(%rbx)
jmp 0x1f79b
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x13e78(%rip), %rcx     # 0x33690
movq %rax, %rdi
callq 0x18be0
leaq 0xde19(%rip), %rsi      # 0x2d640
leaq -0xfc5c(%rip), %rdx     # 0xfbd2
movq %r14, %rdi
callq 0x44f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x1f84f
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20994
movq %r14, %rdi
callq 0x1d548
movl 0x4(%rax), %eax
cmpl $0x7, %eax
je 0x20ace
cmpl $0x6, %eax
je 0x20ab6
cmpl $0x3, %eax
jne 0x20ae6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20af2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20c5e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20cf8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/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 $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1d516
addq $0x8, %r15
leaq -0x78(%rbp), %r12
movq %r14, %rdi
callq 0x1d4b4
testb %al, %al
jne 0x20bb0
movq %r14, %rdi
callq 0x1d548
movq %r12, %rdi
movq %rax, %rsi
callq 0x197a8
movl -0x74(%rbp), %eax
addl $-0x7, %eax
cmpl $-0x3, %eax
jbe 0x20be5
movq %r14, %rdi
callq 0x1d516
cmpl $0x5, -0x74(%rbp)
je 0x20b98
pushq $0x58
popq %rdi
callq 0x42a0
movq %rax, %r13
movq %rax, %rdi
callq 0x19ec2
movq %r13, -0x30(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0x20fca
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19f44
movq %r12, %rdi
callq 0x19892
jmp 0x20b1c
leaq -0x78(%rbp), %rdi
callq 0x19892
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
leaq 0x1317e(%rip), %rcx     # 0x33d40
pushq $-0x1
popq %rdx
movq %rax, %rdi
movl %edx, %esi
callq 0x18be0
leaq 0xca6a(%rip), %rsi      # 0x2d640
leaq -0x1100b(%rip), %rdx    # 0xfbd2
movq %r14, %rdi
callq 0x44f0
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl -0x70(%rbp), %esi
movl -0x6c(%rbp), %edx
leaq 0x13143(%rip), %rcx     # 0x33d40
movq %rax, %rdi
callq 0x18be0
leaq 0xca34(%rip), %rsi      # 0x2d640
leaq -0x11041(%rip), %rdx    # 0xfbd2
movq %r14, %rdi
callq 0x44f0
jmp 0x20c49
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x20c4c
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x20c55
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r13, %rdi
callq 0x42b0
jmp 0x20c4c
jmp 0x20c49
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
leaq -0x30(%rbp), %r13
movq %r14, %rdi
callq 0x1d4b4
testb %al, %al
jne 0x20cd2
movq %r14, %rdi
callq 0x1d548
cmpl $0x6, 0x4(%rax)
jne 0x20cd2
movq %r14, %rdi
callq 0x1d516
pushq $0x58
popq %rdi
callq 0x42a0
movq %rax, %r12
movq %rax, %rdi
callq 0x19ec2
movq %r12, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x20fca
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19f44
jmp 0x20c7d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/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 0x1d516
addq $0x8, %r15
leaq -0x30(%rbp), %r13
movq %rbx, %rdi
callq 0x1d4b4
testb %al, %al
jne 0x20da3
movq %rbx, %rdi
callq 0x1d548
cmpl $0x9, 0x4(%rax)
je 0x20d8c
pushq $0x58
popq %rdi
callq 0x42a0
movq %rax, %r12
movq %rax, %rdi
callq 0x19ec2
movq %r12, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x20fca
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x19f44
movq %rbx, %rdi
callq 0x1d548
movq %rax, %r12
movl 0x4(%rax), %eax
cmpl $0x9, %eax
je 0x20d1f
cmpl $0xb, %eax
jne 0x20dc4
movq %rbx, %rdi
callq 0x1d516
jmp 0x20d1f
movq %rbx, %rdi
callq 0x1d516
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
leaq 0x12fab(%rip), %rcx     # 0x33d60
pushq $-0x1
popq %rdx
movq %rax, %rdi
movl %edx, %esi
callq 0x18be0
jmp 0x20de8
pushq $0x30
popq %rdi
callq 0x4130
movq %rax, %r14
movl 0x8(%r12), %esi
movl 0xc(%r12), %edx
leaq 0x12f80(%rip), %rcx     # 0x33d60
movq %rax, %rdi
callq 0x18be0
leaq 0xc851(%rip), %rsi      # 0x2d640
leaq -0x11224(%rip), %rdx    # 0xfbd2
movq %r14, %rdi
callq 0x44f0
jmp 0x20e00
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x20e1b
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/mhe[P]raytracerframework_cpp/yaml/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 $0x18, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r13
movl %ecx, -0x38(%rbp)
movl %ecx, %eax
xorb $0x1, %al
movl %r8d, -0x30(%rbp)
orb %r8b, %al
movb %al, -0x29(%rbp)
jne 0x20e60
leaq 0x1e93(%rip), %rsi      # 0x22ceb
movq %rbx, %rdi
callq 0x4280
leal 0x1(%r14), %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
movq %r14, -0x40(%rbp)
leaq 0x1f7a(%rip), %r12      # 0x22df5
movl %eax, %r15d
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x20f02
cmpb $0x0, -0x38(%rbp)
je 0x20ea8
testq %r15, %r15
sete %al
testb %al, -0x30(%rbp)
je 0x20ead
jmp 0x20ec7
testq %r15, %r15
je 0x20ec7
movq -0x40(%rbp), %rax
movl %eax, %r14d
subl $0x1, %r14d
jb 0x20ec7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4280
jmp 0x20eb4
movq %rbx, %rdi
leaq 0x20d4(%rip), %rsi      # 0x22fa5
callq 0x4280
movq 0x8(%r13), %rax
movq (%rax,%r15,8), %rdi
testq %r15, %r15
setne %al
orb -0x29(%rbp), %al
movzbl %al, %r8d
movq %rbx, %rsi
movl -0x34(%rbp), %edx
pushq $0x1
popq %rcx
callq 0x1a324
leal 0x1(%r15), %eax
jmp 0x20e7b
cmpq %rcx, %rax
je 0x20f16
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1dce(%rip), %rsi      # 0x22ceb
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
shrq $0x3, %rax
movq 0x10(%rsi), %rcx
subq 0x8(%rsi), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jae 0x20f7c
pushq $-0x1
jmp 0x20f80
jbe 0x20f94
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
movl %eax, %r12d
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x20f82
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rsi
callq 0x1a93e
incq %r13
testl %eax, %eax
je 0x20fa3
movl %eax, %r15d
jmp 0x20f82
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x211d2
andl $0x0, (%rax)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x211de
andl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x211f3
movl $0x1, (%rax)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x21202
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x21708
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %esi
movl 0x64(%rbx), %edx
movl %eax, -0x28(%rbp)
movl %ecx, -0x24(%rbp)
movl %esi, -0x20(%rbp)
movl %edx, -0x1c(%rbp)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1da46
movq %rax, -0x18(%rbp)
testq %rax, %rax
je 0x21243
movl $0x2, (%rax)
movq 0x8(%rbx), %rax
movabsq $0xc00000000, %rcx      # imm = 0xC00000000
leaq -0x50(%rbp), %rdx
movq %rcx, -0x20(%rdx)
movq %rax, -0x18(%rdx)
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
leaq 0x10(%rbx), %rdi
movb $0x0, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
andq $0x0, 0x20(%rdx)
leaq -0x70(%rbp), %rsi
callq 0x1e800
leaq -0x70(%rbp), %rdi
callq 0x19892
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
jne 0x212a2
movq 0x58(%rbx), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
leaq -0x48(%rax), %rcx
leaq -0x28(%rbp), %rsi
movq %rcx, 0x18(%rsi)
movl $0x2, -0x48(%rax)
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x21436
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x19892
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/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:
movb $0x0, 0x68(%rdi)
movq 0xa0(%rdi), %rax
cmpq 0x80(%rdi), %rax
je 0x2135b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq 0xa8(%rdi), %rax
jne 0x2131a
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 0x2135e
movl -0x20(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movl -0x1c(%rax), %r13d
movq -0x10(%rax), %r12
movq -0x8(%rax), %r15
callq 0x216a0
movl 0x64(%rbx), %eax
testl %eax, %eax
jle 0x2136c
leaq 0x138a5(%rip), %rdi     # 0x34bf0
movq %rbx, %rsi
callq 0x1beee
movl %eax, %r14d
movl 0x64(%rbx), %eax
jmp 0x2136f
xorl %eax, %eax
retq
testb %sil, %sil
je 0x21368
callq 0x216a0
xorl %eax, %eax
jmp 0x213db
movb $0x1, %r14b
testl %eax, %eax
jne 0x2138f
leaq 0x13846(%rip), %rdi     # 0x34bc0
movq %rbx, %rsi
callq 0x1beee
movzbl %r14b, %ecx
xorl %r14d, %r14d
testb %al, %al
cmovnel %ecx, %r14d
cmpl %r13d, 0x8(%rbx)
jne 0x213a7
movq %rbx, %rdi
callq 0x21708
subl -0x2c(%rbp), %eax
cmpl $0x400, %eax            # imm = 0x400
jle 0x213ea
xorl %r14d, %r14d
testq %r12, %r12
je 0x213b7
movl $0x1, (%r12)
testq %r15, %r15
je 0x213c3
movl $0x1, (%r15)
cmpl $0x0, 0x64(%rbx)
jne 0x213d5
leaq 0xc0(%rbx), %rdi
callq 0x1eae4
xorl %eax, %eax
movb %r14b, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %r14b, %r14b
je 0x213aa
testq %r12, %r12
je 0x213f9
andl $0x0, (%r12)
movb $0x1, %al
testq %r15, %r15
je 0x213d7
andl $0x0, (%r15)
jmp 0x213d7
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4360
incl 0xc(%rbx)
cmpb $0xa, %al
jne 0x2175b
andl $0x0, 0xc(%rbx)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r15d, %r15d
testl %edx, %edx
cmovgl %edx, %r15d
subl $0x1, %r15d
jb 0x217a6
movq %r14, %rdi
callq 0x2173c
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4250
jmp 0x2178b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x45d8
movq %r14, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x2210
movq %rax, %r13
xorps %xmm0, %xmm0
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(%r13)
xorl %eax, %eax
movb %al, 0x18(%r13)
leaq 0x28(%r13), %rbp
leaq 0x38(%r13), %rcx
movq %rcx, 0x28(%r13)
movb %al, 0x38(%r13)
leaq 0x43c2(%rip), %rax      # 0x7cc8
movq %rax, (%r13)
movq %r12, %rsi
callq 0x2120
movq %rbp, %rdi
movq %r15, %rsi
callq 0x2120
movq %r14, 0x48(%r13)
movq %rsp, %rsi
movq %r13, (%rsi)
movq %rbx, %rdi
callq 0x3b18
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]support/./commandline.h
// Function: std::CommandLine::UserItem<double>::Parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CommandLine::UserItem<T>::Parse (const std::string value)
	{
		std::string src = value;
		std::transform(src.begin(), src.end(), src.begin(), ::tolower);
		std::istringstream iss;
		iss.str (src);
		iss >> (*m_valuePtr);
		return !iss.bad () && !iss.fail ();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2290
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x3b7a
movsbl (%r15,%r12), %edi
callq 0x22c0
movb %al, (%r15,%r12)
incq %r12
jmp 0x3b62
leaq 0x28(%rsp), %rdi
callq 0x2180
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x22e0
movq 0x48(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2150
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
sete %bl
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x3be7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/src/annotate.cpp
// Function: qStartSort(BamTools::BamAlignment, BamTools::BamAlignment)
bool qStartSort(const BamAlignment L,
                const BamAlignment R ){

    int  lp;
    int  rp;

    if(!L.GetTag<int>( "QS", lp )){
        exit(1);
    }
    if(!R.GetTag<int>( "QS", rp )){
        exit(1);
    }

    if(lp < rp){
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x26bef(%rip), %rsi     # 0x2f020
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x966e
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x58f8
testb %bpl, %bpl
je 0x84af
leaq 0x26bb6(%rip), %rsi     # 0x2f020
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x966e
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x58f8
testb %bl, %bl
je 0x84af
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
setl %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x5550
jmp 0x84bb
jmp 0x84ca
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x58f8
jmp 0x84cd
movq %rax, %rbx
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/src/annotate.cpp
// Function: loadFai(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, long>>>&)
bool loadFai(std::string & fastaName,
             std::map<std::string, long int> & dat)
{
    std::string fai = fastaName + ".fai";
    std::string line;
    std::ifstream myfile (fai);

    if(myfile){
        while(getline(myfile, line)){
            std::vector<std::string> splitDat = split(line, "\t");
            if(splitDat.size() < 2){
                return false;
            }
            dat[splitDat[0]] = atol(splitDat[1].c_str());
        }
    }
    else{
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x26030(%rip), %rdx     # 0x2f0ab
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x9b27
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x80(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x5720
movq 0x80(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0xa0(%rsp,%rax)
jne 0x9162
leaq 0x20(%rsp), %r15
leaq 0x60(%rsp), %r13
leaq 0x8(%rsp), %r12
leaq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0x50c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x9154
movq %r13, %rdi
leaq 0x26782(%rip), %rsi     # 0x2f87f
leaq 0x7(%rsp), %rdx
callq 0x96f2
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xd5a4
movq %r13, %rdi
callq 0x58f8
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %rax
subq %r14, %rax
cmpq $0x20, %rax
jbe 0x9158
movq 0x20(%r14), %rdi
callq 0x5540
movq %rax, %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x98f2
movq %rbp, (%rax)
movq %r12, %rdi
callq 0x9b60
jmp 0x90d5
movb $0x1, %bl
jmp 0x9164
leaq 0x8(%rsp), %rdi
callq 0x9b60
xorl %ebx, %ebx
leaq 0x80(%rsp), %rdi
callq 0x5100
leaq 0x20(%rsp), %rdi
callq 0x58f8
leaq 0x40(%rsp), %rdi
callq 0x58f8
movl %ebx, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x91ce
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9b60
jmp 0x91c1
jmp 0x91be
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x58f8
jmp 0x91c1
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x5100
leaq 0x20(%rsp), %rdi
callq 0x58f8
leaq 0x40(%rsp), %rdi
callq 0x58f8
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/src/chain.cpp
// Function: chain::addAlignment(int, int, int)
bool chain::addAlignment(int s, int e, int m){

    node * n = new node;
    n->matches      = double(m);
    n->overallScore = double(m);
    n->start        = s;
    n->end          = e;
    n->index        = current_index;

    nodes.push_back(n);

    current_index++;

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x38
popq %rdi
callq 0x5450
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movq %rsp, %rsi
cvtsi2sd %ebx, %xmm0
movq %rax, (%rsi)
movsd %xmm0, (%rax)
movsd %xmm0, 0x8(%rax)
movl %r14d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movl (%r15), %ecx
movl %ecx, 0x18(%rax)
leaq 0x10(%r15), %rdi
callq 0xbe04
incl (%r15)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/src/chain.cpp
// Function: chain::buildLinks()
bool chain::buildLinks(void){

    // sorted by end position
    sort(nodes.begin(), nodes.end(), _endCmp);
    // adding sink
    addAlignment(nodes.back()->end + 1, nodes.back()->end +2, 0);

    for(int i = 1 ; i < nodes.size() ; i++){

        double maxScore = 0;
        for(int j = i - 1; j >= 0; j--){
            if(nodes[j]->end <= nodes[i]->start){
                double tmp_score = nodes[j]->overallScore ;
                if(tmp_score > maxScore){
                    maxScore = tmp_score;
                }
                nodes[i]->children.push_back(nodes[j]);
            }
        }
        nodes[i]->overallScore += maxScore;
    }

    last = nodes.back();

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
leaq -0xb9(%rip), %rdx       # 0xbb72
callq 0xbfb7
movq 0x18(%rbx), %rax
movq -0x8(%rax), %rax
movl 0x14(%rax), %edx
leal 0x1(%rdx), %esi
addl $0x2, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xbb14
movq 0x10(%rbx), %rax
pushq $0x1
popq %r14
movq 0x18(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0xbcc4
xorpd %xmm0, %xmm0
movq %r14, %r15
movq 0x10(%rbx), %rax
leaq (%rax,%r15,8), %rsi
testq %r15, %r15
jle 0xbcb1
decq %r15
movq -0x8(%rsi), %rcx
addq $-0x8, %rsi
movl 0x14(%rcx), %edx
movq (%rax,%r14,8), %rdi
cmpl 0x10(%rdi), %edx
jg 0xbc75
movsd 0x8(%rcx), %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
addq $0x20, %rdi
callq 0xbe04
movsd 0x8(%rsp), %xmm0
jmp 0xbc6d
movq (%rax,%r14,8), %rcx
addsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rcx)
incq %r14
jmp 0xbc53
movq -0x8(%rcx), %rax
movq %rax, 0x8(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/src/chain.cpp
// Function: chain::traceback(std::vector<int, std::allocator<int>>&)
bool chain::traceback(std::vector<int> & alns){

    if(last != nodes.front() && last != nodes.back() ){
        alns.push_back(last->index);
    }

    if( last->children.empty() ){
        return false;
    }

    double max = last->children.front()->overallScore;
    node * current = last->children.front();

    for(std::vector<node *>::iterator it = last->children.begin();
        it != last->children.end(); it++){

        if((*it)->overallScore > max ){

            max       = (*it)->overallScore;
            current   =  *it ;
        }
    }



    std::cerr << "  best child : "
              << " " << current->index
              << " " << current->start
              << " " << current->end
              << " " << current->matches
              << " " << current->overallScore
              << std::endl;




    last = current;

    return traceback(alns);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rbp
movq 0x3f2fc(%rip), %r15     # 0x4aff0
leaq 0x2345a(%rip), %r12     # 0x2f155
leaq 0x24942(%rip), %r13     # 0x30644
movq 0x10(%r14), %rax
cmpq (%rax), %rbp
je 0xbd28
movq 0x18(%r14), %rax
cmpq -0x8(%rax), %rbp
je 0xbd28
addq $0x18, %rbp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xbe22
movq 0x8(%r14), %rbp
movq 0x20(%rbp), %rax
movq 0x28(%rbp), %rcx
cmpq %rcx, %rax
je 0xbdf2
movq (%rax), %rbp
movsd 0x8(%rbp), %xmm0
cmpq %rcx, %rax
je 0xbd64
movq (%rax), %rdx
movsd 0x8(%rdx), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rdx, %rbp
maxsd %xmm0, %xmm1
addq $0x8, %rax
movapd %xmm1, %xmm0
jmp 0xbd41
movq %r15, %rdi
movq %r12, %rsi
callq 0x5430
movq %rax, %rdi
movq %r13, %rsi
callq 0x5430
movl 0x18(%rbp), %esi
movq %rax, %rdi
callq 0x57b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x5430
movl 0x10(%rbp), %esi
movq %rax, %rdi
callq 0x57b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x5430
movl 0x14(%rbp), %esi
movq %rax, %rdi
callq 0x57b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x5430
movsd (%rbp), %xmm0
movq %rax, %rdi
callq 0x5710
movq %rax, %rdi
movq %r13, %rsi
callq 0x5430
movsd 0x8(%rbp), %xmm0
movq %rax, %rdi
callq 0x5710
movq %rax, %rdi
callq 0x51f0
movq %rbp, 0x8(%r14)
jmp 0xbd02
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/src/errors.cpp
// Function: errorHandler::errorHandler()
errorHandler::errorHandler(void){

    usage_statement = "usage: contigSV annotate";

    error_message.push_back( std::string("FATAL: Could not open bam file.")              );
    error_message.push_back( std::string("FATAL: Could not open bam index.")             );
    error_message.push_back( std::string("FATAL: Could not read bam file - or no reads."));
    error_message.push_back( std::string("FATAL: Bad command line option."              ));
    error_message.push_back( std::string("FATAL: BAM not annotated."                    ));
    error_message.push_back(usage_statement                                              );
    error_message.push_back( std::string("FATAL: Could not read *.fai"                  ));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movb $0x0, 0x40(%rdi)
leaq 0x229a5(%rip), %rsi     # 0x2f165
movq %r14, %rdi
callq 0x5870
leaq 0x229af(%rip), %rsi     # 0x2f17e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xca14
leaq 0x8(%rsp), %rdi
callq 0x58f8
leaq 0x229a2(%rip), %rsi     # 0x2f19e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xca14
leaq 0x8(%rsp), %rdi
callq 0x58f8
leaq 0x22996(%rip), %rsi     # 0x2f1bf
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xca14
leaq 0x8(%rsp), %rdi
callq 0x58f8
leaq 0x22997(%rip), %rsi     # 0x2f1ed
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xca14
leaq 0x8(%rsp), %rdi
callq 0x58f8
leaq 0x2298a(%rip), %rsi     # 0x2f20d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xca14
leaq 0x8(%rsp), %rdi
callq 0x58f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc9e8
leaq 0x2296c(%rip), %rsi     # 0x2f227
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xca14
leaq 0x8(%rsp), %rdi
callq 0x58f8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xc901
jmp 0xc912
jmp 0xc901
jmp 0xc912
jmp 0xc901
jmp 0xc912
jmp 0xc901
jmp 0xc912
jmp 0xc901
jmp 0xc912
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x58f8
jmp 0xc915
jmp 0xc912
movq %rax, %r15
leaq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0x58f8
movq %r12, %rdi
callq 0x9b60
movq %rbx, %rdi
callq 0x9b60
movq %r15, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/src/split.hpp
// Function: void tokenize<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void tokenize(const std::string& str, ContainerT& tokens,
              const std::string& delimiters = " ", const bool trimEmpty = false)
{

    std::string::size_type pos, lastPos = 0;
    while(true)
    {
	pos = str.find_first_of(delimiters, lastPos);
	if(pos == std::string::npos)
	{

	    pos = str.length();

	    if(pos != lastPos || !trimEmpty) {
		tokens.push_back(typename ContainerT::value_type(str.data()+lastPos, (typename ContainerT::value_type::size_type)pos-lastPos));
	    }

	    break;
	}
	else
	{
	    if(pos != lastPos || !trimEmpty) {
		tokens.push_back(typename ContainerT::value_type(str.data()+lastPos, (typename ContainerT::value_type::size_type)pos-lastPos));
	    }
	}

	lastPos = pos + 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x53c0
cmpq $-0x1, %rax
je 0xd674
movq %rax, %r13
cmpq %rbx, %rax
sete %al
testb %bpl, %al
jne 0xd66c
movq (%r14), %rdx
addq %rdx, %rbx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq %r13, %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x9d7a
movq (%rsp), %rdi
movq %r12, %rsi
callq 0xca14
movq %r12, %rdi
callq 0x58f8
incq %r13
movq %r13, %rbx
jmp 0xd618
movq 0x8(%r14), %rdx
cmpq %rbx, %rdx
sete %al
testb %bpl, %al
jne 0xd6b9
movq (%r14), %rax
addq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movq %rcx, (%rdi)
addq %rax, %rdx
movq %rbx, %rsi
callq 0x9d7a
leaq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0xca14
leaq 0x8(%rsp), %rdi
callq 0x58f8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd6d1
jmp 0xd6cc
movq %rax, %rbx
jmp 0xd6de
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x58f8
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O2/BartMassey[P]ancient-raytracer/render.cc
// Function: trace(ray, model&, int)
point trace( ray r, model &m, int depth ) {
  object *p, *current = 0;
  intersection s, sb;

  if( depth > m.maxdepth ) {
    point value( m.bg );
    
    value.dilate(0);
    return value;
  }
  // find an object struct by the ray
  for( p = &m.scene; p; p = p->next() )
    if( p->intersect( r, s ) ) {
	sb = s;
	current = p;
	break;
    }
  if (!current) {
    point value( m.bg );
    
    value.dilate(0);
    return value;
  }
  // if there are other intersections,
  // choose the nearest
  for( p = p->next(); p; p = p->next() )
    if( p->intersect( r, s ) && s.t < sb.t ) {
      delete sb.normal;
      delete sb.at;
      sb = s;
      current = p;
    }
  // determine the pixel value
  point nr(r.at( sb.t ));
  point value( (current->get_texture()).value(
   *sb.at, nr, *sb.normal, m, depth + 1 ) );

  delete sb.normal;
  delete sb.at;
  value.dilate(1);
  return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r14
movq %rdi, %rbp
cmpl %ecx, 0x20(%rdx)
jge 0x22fc
movq 0x18(%r14), %rsi
movq %rbp, %rdi
callq 0x2808
xorps %xmm0, %xmm0
jmp 0x2463
movq %rsi, %r15
movl %ecx, 0x24(%rsp)
movq 0x10(%r14), %rbx
leaq 0xb0(%rsp), %r12
leaq 0x30(%rsp), %r13
testq %rbx, %rbx
je 0x22e8
movq %r12, %rdi
movq %r15, %rsi
callq 0x286e
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x28(%rax)
testl %eax, %eax
jne 0x2345
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq %rax, %rbx
jmp 0x2314
movq %rbp, 0x28(%rsp)
leaq 0x30(%rsp), %r13
movq 0x8(%r13), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%r13), %rax
movq %rax, 0x18(%rsp)
leaq 0x68(%rsp), %rbp
movq %rbx, %r12
movss 0x30(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
testq %rax, %rax
je 0x23ef
movq %rax, %r12
movq %rbp, %rdi
movq %r15, %rsi
callq 0x286e
movq (%r12), %rax
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq *0x28(%rax)
testl %eax, %eax
je 0x2375
movss 0xc(%rsp), %xmm0
ucomiss 0x30(%rsp), %xmm0
jbe 0x2375
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23c3
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x23d3
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r12, %rbx
jmp 0x2369
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movss 0xc(%rsp), %xmm0
callq 0x28ae
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movl 0x24(%rsp), %ecx
incl %ecx
movq (%rax), %r10
movl %ecx, (%rsp)
movq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rbx
movq %rbx, %rdx
movq %r12, %rcx
movq 0x10(%rsp), %r15
movq %r15, %r8
movq %r14, %r9
callq *0x18(%r10)
testq %r15, %r15
je 0x244d
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testq %rbx, %rbx
je 0x245b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movss 0x3ba1(%rip), %xmm0     # 0x6004
movq %rbp, %rdi
callq 0x2836
movq %rbp, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::point(point const&)
inline point::point( const point &p ) {
  int i;

  nc = p.nc;
  for( i = 0; i < nc; i++ )
    c[i] = p.c[i];
}

// Assembly:
leaq 0x7039(%rip), %rax      # 0x9848
movq %rax, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x2835
movss 0xc(%rsi,%rcx,4), %xmm0
movss %xmm0, 0xc(%rdi,%rcx,4)
incq %rcx
jmp 0x281f
retq
// File: /workspace/github_cpp_makefile_star2_O2/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::operator*(point)
inline float point::operator* ( point p ) {
  int i;
  float r;
  
  assert( nc == p.nc );
  r = 0.0;
  for( i = 0; i < nc ; i++ )
    r += c[i] * p.c[i];
  return r;
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x29c5
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorps %xmm0, %xmm0
cmpq %rcx, %rax
je 0x29c4
movss 0xc(%rdi,%rcx,4), %xmm1
mulss 0xc(%rsi,%rcx,4), %xmm1
addss %xmm1, %xmm0
incq %rcx
jmp 0x29aa
retq
pushq %rax
leaq 0x36f3(%rip), %rdi      # 0x60c0
leaq 0x36c2(%rip), %rsi      # 0x6096
leaq 0x36f0(%rip), %rcx      # 0x60cb
pushq $0x4f
popq %rdx
callq 0x2070
nop
// File: /workspace/github_cpp_makefile_star2_O2/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::operator+=(point)
inline void point::operator+= ( point p ) {
  int i;
  
  assert( nc == p.nc );
  for( i = 0; i < nc ; i++ )
    c[i] += p.c[i];
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x2ac2
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x2ac1
movss 0xc(%rsi,%rcx,4), %xmm0
addss 0xc(%rdi,%rcx,4), %xmm0
movss %xmm0, 0xc(%rdi,%rcx,4)
incq %rcx
jmp 0x2aa5
retq
pushq %rax
leaq 0x35f6(%rip), %rdi      # 0x60c0
leaq 0x35c5(%rip), %rsi      # 0x6096
leaq 0x3619(%rip), %rcx      # 0x60f1
pushq $0x66
popq %rdx
callq 0x2070