LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40510
movq -0x10(%rbp), %rdi
callq 0x40460
testb $0x1, %al
jne 0x4871a
jmp 0x4877d
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
leaq 0x256d8(%rip), %rcx     # 0x6de10
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, %esi
callq 0x340e0
jmp 0x48746
movq -0x90(%rbp), %rdi
leaq 0x1eeac(%rip), %rsi     # 0x67600
leaq -0x1462b(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x488d6
movq -0x10(%rbp), %rdi
callq 0x40550
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x35a00
cmpl $0x6, -0x6c(%rbp)
je 0x48816
cmpl $0x5, -0x6c(%rbp)
je 0x48816
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movl -0x68(%rbp), %esi
movl -0x64(%rbp), %edx
leaq 0x2564e(%rip), %rcx     # 0x6de10
callq 0x340e0
jmp 0x487c9
movq -0x98(%rbp), %rdi
leaq 0x1ee29(%rip), %rsi     # 0x67600
leaq -0x146ae(%rip), %rdx    # 0x34130
callq 0x5690
jmp 0x488df
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x488c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x488c2
movq -0x10(%rbp), %rdi
callq 0x40510
jmp 0x48821
cmpl $0x5, -0x6c(%rbp)
jne 0x48830
movl $0x3, -0x74(%rbp)
jmp 0x4888c
movl $0x58, %edi
callq 0x53b0
movq %rax, -0xa0(%rbp)
jmp 0x48843
movq -0xa0(%rbp), %rdi
callq 0x379f0
jmp 0x48851
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x8, %rdi
leaq -0x80(%rbp), %rsi
callq 0x48f20
jmp 0x48872
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37ad0
jmp 0x48885
movl $0x0, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35c00
movl -0x74(%rbp), %eax
testl %eax, %eax
je 0x488a0
jmp 0x4889e
jmp 0x488cd
jmp 0x4870b
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x53c0
leaq -0x70(%rbp), %rdi
callq 0x35c00
jmp 0x488d6
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x56c0
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40460
testb $0x1, %al
jne 0x4890b
jmp 0x48910
jmp 0x48995
movq -0x10(%rbp), %rdi
callq 0x40550
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, 0x4(%rax)
je 0x48929
jmp 0x48995
movq -0x10(%rbp), %rdi
callq 0x40510
movl $0x58, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x379f0
jmp 0x4894d
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x48f20
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37ad0
jmp 0x488fc
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x53c0
jmp 0x4899b
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40510
movq -0x10(%rbp), %rdi
callq 0x40460
testb $0x1, %al
jne 0x489e4
jmp 0x48a3e
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x25431(%rip), %rcx     # 0x6de30
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, %esi
callq 0x340e0
jmp 0x48a0d
movq -0x48(%rbp), %rdi
leaq 0x1ebe8(%rip), %rsi     # 0x67600
leaq -0x148ef(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x48b52
movq -0x10(%rbp), %rdi
callq 0x40550
cmpl $0x9, 0x4(%rax)
jne 0x48a5b
movq -0x10(%rbp), %rdi
callq 0x40510
jmp 0x48b4c
movl $0x58, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x379f0
jmp 0x48a76
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x48f20
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37ad0
movq -0x10(%rbp), %rdi
callq 0x40550
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0xb, 0x4(%rax)
jne 0x48ae1
movq -0x10(%rbp), %rdi
callq 0x40510
jmp 0x48b47
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x53c0
jmp 0x48b52
movq -0x38(%rbp), %rax
cmpl $0x9, 0x4(%rax)
je 0x48b45
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x25320(%rip), %rcx     # 0x6de30
callq 0x340e0
jmp 0x48b17
movq -0x58(%rbp), %rdi
leaq 0x1eade(%rip), %rsi     # 0x67600
leaq -0x149f9(%rip), %rdx    # 0x34130
callq 0x5690
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x48b52
jmp 0x48b47
jmp 0x489d5
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %cl
movb %cl, -0x15(%rbp)
andb $0x1, %al
movb %al, -0x16(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x15(%rbp)
je 0x48ba5
testb $0x1, -0x16(%rbp)
jne 0x48ba5
movq -0x10(%rbp), %rdi
leaq 0x31d7(%rip), %rsi      # 0x4bd77
callq 0x5390
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x48e40
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x48c92
testb $0x1, -0x15(%rbp)
je 0x48bdc
testb $0x1, -0x16(%rbp)
je 0x48be2
cmpl $0x0, -0x1c(%rbp)
jbe 0x48c0e
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x48c0c
movq -0x10(%rbp), %rdi
leaq 0x3285(%rip), %rsi      # 0x4be81
callq 0x5390
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x48be9
jmp 0x48c0e
movq -0x10(%rbp), %rdi
leaq 0x3431(%rip), %rsi      # 0x4c04a
callq 0x5390
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x48e60
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movb $0x1, %al
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x31(%rbp)
ja 0x48c64
movb $0x1, %al
testb $0x1, -0x15(%rbp)
movb %al, -0x31(%rbp)
je 0x48c64
movb -0x16(%rbp), %al
movb %al, -0x31(%rbp)
movl -0x38(%rbp), %edx
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
movb -0x31(%rbp), %al
movzbl %al, %r8d
andl $0x1, %r8d
movl $0x1, %ecx
callq 0x380c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x48bac
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x48f90
testb $0x1, %al
jne 0x48ca5
jmp 0x48cb5
movq -0x10(%rbp), %rdi
leaq 0x30c7(%rip), %rsi      # 0x4bd77
callq 0x5390
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x48e40
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x48e40
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x48d35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x48db3
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jbe 0x48d46
movl $0x1, -0x4(%rbp)
jmp 0x48db3
jmp 0x48d48
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x48dac
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x48e60
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x48e60
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x38e90
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x48d9f
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x48db3
jmp 0x48da1
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x48d4f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x49a35
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x49a4e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x0, (%rax)
popq %rbp
retq
// File: 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 %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x49a75
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x49a8e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x1, (%rax)
popq %rbp
retq
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4a810
movl %eax, %esi
movq -0x88(%rbp), %rax
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
movl 0x64(%rax), %r8d
leaq -0x28(%rbp), %rdi
callq 0x499c0
movq -0x88(%rbp), %rdi
movl 0xc(%rdi), %esi
xorl %edx, %edx
callq 0x40c30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x49af1
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x88(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x98(%rbp)
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0xc, %esi
callq 0x41000
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x40fd0
jmp 0x49b36
leaq -0x70(%rbp), %rdi
callq 0x35c00
movq -0x88(%rbp), %rdi
addq $0x10, %rdi
callq 0x41060
movq -0x88(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
addq $0x70, %rdi
leaq -0x28(%rbp), %rsi
callq 0x49d50
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35c00
movq -0x78(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
callq 0x54c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movb %cl, -0x9(%rbp)
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x4a8db
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x55b0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4a971
movq -0x38(%rbp), %rdi
callq 0x4a890
movb %al, -0x49(%rbp)
jmp 0x4a93c
movq -0x48(%rbp), %rdi
movb -0x49(%rbp), %al
movsbl %al, %esi
callq 0x5220
jmp 0x4a94d
jmp 0x4a94f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a926
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5788
jmp 0x4a98e
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x4a984
movq -0x48(%rbp), %rdi
callq 0x5788
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x50, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x50, %edx
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x8070
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3040
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x3040
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x80b0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x3110
movq -0x1f0(%rbp), %rdi
callq 0x3250
movq -0x1f0(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x3170
movq -0x1f0(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x3250
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq 0x8ddf(%rip), %rcx      # 0x10fd0
callq 0x8360
movq %rax, -0x1e8(%rbp)
jmp 0x81ff
movq -0x1e8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x31f0
jmp 0x8218
leaq -0x1e0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3330
jmp 0x822a
movq -0x1f8(%rbp), %rax
movq 0x48(%rax), %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x3230
jmp 0x8243
movq -0x1e0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1e0(%rbp,%rax), %rdi
callq 0x3470
movb %al, -0x1f9(%rbp)
jmp 0x8263
movb -0x1f9(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1fa(%rbp)
jne 0x82a6
jmp 0x8278
movq -0x1e0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1e0(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x1fb(%rbp)
jmp 0x8298
movb -0x1fb(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1fa(%rbp)
movb -0x1fa(%rbp), %al
movb %al, -0x1fc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3190
movb -0x1fc(%rbp), %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x82fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3190
movq -0x50(%rbp), %rdi
callq 0x3440
// File: Albuso0[P]support/commandline.cpp
// Function: std::CommandLine::PrintHelp(std::ostream&) const
void CommandLine::PrintHelp (std::ostream &os) const
	{
		if (!m_items.empty ())
		{
			size_t width = 0;
			for (Items::const_iterator i = m_items.begin (); i != m_items.end (); ++i)
				width = std::max (width, (*i)->m_name.size ());
			width += 3;
			os << std::endl << "Program Arguments:" << std::endl;

			for (Items::const_iterator i = m_items.begin (); i != m_items.end (); ++i)
			{
				os << "    --"
				   << std::left << std::setw (width) << ( (*i)->m_name + ":")
				   << std::right << (*i)->m_help;
				
				// if ( (*i)->HasDefault ())
				// 	os << " [" << (*i)->GetDefault () << "]";
				os << std::endl;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9660
testb $0x1, %al
jne 0x9443
movq -0x80(%rbp), %rdi
movq $0x0, -0x18(%rbp)
callq 0x9680
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rdi
callq 0x96b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9550
testb $0x1, %al
jne 0x929d
jmp 0x92d5
leaq -0x20(%rbp), %rdi
callq 0x9610
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x31d0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5f50
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9640
jmp 0x927d
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x7ccc(%rip), %rsi      # 0x10fb8
callq 0x32e0
movq %rax, %rdi
leaq 0x2004(%rip), %rsi      # 0xb2ff
callq 0x3290
movq %rax, %rdi
movq 0x7cae(%rip), %rsi      # 0x10fb8
callq 0x32e0
movq -0x80(%rbp), %rdi
callq 0x9680
movq %rax, -0x38(%rbp)
movq -0x80(%rbp), %rdi
callq 0x96b0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9550
testb $0x1, %al
jne 0x933f
jmp 0x9441
movq -0x10(%rbp), %rdi
leaq 0x1fc8(%rip), %rsi      # 0xb312
callq 0x3290
movq %rax, %rdi
leaq 0x387(%rip), %rsi       # 0x96e0
callq 0x30d0
movq %rax, -0xa0(%rbp)
movl -0x18(%rbp), %edi
callq 0x9710
movq -0xa0(%rbp), %rdi
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
callq 0x3350
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9610
movq (%rax), %rsi
addq $0x8, %rsi
leaq 0x1f73(%rip), %rdx      # 0xb310
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x9730
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3270
movq %rax, -0x88(%rbp)
jmp 0x93c9
movq -0x88(%rbp), %rdi
leaq 0x3d9(%rip), %rsi       # 0x97b0
callq 0x30d0
movq %rax, -0xa8(%rbp)
jmp 0x93e5
leaq -0x38(%rbp), %rdi
callq 0x9610
movq -0xa8(%rbp), %rdi
movq (%rax), %rsi
addq $0x28, %rsi
callq 0x3270
jmp 0x9403
leaq -0x68(%rbp), %rdi
callq 0x3190
movq -0x10(%rbp), %rdi
movq 0x7ba1(%rip), %rsi      # 0x10fb8
callq 0x32e0
leaq -0x38(%rbp), %rdi
callq 0x9640
jmp 0x931c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3190
jmp 0x944c
jmp 0x9443
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6a20
movq -0x88(%rbp), %rdx
leaq 0x71889(%rip), %rsi     # 0x800d8
leaq -0x40(%rbp), %rdi
callq 0x11570
jmp 0xe85a
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x111c0
movb %al, -0x99(%rbp)
jmp 0xe876
movb -0x99(%rbp), %al
xorb $-0x1, %al
movb %al, -0x9a(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6ba8
leaq -0x41(%rbp), %rdi
callq 0x6600
movb -0x9a(%rbp), %al
testb $0x1, %al
jne 0xe8a2
jmp 0xe8dd
movl $0x1, %edi
callq 0x66f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xe8cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6ba8
leaq -0x41(%rbp), %rdi
callq 0x6600
jmp 0xe9a6
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x6a20
movq -0xa8(%rbp), %rdx
leaq 0x717dd(%rip), %rsi     # 0x800d8
leaq -0x78(%rbp), %rdi
callq 0x11570
jmp 0xe906
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x111c0
movb %al, -0xa9(%rbp)
jmp 0xe922
movb -0xa9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xaa(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6ba8
leaq -0x79(%rbp), %rdi
callq 0x6600
movb -0xaa(%rbp), %al
testb $0x1, %al
jne 0xe94e
jmp 0xe986
movl $0x1, %edi
callq 0x66f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xe97b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6ba8
leaq -0x79(%rbp), %rdi
callq 0x6600
jmp 0xe9a6
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xe994
movb $0x1, -0x1(%rbp)
jmp 0xe998
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6a10
nop
// File: zeeev[P]DASVC/bamtools/include/api/BamConstants.h
// Function: BamTools::TagTypeHelper<int>::CanConvertFrom(char)
static bool CanConvertFrom(const char c) {
        return ( c == Constants::BAM_TAG_TYPE_ASCII  ||
                 c == Constants::BAM_TAG_TYPE_INT8  ||
                 c == Constants::BAM_TAG_TYPE_INT16 ||
                 c == Constants::BAM_TAG_TYPE_INT32 );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x2(%rbp)
je 0x13821
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x63, %ecx
movb %al, -0x2(%rbp)
je 0x13821
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x73, %ecx
movb %al, -0x2(%rbp)
je 0x13821
movsbl -0x1(%rbp), %eax
cmpl $0x69, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x38, %edi
callq 0x6580
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1b790
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
cvtsi2sdl -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl (%rdi), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x1b7b0
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x10, %rdi
callq 0x1b8a0
movq -0x48(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x10, %rdi
callq 0x1b910
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x181(%rip), %rdx      # 0x1b230
callq 0x1b9c0
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x1ba10
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movl 0x14(%rax), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
addq $0x10, %rdi
callq 0x1ba10
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq (%rax), %rax
movl 0x14(%rax), %edx
addl $0x2, %edx
xorl %ecx, %ecx
callq 0x1b190
movl $0x1, -0x1c(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x1ba50
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x1b52b
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x1b4f0
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1ba70
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movl 0x14(%rax), %eax
movl %eax, -0x54(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ba70
movq %rax, %rcx
movl -0x54(%rbp), %eax
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jg 0x1b4e0
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1ba70
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x1b4a7
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ba70
movq -0x48(%rbp), %rdi
movq (%rax), %rax
addq $0x20, %rax
movq %rax, -0x60(%rbp)
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1ba70
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1b7b0
jmp 0x1b4e2
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1b430
movq -0x48(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ba70
movsd -0x68(%rbp), %xmm0
movq (%rax), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b3fa
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x1ba10
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
// File: zeeev[P]DASVC/src/cigar.cpp
// Function: percentID(std::vector<BamTools::CigarOp, std::allocator<BamTools::CigarOp>>&, int, int*)
double percentID(std::vector< CigarOp > & cigs, int32_t len, int * mb){

    double num       = 0;
    double denom     = 0;

    for(std::vector<CigarOp>::iterator it = cigs.begin();
        it != cigs.end(); it++){
        switch(it->Type){
        case 'M':
            {
                num += it->Length;
                break;
            }
        case '=':
            {
                num += it->Length;
                break;
            }
        case 'X':
            {
                denom += it->Length;
                break;
            }
        case 'I':
            {
                denom += it->Length;
                break;
            }
        case 'D':
            {
                denom += it->Length;
                break;
            }

        default:
            {
                break;
            }
        }
    }
    *mb = (int)num;
    return num / (denom + num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d30
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11da0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11d60
testb $0x1, %al
jne 0x1df23
jmp 0x1dffe
leaq -0x30(%rbp), %rdi
callq 0x11dd0
movsbl (%rax), %eax
addl $-0x3d, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x1b, %eax
ja 0x1dfe6
movq -0x48(%rbp), %rax
leaq 0x6233c(%rip), %rcx     # 0x80288
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x30(%rbp), %rdi
callq 0x11dd0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x1dfe8
leaq -0x30(%rbp), %rdi
callq 0x11dd0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x1dfe8
leaq -0x30(%rbp), %rdi
callq 0x11dd0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1dfe8
leaq -0x30(%rbp), %rdi
callq 0x11dd0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1dfe8
leaq -0x30(%rbp), %rdi
callq 0x11dd0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1dfe8
jmp 0x1dfe8
jmp 0x1dfea
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x11df0
movq %rax, -0x40(%rbp)
jmp 0x1df00
cvttsd2si -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
addsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/src/cigar.cpp
// Function: advanceQuery(char, unsigned int, long*, bool)
void advanceQuery(const char o,
                  const uint32_t l,
                  long int * pos,
                  bool countHardClip){

    switch(o){
    case 'M':
        {
            *pos += l;
            break;
        }
    case 'I':
        {
            *pos += l;
            break;
        }
    case 'S':
        {
            *pos += l;
            break;
        }
    case '=':
        {
            *pos += l;
            break;
        }
    case 'X':
        {
            *pos += l;
            break;
        }
    case 'H':
        {
            if(countHardClip){
                *pos += l;
                break;
            }
        }
    default:
        {
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x3d, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x1b, %eax
ja 0x1e0e0
movq -0x20(%rbp), %rax
leaq 0x6228f(%rip), %rcx     # 0x802f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e0e2
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e0e2
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e0e2
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e0e2
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e0e2
testb $0x1, -0x11(%rbp)
je 0x1e0de
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e0e2
jmp 0x1e0e0
jmp 0x1e0e2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/src/cigar.cpp
// Function: qlen(std::vector<BamTools::CigarOp, std::allocator<BamTools::CigarOp>>&)
long int qlen(std::vector< CigarOp > & cigs)
{
    long int qLength = 0;
    for(std::vector<CigarOp>::iterator it = cigs.begin();
        it != cigs.end(); it++){
        advanceQuery(it->Type, it->Length, &qLength, true);
    }
    return qLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11da0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11d60
testb $0x1, %al
jne 0x1e161
jmp 0x1e1a3
leaq -0x18(%rbp), %rdi
callq 0x11dd0
movb (%rax), %al
movb %al, -0x29(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x11dd0
movq %rax, %rcx
movb -0x29(%rbp), %al
movl 0x4(%rcx), %esi
leaq -0x10(%rbp), %rdx
movl $0x1, %ecx
movsbl %al, %edi
callq 0x1e030
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x11df0
movq %rax, -0x28(%rbp)
jmp 0x1e141
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zeeev[P]DASVC/src/cigar.cpp
// Function: advanceReference(char, unsigned int, long*)
void advanceReference(const char o, const uint32_t l, long int * pos){

    switch(o){
    case 'M':
        {
            *pos += l;
            break;
        }
    case '=':
        {
            *pos += l;
            break;
        }
    case 'X':
        {
            *pos += l;
            break;
        }
    case 'D':
        {
            *pos += l;
            break;
        }

    default:
        {
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x3d, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x1b, %eax
ja 0x1e22b
movq -0x18(%rbp), %rax
leaq 0x6218a(%rip), %rcx     # 0x80368
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e22d
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e22d
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e22d
movl -0x8(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1e22d
jmp 0x1e22d
popq %rbp
retq
nop
// File: zeeev[P]DASVC/bamtools/include/api/BamConstants.h
// Function: BamTools::TagTypeHelper<float>::CanConvertFrom(char)
static bool CanConvertFrom(const char c) {
        return ( c == Constants::BAM_TAG_TYPE_ASCII  ||
                 c == Constants::BAM_TAG_TYPE_UINT8  ||
                 c == Constants::BAM_TAG_TYPE_INT8   ||
                 c == Constants::BAM_TAG_TYPE_UINT16 ||
                 c == Constants::BAM_TAG_TYPE_INT16  ||
                 c == Constants::BAM_TAG_TYPE_UINT32 ||
                 c == Constants::BAM_TAG_TYPE_INT32  ||
                 c == Constants::BAM_TAG_TYPE_FLOAT);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x2(%rbp)
je 0x24139
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x43, %ecx
movb %al, -0x2(%rbp)
je 0x24139
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x63, %ecx
movb %al, -0x2(%rbp)
je 0x24139
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x53, %ecx
movb %al, -0x2(%rbp)
je 0x24139
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x73, %ecx
movb %al, -0x2(%rbp)
je 0x24139
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x49, %ecx
movb %al, -0x2(%rbp)
je 0x24139
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x69, %ecx
movb %al, -0x2(%rbp)
je 0x24139
movsbl -0x1(%rbp), %eax
cmpl $0x66, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: BartMassey[P]ancient-raytracer/render.cc
// Function: main
int main( int argc, char **argv ) {
  char *imgtype = (char *)"-ppm";
  int x, y;

  object *scene = generate();
  if( argc == 4 && argv[1][1] == '-' ) {
    imgtype = argv[1];
    argv++;
    argc--;
  }
  if( argc == 3 && (x = atoi( argv[1] )) && (y = atoi( argv[2] )) ) {
    render( scene, imgtype, x, y );
    // all done
    return 0;
  }
  fprintf( stderr, "usage: render [-oldppm|-ppm] x y\n" );
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x88d3(%rip), %rax      # 0xb060
movq %rax, -0x18(%rbp)
callq 0x91c0
movq %rax, -0x28(%rbp)
cmpl $0x4, -0x8(%rbp)
jne 0x27d2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2d, %eax
jne 0x27d2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jne 0x281e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x281e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2180
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x281e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x2850
movl $0x0, -0x4(%rbp)
jmp 0x283d
movq 0xc7bb(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x8836(%rip), %rsi      # 0xb065
movb $0x0, %al
callq 0x2170
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xb92d(%rip), %rcx      # 0xe838
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2f56
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movss 0xc(%rcx,%rdx,4), %xmm0
movslq -0x14(%rbp), %rcx
movss %xmm0, 0xc(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f23
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
cmpl 0x8(%rsi), %eax
jne 0x3316
jmp 0x3335
leaq 0x7d9b(%rip), %rdi      # 0xb0b8
leaq 0x7d6a(%rip), %rsi      # 0xb08e
movl $0x4f, %edx
leaq 0x7d93(%rip), %rcx      # 0xb0c3
callq 0x20b0
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3389
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movss 0xc(%rcx,%rdx,4), %xmm0
movslq -0x14(%rbp), %rcx
movss 0xc(%rax,%rcx,4), %xmm2
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3344
movss -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
cmpl 0x8(%rsi), %eax
jne 0x3606
jmp 0x3625
leaq 0x7aab(%rip), %rdi      # 0xb0b8
leaq 0x7a7a(%rip), %rsi      # 0xb08e
movl $0x66, %edx
leaq 0x7ac9(%rip), %rcx      # 0xb0e9
callq 0x20b0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3665
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movss 0xc(%rcx,%rdx,4), %xmm0
movslq -0x14(%rbp), %rcx
addss 0xc(%rax,%rcx,4), %xmm0
movss %xmm0, 0xc(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x362c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BartMassey[P]ancient-raytracer/./point.cc
// Function: point::transform(xform&)
inline void point::transform ( xform &m ) {
  int i, n;
  float t[4];

  assert( nc < 5 );
  for( n = 0; n < nc; n++ )
    t[n] = c[n];
  while( n < 3 )
    t[n++] = 0;
  if( n < 4 )
    t[n++] = 1;
  for( i = 0; i < nc; i++ )
    c[i] = m.rowmult( i, t );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x5, 0x8(%rax)
jge 0x37e0
jmp 0x37ff
leaq 0x7928(%rip), %rdi      # 0xb10f
leaq 0x78a0(%rip), %rsi      # 0xb08e
movl $0x92, %edx
leaq 0x791c(%rip), %rcx      # 0xb116
callq 0x20b0
movl $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3835
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss 0xc(%rax,%rcx,4), %xmm0
movslq -0x18(%rbp), %rax
movss %xmm0, -0x30(%rbp,%rax,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3806
jmp 0x3837
cmpl $0x3, -0x18(%rbp)
jge 0x3855
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
cltq
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp,%rax,4)
jmp 0x3837
cmpl $0x4, -0x18(%rbp)
jge 0x3876
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
cltq
movss 0x7794(%rip), %xmm0     # 0xb004
movss %xmm0, -0x30(%rbp,%rax,4)
movl $0x0, -0x14(%rbp)
movq -0x38(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x38b3
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x30(%rbp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x38(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss %xmm0, 0xc(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x387d
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BartMassey[P]ancient-raytracer/./point.cc
// Function: point::operator^(point)
inline point point::operator^( point p ) {
  point r(3);
  
  assert( nc == 3 && p.nc == 3 );
  // Each component is computed from the two other
  // components in a symmetric way.
  for (int i = 0; i < 3; i++)
      r.c[i] = cross_term(p, (i + 1) % 3,  (i + 2) % 3);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x3, %esi
callq 0x3f40
movq -0x58(%rbp), %rcx
xorl %eax, %eax
cmpl $0x3, 0x8(%rcx)
movb %al, -0x4d(%rbp)
jne 0x3919
movq -0x70(%rbp), %rax
cmpl $0x3, 0x8(%rax)
sete %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0x3922
jmp 0x3924
jmp 0x3943
leaq 0x7812(%rip), %rdi      # 0xb13d
leaq 0x775c(%rip), %rsi      # 0xb08e
movl $0xa6, %edx
leaq 0x7814(%rip), %rcx      # 0xb152
callq 0x20b0
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x3a1e
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2ef0
jmp 0x3963
movq -0x58(%rbp), %rdi
movl -0x20(%rbp), %ecx
movl %ecx, %edx
incl %edx
movl %ecx, %eax
movslq %edx, %rdx
imulq $0x55555556, %rdx, %rsi # imm = 0x55555556
movq %rsi, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rsi
addl %edx, %esi
movl %esi, %edx
leal (%rdx,%rdx,2), %esi
negl %esi
movl %esi, %edx
leal 0x1(%rax,%rdx), %edx
addl $0x2, %ecx
movslq %ecx, %rcx
imulq $0x55555556, %rcx, %rsi # imm = 0x55555556
movq %rsi, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rsi
addl %ecx, %esi
movl %esi, %ecx
leal (%rcx,%rcx,2), %esi
negl %esi
movl %esi, %ecx
leal 0x2(%rax,%rcx), %ecx
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq -0x40(%rbp), %rsi
callq *%rax
movss %xmm0, -0x74(%rbp)
jmp 0x39cf
movq -0x68(%rbp), %rax
movss -0x74(%rbp), %xmm0
movslq -0x20(%rbp), %rcx
movss %xmm0, 0xc(%rax,%rcx,4)
leaq -0x40(%rbp), %rdi
callq 0x2fd0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x394a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3a3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fd0
jmp 0x3a3e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3a31
movq -0x68(%rbp), %rdi
callq 0x2fd0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2fd0
movq -0x48(%rbp), %rdi
callq 0x21c0