LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_ALT_allele[abi:cxx11](int) const
string entry::get_ALT_allele(int allele_num) const
{
	assert(parsed_ALT == true);

	if (allele_num == -2)
		return "";
	else if ((allele_num == -1) || (unsigned(allele_num) >=  ALT.size()))
		return ".";
	return ALT[allele_num];
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x3da(%rsi)
je 0x220ad
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x2208b
cmpl $-0x2, %edx
jne 0x2204b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x17e94(%rip), %rdx     # 0x39ed7
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x220a3
movl %edx, %ecx
movq 0x448(%rsi), %rax
movq 0x450(%rsi), %rsi
subq %rax, %rsi
sarq $0x5, %rsi
cmpq %rcx, %rsi
jbe 0x2208b
movslq %edx, %rcx
shlq $0x5, %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xc7c8
jmp 0x220a8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x17154(%rip), %rsi     # 0x391ed
leaq 0x1714e(%rip), %rdx     # 0x391ee
movq %rbx, %rdi
callq 0xc85e
movq %rbx, %rax
popq %rbx
retq
leaq 0x17345(%rip), %rdi     # 0x393f9
leaq 0x17351(%rip), %rsi     # 0x3940c
leaq 0x1743f(%rip), %rcx     # 0x39501
movl $0x8a, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_alleles_vector(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>>>>&) const
void entry::get_alleles_vector(vector<string> &out) const
{
	assert(parsed_ALT == true);
	out.resize(ALT.size()+1);
	out[0] = REF;
	copy(ALT.begin(), ALT.end(), out.begin()+1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x3da(%rdi)
je 0x22152
movq %rsi, %r14
movq %rdi, %r15
movq 0x450(%rdi), %rsi
subq 0x448(%rdi), %rsi
sarq $0x5, %rsi
incq %rsi
movq %r14, %rdi
callq 0x1300e
leaq 0x428(%r15), %rsi
movq (%r14), %rdi
callq 0x51f0
movq 0x448(%r15), %rbx
movq 0x450(%r15), %r15
subq %rbx, %r15
sarq $0x5, %r15
testq %r15, %r15
jle 0x2214c
movq (%r14), %r14
incq %r15
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51f0
addq $0x20, %rbx
decq %r15
addq $0x20, %r14
cmpq $0x1, %r15
ja 0x22130
popq %rbx
popq %r14
popq %r15
retq
leaq 0x172a0(%rip), %rdi     # 0x393f9
leaq 0x172ac(%rip), %rsi     # 0x3940c
leaq 0x173c2(%rip), %rcx     # 0x39529
movl $0x95, %edx
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_FILTER[abi:cxx11]() const
string entry::get_FILTER() const
{
	assert(parsed_FILTER == true);

	ostringstream out;
	if (FILTER.empty())
		out << ".";
	else
	{
		out << FILTER[0];
		for (unsigned int ui=1; ui<FILTER.size(); ui++)
			out << ";" << FILTER[ui];
	}
	return out.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
cmpb $0x0, 0x3db(%rsi)
je 0x2228d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x55d0
movq 0x468(%r14), %rax
cmpq 0x470(%r14), %rax
je 0x2223e
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rsp, %rdi
callq 0x54f0
movq 0x470(%r14), %rax
subq 0x468(%r14), %rax
cmpq $0x21, %rax
jb 0x22252
movl $0x1, %r13d
movl $0x2, %ebp
leaq 0x173a6(%rip), %r15     # 0x39597
movq %rsp, %r12
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f0
movq 0x468(%r14), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %r12, %rdi
callq 0x54f0
movq 0x470(%r14), %rax
subq 0x468(%r14), %rax
movl %ebp, %r13d
sarq $0x5, %rax
incl %ebp
cmpq %r13, %rax
ja 0x221f4
jmp 0x22252
leaq 0x16fa8(%rip), %rsi     # 0x391ed
movq %rsp, %rdi
movl $0x1, %edx
callq 0x54f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c0
movq 0x26d5a(%rip), %rsi     # 0x48fc0
movq %rsp, %rdi
callq 0x51e0
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x172cc(%rip), %rdi     # 0x39560
leaq 0x17171(%rip), %rsi     # 0x3940c
leaq 0x172d4(%rip), %rcx     # 0x39576
movl $0xa2, %edx
callq 0x5280
jmp 0x222ae
movq %rax, %rbx
movq 0x26d08(%rip), %rsi     # 0x48fc0
movq %rsp, %rdi
callq 0x51e0
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_INFO_vector(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>> const&, bool) const
vector<pair<string, string> > entry::get_INFO_vector(const set<string> &INFO_to_keep, bool keep_all_INFO) const
{
	assert(parsed_INFO == true);

	vector<pair<string, string> > out_vector;
	if (keep_all_INFO == true)
		return INFO;

	if ( (!INFO.empty()) && (!INFO_to_keep.empty()) )
	{
		string key;
		for (unsigned int ui=0; ui<INFO.size();ui++)
		{
			key = INFO[ui].first;
			if ( keep_all_INFO or (INFO_to_keep.find(key) != INFO_to_keep.end() ) )
				out_vector.push_back( INFO[ui] );
		}
	}

	return out_vector;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x3dc(%rsi)
je 0x22728
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x480(%rsi), %rdx
testb %cl, %cl
je 0x22633
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x236d4
jmp 0x2270e
movq 0x480(%r15), %rsi
xorl %eax, %eax
cmpq 0x488(%r15), %rsi
je 0x226f7
cmpq $0x0, 0x28(%r14)
je 0x226f7
movq %rdx, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%r14), %rbp
movl $0x1, %r12d
xorl %ebx, %ebx
leaq 0x28(%rsp), %r13
shlq $0x6, %rbx
addq %rbx, %rsi
movq %r13, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x1b8cc
cmpq %rbp, %rax
je 0x226b5
movq 0x20(%rsp), %rax
addq (%rax), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x23758
movl %r12d, %ebx
movq 0x480(%r15), %rsi
movq 0x488(%r15), %rax
subq %rsi, %rax
sarq $0x6, %rax
incl %r12d
cmpq %rbx, %rax
ja 0x22683
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x226e9
callq 0x5410
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rbx
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rsp, %rdi
callq 0x1b3a8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16ea0(%rip), %rdi     # 0x395cf
leaq 0x16cd6(%rip), %rsi     # 0x3940c
leaq 0x16ede(%rip), %rcx     # 0x3961b
movl $0xdb, %edx
callq 0x5280
movq %rax, %rbx
jmp 0x22765
jmp 0x2274e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x22765
callq 0x5410
movq %rsp, %rdi
callq 0x1b3a8
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_INFO_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string entry::get_INFO_value(const string &key) const
{
	assert(parsed_INFO == true);

	for (unsigned int ui=0; ui<INFO.size(); ui++)
	{
		if (INFO[ui].first == key)
			return INFO[ui].second;
	}
	return "?";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
cmpb $0x1, 0x3dc(%rsi)
jne 0x22839
movq 0x480(%rsi), %r12
movq 0x488(%rsi), %r13
subq %r12, %r13
je 0x227e6
sarq $0x6, %r13
movq (%rdx), %r14
movq 0x8(%rdx), %r15
movl $0x1, %ebx
xorl %ebp, %ebp
shlq $0x6, %rbp
cmpq %r15, 0x8(%r12,%rbp)
jne 0x227dd
addq %r12, %rbp
testq %r15, %r15
je 0x22809
movq (%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5470
testl %eax, %eax
je 0x22809
movl %ebx, %ebp
incl %ebx
cmpq %rbp, %r13
ja 0x227b7
movq (%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x18048(%rip), %rsi     # 0x3a840
leaq 0x18042(%rip), %rdx     # 0x3a841
movq %rbx, %rdi
callq 0xc85e
jmp 0x22827
movq (%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%rbp), %rsi
movq 0x28(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xc7c8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16d8f(%rip), %rdi     # 0x395cf
leaq 0x16bc5(%rip), %rsi     # 0x3940c
leaq 0x16e22(%rip), %rcx     # 0x39670
movl $0xf1, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_INFO_values(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
vector<string> entry::get_INFO_values(const string &key) const
{
	vector<string> out;
	string tmp;

	tmp = get_INFO_value(key);
	if (tmp != "?")	header::tokenize(tmp, ',', out);

	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdi
callq 0x22776
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x5550
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x228ad
callq 0x5410
leaq 0x17f8c(%rip), %rsi     # 0x3a840
movq %rsp, %rdi
callq 0x50e0
testl %eax, %eax
je 0x228d0
movq %rsp, %rdi
movl $0x2c, %esi
movq %rbx, %rdx
callq 0x16a0a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x228de
callq 0x5410
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x228ed
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x228fe
callq 0x5410
movq %rbx, %rdi
callq 0xc4da
movq %r14, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_FORMAT[abi:cxx11]() const
string entry::get_FORMAT() const
{
	assert(parsed_FORMAT == true);

	string out;
	bool first = true;
	for (unsigned int ui=0; ui<FORMAT.size(); ui++)
	{
		if (first == false)
			out += ":";
		out += FORMAT[ui];
		first = false;
	}
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0x3dd(%rsi)
je 0x229bf
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x498(%rsi), %rax
cmpq %rax, 0x4a0(%rsi)
je 0x229ad
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x1772f(%rip), %r15     # 0x3a08d
xorl %ecx, %ecx
testb $0x1, %cl
je 0x22977
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5870
movq 0x498(%r14), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x50f0
movl %ebp, %r13d
movq 0x498(%r14), %rax
movq 0x4a0(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebp
movb $0x1, %cl
cmpq %r13, %rdx
ja 0x22960
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16cdd(%rip), %rdi     # 0x396a3
leaq 0x16a3f(%rip), %rsi     # 0x3940c
leaq 0x16ce5(%rip), %rcx     # 0x396b9
movl $0x108, %edx            # imm = 0x108
callq 0x5280
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x229ee
callq 0x5410
movq %r14, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GENOTYPE_strings(unsigned int, std::pair<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
void entry::get_indv_GENOTYPE_strings(unsigned int indv, pair<string, string> &out) const
{
	assert(parsed_GT[indv] == true);

	static string out_allele1, out_allele2;

	get_allele(GENOTYPE[indv].first, out_allele1);
	get_allele(GENOTYPE[indv].second, out_allele2);
	out = make_pair(out_allele1, out_allele2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x560(%rdi), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jae 0x22b1c
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r12d
movb 0x27430(%rip), %al      # 0x49e98
testb %al, %al
je 0x22b3b
movb 0x2744a(%rip), %al      # 0x49ec0
testb %al, %al
je 0x22b45
movq 0x4d0(%r14), %rax
movl (%rax,%r12,8), %esi
leaq 0x273e8(%rip), %r15     # 0x49e78
movq %r14, %rdi
movq %r15, %rdx
callq 0x21e8e
movq 0x4d0(%r14), %rax
movl 0x4(%rax,%r12,8), %esi
leaq 0x273f2(%rip), %r12     # 0x49ea0
movq %r14, %rdi
movq %r12, %rdx
callq 0x21e8e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x239dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5550
leaq 0x28(%rsp), %r14
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5550
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x22afd
callq 0x5410
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22b10
callq 0x5410
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x16c08(%rip), %rdi     # 0x3972b
leaq 0x168e2(%rip), %rsi     # 0x3940c
leaq 0x16c12(%rip), %rcx     # 0x39743
movl $0x11f, %edx            # imm = 0x11F
callq 0x5280
callq 0x5c51
jmp 0x22a70
callq 0x5ca8
jmp 0x22a7e
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GFILTER(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
void entry::get_indv_GFILTER(unsigned int indv, string &out) const
{
	assert(parsed_FT[indv] == true);

	if ((!GFILTER.empty()) && (GFILTER[indv].size()>0))
	{
		out="";
		for (unsigned int ui=0; ui<GFILTER[indv].size(); ui++)
		{
			if (ui!=0)
				out += ";";
			out += GFILTER[indv][ui];
		}
	}
	else
		out = ".";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5d8(%rdi), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jae 0x22e04
movq %rdx, %rbx
movq %rdi, %r14
movq 0x548(%rdi), %rax
cmpq 0x550(%rdi), %rax
je 0x22ddb
movl %esi, %r15d
leaq (%r15,%r15,2), %r12
movq 0x8(%rax,%r12,8), %rcx
cmpq (%rax,%r12,8), %rcx
je 0x22ddb
movq 0x8(%rbx), %rdx
leaq 0x1718f(%rip), %rcx     # 0x39ed7
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5690
movq 0x548(%r14), %rax
movq 0x8(%rax,%r12,8), %rcx
cmpq (%rax,%r12,8), %rcx
je 0x22dcc
movl $0x1, %ebp
xorl %r13d, %r13d
shlq $0x3, %r15
leaq (%r15,%r15,2), %r12
leaq 0x16819(%rip), %r15     # 0x39597
cmpl $0x1, %ebp
je 0x22d95
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5870
movq 0x548(%r14), %rax
movq (%rax,%r12), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x50f0
movq 0x548(%r14), %rax
movq 0x8(%rax,%r12), %rcx
subq (%rax,%r12), %rcx
movl %ebp, %r13d
sarq $0x5, %rcx
incl %ebp
cmpq %r13, %rcx
ja 0x22d7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdx
leaq 0x16407(%rip), %rcx     # 0x391ed
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5690
leaq 0x16a93(%rip), %rdi     # 0x3989e
leaq 0x165fa(%rip), %rsi     # 0x3940c
leaq 0x16ae7(%rip), %rcx     # 0x39900
movl $0x14f, %edx            # imm = 0x14F
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::FORMAT_id_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool entry::FORMAT_id_exists(const string &FORMAT_id)
{
	assert(parsed_FORMAT == true);
	if (FORMAT_to_idx.find(FORMAT_id) != FORMAT_to_idx.end())
		return true;
	return false;
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x3dd(%rdi)
je 0x22e90
movq %rdi, %rbx
addq $0x600, %rdi            # imm = 0x600
callq 0x1f64c
addq $0x608, %rbx            # imm = 0x608
cmpq %rbx, %rax
setne %al
popq %rbx
retq
leaq 0x1680c(%rip), %rdi     # 0x396a3
leaq 0x1656e(%rip), %rsi     # 0x3940c
leaq 0x16adb(%rip), %rcx     # 0x39980
movl $0x167, %edx            # imm = 0x167
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_N_chr() const
unsigned int entry::get_N_chr() const
{
	unsigned int out=0;

	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if (include_indv[ui] == true)
		{
			assert(parsed_GT[ui] == true);
			out += ploidy[ui];
		}
	}
	return out;
}

// Assembly:
pushq %rax
movl 0x8(%rdi), %edx
testq %rdx, %rdx
je 0x22f3d
movq 0x1f0(%rdi), %rsi
movq 0x560(%rdi), %r8
movq 0x4e8(%rdi), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl $0x1, %r9d
shlq %cl, %r9
movl %ecx, %r10d
shrl $0x6, %r10d
movq (%rsi,%r10,8), %r11
btq %rcx, %r11
jae 0x22f33
testq %r9, (%r8,%r10,8)
je 0x22f41
addl (%rdi,%rcx,4), %eax
incq %rcx
cmpq %rcx, %rdx
jne 0x22f10
jmp 0x22f3f
xorl %eax, %eax
popq %rcx
retq
leaq 0x16534(%rip), %rdi     # 0x3947c
leaq 0x164bd(%rip), %rsi     # 0x3940c
leaq 0x16a81(%rip), %rcx     # 0x399d7
movl $0x17b, %edx            # imm = 0x17B
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_allele_counts(std::vector<int, std::allocator<int>>&, unsigned int&, std::vector<bool, std::allocator<bool>> const&, std::vector<bool, std::allocator<bool>> const&) const
void entry::get_allele_counts(vector<int> &out, unsigned int &N_non_missing_chr_out, const vector<bool> &include_indv, const vector<bool> &include_genotype) const
{
	pair<int,int> genotype;
	vector<int> allele_counts(get_N_alleles(), 0);
	N_non_missing_chr_out = 0;

	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		//FILTERING BY INDIVIDUAL
		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
		{
			assert(parsed_GT[ui] == true);
			get_indv_GENOTYPE_ids(ui, genotype);

			if (genotype.first > -1)
			{
				allele_counts[genotype.first]++;
				N_non_missing_chr_out++;
			}
			if (genotype.second > -1)
			{
				allele_counts[genotype.second]++;
				N_non_missing_chr_out++;
			}
		}
	}
	out = allele_counts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq $0x0, 0x8(%rsp)
callq 0x22eb0
movl %eax, %esi
xorl %ebp, %ebp
leaq 0x34(%rsp), %rdx
movl %ebp, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x23784
movl %ebp, (%r12)
cmpl %ebp, 0x8(%r13)
je 0x2303d
leaq 0x8(%rsp), %rbx
movq (%r15), %rdx
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
movl %ebp, %ecx
shrl $0x6, %ecx
movq (%rdx,%rcx,8), %rdx
btq %rbp, %rdx
jae 0x23035
movq (%r14), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x23035
movq 0x560(%r13), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x2306a
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x22b50
movslq 0x8(%rsp), %rax
testq %rax, %rax
js 0x2301f
movq 0x18(%rsp), %rcx
incl (%rcx,%rax,4)
incl (%r12)
movslq 0xc(%rsp), %rax
testq %rax, %rax
js 0x23035
movq 0x18(%rsp), %rcx
incl (%rcx,%rax,4)
incl (%r12)
incl %ebp
cmpl 0x8(%r13), %ebp
jb 0x22fca
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x23900
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2305b
callq 0x5410
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1640b(%rip), %rdi     # 0x3947c
leaq 0x16394(%rip), %rsi     # 0x3940c
leaq 0x1697e(%rip), %rcx     # 0x399fd
movl $0x194, %edx            # imm = 0x194
callq 0x5280
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2309b
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_multiple_genotype_counts(std::vector<bool, std::allocator<bool>> const&, std::vector<bool, std::allocator<bool>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&) const
void entry::get_multiple_genotype_counts(const vector<bool> &include_indv, const vector<bool> &include_genotype, vector<unsigned int> &out_N_hom, vector<unsigned int> &out_N_het) const
{
	out_N_hom.assign(ALT.size()+1, 0);
	out_N_het.assign(ALT.size()+1, 0);
	pair<int, int> genotype;

	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
		{
			assert(parsed_GT[ui] == true);
			get_indv_GENOTYPE_ids(ui, genotype);

			for (int uj=0; uj<=(int)ALT.size(); uj++)
			{
				if ((genotype.first == uj) && (genotype.second == uj))
					out_N_hom[uj]++;
				else if (((genotype.first == uj) || (genotype.second == uj)) && (genotype.first != -1) && (genotype.second != -1))
					out_N_het[uj]++;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x450(%rdi), %rsi
subq 0x448(%rdi), %rsi
sarq $0x5, %rsi
incq %rsi
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdx
movl %ebp, (%rdx)
movq %rcx, %rdi
callq 0x23d66
movq 0x450(%r13), %rsi
subq 0x448(%r13), %rsi
sarq $0x5, %rsi
incq %rsi
leaq 0x8(%rsp), %rax
movl %ebp, (%rax)
leaq 0x8(%rsp), %rdx
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movq %rbx, %r14
movq %rdx, %rbx
callq 0x23d66
movq $0x0, (%rbx)
cmpl %ebp, 0x8(%r13)
je 0x23404
movq (%r12), %rdx
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
movl %ebp, %ecx
shrl $0x6, %ecx
movq (%rdx,%rcx,8), %rdx
btq %rbp, %rdx
jae 0x233f8
movq (%r15), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x233f8
movq 0x560(%r13), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x23413
movq %r13, %rdi
movl %ebp, %esi
leaq 0x8(%rsp), %rdx
callq 0x22b50
movq 0x450(%r13), %rax
subq 0x448(%r13), %rax
btq $0x24, %rax
jb 0x233f8
shrq $0x5, %rax
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rsi, %rcx
sete %dil
cmpq %rsi, %rdx
sete %sil
orb %dil, %sil
movq 0x10(%rsp), %rdi
movq (%rdi), %rdi
incl %eax
leaq (,%rdx,4), %r8
addq (%r14), %r8
xorl %r9d, %r9d
movq %rcx, %r10
xorq %r9, %r10
movq %rdx, %r11
xorq %r9, %r11
orq %r10, %r11
movq %r8, %r10
jne 0x233d2
incl (%r10)
incq %r9
addq $0x4, %rdi
cmpq %r9, %rax
jne 0x233ad
jmp 0x233f8
cmpq %r9, %rcx
jne 0x233e1
movq %rdi, %r10
testb %sil, %sil
je 0x233c1
jmp 0x233c4
cmpq %r9, %rdx
sete %r11b
cmpl $-0x1, %ecx
setne %bl
movq %rdi, %r10
testb %r11b, %bl
jne 0x233c1
jmp 0x233c4
incl %ebp
cmpl 0x8(%r13), %ebp
jb 0x2330c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16062(%rip), %rdi     # 0x3947c
leaq 0x15feb(%rip), %rsi     # 0x3940c
leaq 0x1671c(%rip), %rcx     # 0x39b44
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_rlen(std::vector<char, std::allocator<char>>&) const
void entry::get_rlen(vector<char> &out) const
{
	out.resize(sizeof(int32_t));
	int32_t rlen;
	if (REF != "" and REF != "." and REF != " ")
		rlen = (int32_t)REF.length();
	else
		rlen = (int32_t)0;
	memcpy(&out[0], &rlen, sizeof(rlen));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
movq %rbx, %rdi
callq 0xf332
leaq 0x428(%r14), %r15
leaq 0x16a33(%rip), %rsi     # 0x39ed7
movq %r15, %rdi
callq 0x50e0
xorl %ebp, %ebp
testl %eax, %eax
je 0x234df
leaq 0x15d34(%rip), %rsi     # 0x391ed
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x234df
leaq 0x14c43(%rip), %rsi     # 0x3810f
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x234df
movl 0x430(%r14), %ebp
movq (%rbx), %rax
movl %ebp, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_n_fmt_sample(std::vector<char, std::allocator<char>>&) const
void entry::get_n_fmt_sample(vector<char> &out) const
{
	out.resize(sizeof(uint32_t));
	uint32_t n_fmt_sample = (uint32_t)(FORMAT.size()-N_FORMAT_removed);
	uint32_t n_sample = (uint32_t)N_indv;

	n_fmt_sample = n_fmt_sample << 24;
	n_fmt_sample = n_fmt_sample | n_sample;

	memcpy(&out[0], &n_fmt_sample, sizeof(n_fmt_sample));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
movq %rbx, %rdi
callq 0xf332
movl 0x4a0(%r14), %eax
subl 0x498(%r14), %eax
shrl $0x5, %eax
subl 0x4cc(%r14), %eax
shll $0x18, %eax
orl 0x8(%r14), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_ALLELES_binary(std::vector<char, std::allocator<char>>&)
void entry::get_ALLELES_binary(vector<char> &out)
{
	vector<char> tmp;
	out.resize(0);

	make_typed_string(tmp, REF, true );
	out.insert(out.end(), tmp.begin(), tmp.end());

	for (unsigned int ui=0; ui<ALT.size(); ui++)
	{
		tmp.resize(0);
		make_typed_string(tmp, ALT[ui], true );
		out.insert(out.end(), tmp.begin(), tmp.end());
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xf332
leaq 0x428(%r14), %rdx
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %ecx
callq 0x1fa40
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x1bd8c
movq 0x450(%r14), %rax
cmpq 0x448(%r14), %rax
je 0x2369a
movl $0x1, %ebp
xorl %r12d, %r12d
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xf332
shlq $0x5, %r12
addq 0x448(%r14), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x1fa40
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x1bd8c
movq 0x450(%r14), %rax
subq 0x448(%r14), %rax
movl %ebp, %r12d
sarq $0x5, %rax
incl %ebp
cmpq %r12, %rax
ja 0x23641
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x236a8
callq 0x5410
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x236bb
jmp 0x236bb
jmp 0x236bb
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x236cc
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_setters.cpp
// Function: entry::add_ALT_allele(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void entry::add_ALT_allele(const string &in)
{
	if (in != ".")
	{
		if (find(ALT.begin(), ALT.end(),in) == ALT.end())
		{
			ALT.push_back(in);
		}
		else
		{
			LOG.warning(" Duplicate alternate alleles found at " + CHROM + ":" + LOG.int2str(POS));
			ALT.push_back(in);
		}
	}
	parsed_ALT = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14f3e(%rip), %rsi     # 0x391ed
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x24475
leaq 0x448(%rbx), %r15
movq 0x448(%rbx), %rdi
movq 0x450(%rbx), %rsi
movq %r14, %rdx
callq 0x24569
cmpq 0x450(%rbx), %rax
je 0x2446a
leaq 0x3e0(%rbx), %rdx
leaq 0x158d8(%rip), %rsi     # 0x39bcf
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0xb777
leaq 0x15d82(%rip), %rsi     # 0x3a08d
movq %r12, %rdi
callq 0x5870
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2433b
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x24343
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x400(%rbx), %esi
leaq 0x48(%rsp), %rdi
callq 0x37288
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x2438d
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x243b0
leaq 0x58(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x243ab
movq 0x58(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x243bc
leaq 0x28(%rsp), %rdi
callq 0x50f0
jmp 0x243ca
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x54d0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x243ee
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x243f4
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x25090(%rip), %rdi     # 0x494a8
leaq 0x8(%rsp), %rsi
callq 0x37146
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24435
callq 0x5410
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24448
callq 0x5410
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x24457
callq 0x5410
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2446a
callq 0x5410
movq %r15, %rdi
movq %r14, %rsi
callq 0x13084
movb $0x1, 0x3da(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x244a6
callq 0x5410
jmp 0x244a6
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x244be
callq 0x5410
jmp 0x244be
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x244d2
callq 0x5410
jmp 0x244d2
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x244e5
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_setters.cpp
// Function: entry::set_indv_DEPTH(unsigned int, int)
void entry::set_indv_DEPTH(unsigned int indv, int in)
{
	parsed_DP[indv] = true;
	if (in == -1)
	{
		if (!DEPTH.empty())
			DEPTH[indv] = -1;
		return;
	}
	if (DEPTH.empty())
		DEPTH.resize(N_indv, -1);

	DEPTH[indv] = in;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl $0x1, %eax
movl %ebx, %ecx
shlq %cl, %rax
movq 0x5b0(%rdi), %rcx
shrl $0x6, %esi
orq %rax, (%rcx,%rsi,8)
movq 0x530(%rdi), %rax
movq 0x538(%rdi), %rcx
cmpl $-0x1, %edx
je 0x24551
movl %edx, %ebp
cmpq %rcx, %rax
jne 0x2455b
movq %rdi, %r14
addq $0x530, %rdi            # imm = 0x530
movl 0x8(%r14), %esi
leaq 0xc(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
callq 0xbac4
movq 0x530(%r14), %rax
jmp 0x2455b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x24560
movl %ebx, %ecx
movl %ebp, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_ALT(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_ALT(const string &in)
{
	istringstream ss(in);
	string tmpstr;
	ALT.resize(0);
	while(!ss.eof())
	{
		getline(ss, tmpstr, ',');
		add_ALT_allele(tmpstr);
	}
	parsed_ALT = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movl $0x8, %edx
callq 0x5730
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x448(%rbx), %rdi
xorl %esi, %esi
callq 0x1300e
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x48(%rsp,%rax)
jne 0x2470d
movq %r14, %rdi
movq %r15, %rsi
movl $0x2c, %edx
callq 0x5830
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24294
jmp 0x246e0
movb $0x1, 0x3da(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24723
callq 0x5410
movq 0x2488e(%rip), %rsi     # 0x48fb8
leaq 0x28(%rsp), %rdi
callq 0x5610
leaq 0xa0(%rsp), %rdi
callq 0x5100
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x24752
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24764
callq 0x5410
movq 0x2484d(%rip), %rsi     # 0x48fb8
leaq 0x28(%rsp), %rdi
callq 0x5610
leaq 0xa0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_PHASE(unsigned int, char)
void vcf_entry::set_indv_PHASE(unsigned int indv, char in)
{
	if (PHASE.size() == 0)
		PHASE.resize(N_indv, '/');

	PHASE[indv] = in;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movq 0x500(%rdi), %rax
cmpq %rax, 0x508(%rdi)
jne 0x2510a
leaq 0x500(%r14), %rdi
movl 0x8(%r14), %esi
leaq 0xf(%rsp), %rdx
movb $0x2f, (%rdx)
callq 0x25b44
movq 0x500(%r14), %rax
movl %ebx, %ecx
movb %bpl, (%rax,%rcx)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GENOTYPE_alleles(unsigned int, char, char)
void vcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, char a1, char a2)
{
	if (GENOTYPE.size() == 0)
		GENOTYPE.resize(N_indv, make_pair(-1,-1));

	pair<int, int> a(-1,-1);

	if (a1 != '.')
		a.first = a1 - '0';

	if (a2 != '.')
		a.second = a2 - '0';

	GENOTYPE[indv] = a;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
movq 0x4d0(%rdi), %rax
cmpq %rax, 0x4d8(%rdi)
jne 0x25176
leaq 0x4d0(%r14), %rdi
movl 0x8(%r14), %esi
movq %rsp, %rdx
movq $-0x1, (%rdx)
callq 0x25b10
movq 0x4d0(%r14), %rax
movsbl %r15b, %ecx
leal -0x30(%rcx), %edx
cmpb $0x2e, %cl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovel %ecx, %edx
movsbl %bpl, %esi
leal -0x30(%rsi), %edi
cmpb $0x2e, %sil
cmovel %ecx, %edi
movl %ebx, %ecx
movl %edx, (%rax,%rcx,8)
movl %edi, 0x4(%rax,%rcx,8)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GENOTYPE_alleles(unsigned int, std::pair<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&)
void vcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, const pair<string, string> &in)
{
	if (GENOTYPE.size() == 0)
		GENOTYPE.resize(N_indv, make_pair(-1,-1));

	pair<int, int> a(-1,-1);

	if (in.first != ".")
		a.first = header::str2int(in.first);

	if (in.second != ".")
		a.second = header::str2int(in.second);

	GENOTYPE[indv] = a;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x4d8(%rdi), %rax
cmpq 0x4d0(%rdi), %rax
jne 0x25204
leaq 0x4d0(%r14), %rdi
movl 0x8(%r14), %esi
leaq 0x8(%rsp), %rdx
movq $-0x1, (%rdx)
callq 0x25b10
leaq 0x13fe2(%rip), %rsi     # 0x391ed
movq %r15, %rdi
callq 0x50e0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x25232
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16afa
movl %eax, %r12d
addq $0x20, %r15
leaq 0x13fb0(%rip), %rsi     # 0x391ed
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x25258
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16afa
movl %eax, %ebp
movl %ebx, %eax
movq 0x4d0(%r14), %rcx
movl %r12d, (%rcx,%rax,8)
movl %ebp, 0x4(%rcx,%rax,8)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int, std::pair<int, int> const&, char)
void vcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<int, int> &genotype, char phase)
{
	ploidy.resize(N_indv);
	ploidy[indv] = 2;
	set_indv_GENOTYPE_ids(indv, genotype);
	set_indv_PHASE(indv, phase);
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
addq $0x4e8, %rdi            # imm = 0x4E8
movl 0x8(%r15), %esi
callq 0xc17a
movl %ebx, %eax
movq 0x4e8(%r15), %rcx
movl $0x2, (%rcx,%rax,4)
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x25300
movq %r15, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x250cc
movq 0x560(%r15), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GQUALITY(unsigned int, double)
void vcf_entry::set_indv_GQUALITY(unsigned int indv, double in)
{
	parsed_GQ[indv] = true;
	if (in == -1)
	{
		if (GQUALITY.size() > 0)
			GQUALITY[indv] = -1;
		return;
	}
	if (GQUALITY.size() == 0)
		GQUALITY.resize(N_indv, -1);

	if (in > 99)
		in = 99;
	GQUALITY[indv] = in;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq 0x588(%rdi), %rax
movl %esi, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
ucomisd 0x13c4f(%rip), %xmm0    # 0x39040
movq 0x518(%rdi), %rax
movq 0x520(%rdi), %rcx
jne 0x25412
jp 0x25412
cmpq %rax, %rcx
je 0x25462
movsd 0x13c30(%rip), %xmm1    # 0x39040
jmp 0x2545b
cmpq %rax, %rcx
jne 0x2544f
movq %rdi, %r14
addq $0x518, %rdi            # imm = 0x518
movl 0x8(%r14), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movsd %xmm0, 0x8(%rsp)
callq 0xbaf8
movsd 0x8(%rsp), %xmm0
movq 0x518(%r14), %rax
movsd 0x147a1(%rip), %xmm1    # 0x39bf8
minsd %xmm0, %xmm1
movl %ebx, %ecx
movsd %xmm1, (%rax,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GFILTER(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_indv_GFILTER(unsigned int indv, const string &in)
{
	parsed_FT[indv] = true;

	if (GFILTER.size() == 0)
		GFILTER.resize(N_indv);

	GFILTER[indv].resize(0);
	if ((in.size() == 0) || (in == "."))
		return;

	static istringstream ss;
	static string ith_FILTER;
	ss.clear();
	ss.str(in);
	while (!ss.eof())
	{
		getline(ss, ith_FILTER, ';');

		if ((ith_FILTER.size()==0) || (ith_FILTER == "."))
			continue;	// Don't bother storing "unfiltered" state.

		GFILTER[indv].push_back(ith_FILTER);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ecx
movl %esi, %r12d
movq 0x5d8(%rdi), %rax
movl %esi, %edx
movl $0x1, %esi
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
leaq 0x548(%rdi), %rbx
movq 0x548(%rdi), %rax
cmpq %rax, 0x550(%rdi)
jne 0x254bf
movq %rdi, %r15
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x25b72
movq 0x548(%r15), %rax
leaq (%r12,%r12,2), %r13
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
callq 0x1300e
cmpq $0x0, 0x8(%r14)
je 0x255a6
leaq 0x13d0d(%rip), %rsi     # 0x391ed
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x255a6
movb 0x24ba2(%rip), %al      # 0x4a098
testb %al, %al
je 0x255b0
movb 0x24bbc(%rip), %al      # 0x4a0c0
testb %al, %al
je 0x255fb
movq 0x24a05(%rip), %rax     # 0x49f18
leaq 0x249fe(%rip), %r15     # 0x49f18
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x5750
leaq 0x249f9(%rip), %rdi     # 0x49f28
movq %r14, %rsi
callq 0x5640
movq 0x249da(%rip), %rax     # 0x49f18
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rax,%r15)
jne 0x255a6
leaq 0x24b4f(%rip), %r14     # 0x4a0a0
leaq 0x13c95(%rip), %r12     # 0x391ed
shlq $0x3, %r13
movq %r15, %rdi
movq %r14, %rsi
movl $0x3b, %edx
callq 0x5830
cmpq $0x0, 0x24b34(%rip)     # 0x4a0a8
je 0x25593
movq %r14, %rdi
movq %r12, %rsi
callq 0x50e0
testl %eax, %eax
je 0x25593
movq (%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x13084
movq 0x2497e(%rip), %rax     # 0x49f18
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rax,%r15)
je 0x2555c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x24ae1(%rip), %rdi     # 0x4a098
callq 0x5810
testl %eax, %eax
je 0x254fe
leaq 0x2494d(%rip), %rdi     # 0x49f18
callq 0x5310
movq 0x239c1(%rip), %rdi     # 0x48f98
leaq 0x2493a(%rip), %rsi     # 0x49f18
leaq 0x23e73(%rip), %rdx     # 0x49458
callq 0x53d0
leaq 0x24aa7(%rip), %rdi     # 0x4a098
callq 0x5270
jmp 0x254fe
callq 0x5d65
jmp 0x2550c
movq %rax, %rbx
leaq 0x24a89(%rip), %rdi     # 0x4a098
callq 0x5250
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_FILTER(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_FILTER(const string &FILTER_str)
{
	FILTER.resize(0);

	if (FILTER_str != ".")
	{
		istringstream ss(FILTER_str);
		string ith_FILTER;
		while (!ss.eof())
		{
			getline(ss, ith_FILTER, ';');
			FILTER.push_back(ith_FILTER);
		}
	}
	sort(FILTER.begin(), FILTER.end());
	parsed_FILTER = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x468(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1300e
leaq 0x13ba3(%rip), %rsi     # 0x391ed
movq %r12, %rdi
callq 0x50e0
testl %eax, %eax
je 0x256e1
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x5730
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %rsp, %r12
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x256b5
movq %r15, %rdi
movq %r12, %rsi
movl $0x3b, %edx
callq 0x5830
movq %r14, %rdi
movq %r12, %rsi
callq 0x13084
jmp 0x25688
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x256c3
callq 0x5410
movq 0x238ee(%rip), %rsi     # 0x48fb8
leaq 0x20(%rsp), %rdi
callq 0x5610
leaq 0x98(%rsp), %rdi
callq 0x5100
movq 0x468(%rbx), %r14
movq 0x470(%rbx), %r15
cmpq %r15, %r14
je 0x25721
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x263a1
movq %r14, %rdi
movq %r15, %rsi
callq 0x26475
movb $0x1, 0x3db(%rbx)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2574a
callq 0x5410
movq 0x23867(%rip), %rsi     # 0x48fb8
leaq 0x20(%rsp), %rdi
callq 0x5610
leaq 0x98(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_ALT(int)
void bcf_entry::set_ALT(const int n_allele)
{
	ALT.resize(n_allele-1);
	unsigned int pos = ALT_pos;
	string allele;
	for (int ui=0; ui<(n_allele-1); ui++)
	{
		allele = get_typed_string( &pos, line );
		std::transform(allele.begin(), allele.end(), allele.begin(), ::toupper);
		ALT[ui] = allele;
	}

	parsed_ALT = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r15d
movq %rdi, %rbx
addq $0x448, %rdi            # imm = 0x448
leal -0x1(%r15), %ebp
movslq %ebp, %rsi
movq %rdi, 0x20(%rsp)
callq 0x1300e
movl 0x6f0(%rbx), %eax
movl %eax, 0x4(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x1, %r15d
jle 0x26e11
leaq 0x3c0(%rbx), %rax
movq %rax, 0x18(%rsp)
movl %ebp, %eax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0x48(%rsp), %r15
leaq 0x28(%rsp), %r13
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x4(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x21124
movq %r13, %r12
movq %r13, %rdi
movq %r15, %rbp
movq %r15, %rsi
callq 0x5550
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x26d9b
callq 0x5410
movq 0x30(%rsp), %r15
testq %r15, %r15
je 0x26dc4
movq 0x28(%rsp), %r13
xorl %ebx, %ebx
movsbl (%r13,%rbx), %edi
callq 0x5840
movb %al, (%r13,%rbx)
incq %rbx
cmpq %rbx, %r15
jne 0x26dac
movq %r14, %rdi
shlq $0x5, %rdi
movq 0x20(%rsp), %rax
addq (%rax), %rdi
movq %r12, %r13
movq %r12, %rsi
callq 0x51f0
incq %r14
cmpq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbx
movq %rbp, %r15
jne 0x26d61
movq 0x28(%rsp), %rdi
movb $0x1, 0x3da(%rbx)
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x26e18
callq 0x5410
jmp 0x26e18
movb $0x1, 0x3da(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26e29
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x26e40
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::add_FORMAT_entry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&)
void bcf_entry::add_FORMAT_entry(const string &in, const unsigned int &fmt_key, const unsigned int &pos, const unsigned int &line_pos, const unsigned int &type, const unsigned int &size)
{
	FORMAT.push_back(in);
	FORMAT_to_idx[in] = pos;
	FORMAT_positions[pos] = line_pos;
	FORMAT_types[pos] = type;
	FORMAT_sizes[pos] = size;
	FORMAT_keys[pos] = fmt_key;

	if ( (type==1) or (type==7) )
		FORMAT_skip[pos] = ( sizeof(int8_t)*size );
	else if ( type==2 )
		FORMAT_skip[pos] = ( sizeof(int16_t)*size );
	else if ( (type==3) or (type==5) )
		FORMAT_skip[pos] = ( sizeof(int32_t)*size );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %rbp
movq %rdi, %r14
addq $0x498, %rdi            # imm = 0x498
callq 0x13084
movl (%rbx), %r12d
leaq 0x600(%r14), %rdi
movq %rbp, %rsi
callq 0x1b32c
movq 0x40(%rsp), %rsi
movl %r12d, (%rax)
movl (%r13), %eax
movl (%rbx), %ecx
movq 0x640(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movl (%r15), %eax
movl (%rbx), %ecx
movq 0x658(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movl (%rsi), %eax
movl (%rbx), %ecx
movq 0x670(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movq (%rsp), %rax
movl (%rax), %eax
movl (%rbx), %ecx
movq 0x6a0(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movl (%r15), %eax
decl %eax
cmpl $0x6, %eax
ja 0x27b8e
leaq 0x1210a(%rip), %rcx     # 0x39c74
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %eax
jmp 0x27b82
movl (%rsi), %eax
shll $0x2, %eax
jmp 0x27b82
movl (%rsi), %eax
addl %eax, %eax
movl (%rbx), %ecx
movq 0x688(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GENOTYPE_alleles(unsigned int, std::pair<int, int> const&)
void bcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, const pair<int, int> &in)
{
	if (GENOTYPE.size() == 0)
		GENOTYPE.resize(N_indv, make_pair(-1,-1));

	pair<int, int> a(-1,-1);

	if (in.first == 0x81)
		a.first = -2;
	else if (in.first != 0x80)
		a.first = in.first;

	if (in.second == 0x81)
		a.second = -2;
	else if (in.second != 0x80)
		a.second = in.second;

	GENOTYPE[indv] = in;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x4d0(%rdi), %rax
cmpq %rax, 0x4d8(%rdi)
jne 0x27f8e
leaq 0x4d0(%r14), %rdi
movl 0x8(%r14), %esi
leaq 0x8(%rsp), %rdx
movq $-0x1, (%rdx)
callq 0x25b10
movq 0x4d0(%r14), %rax
movl %ebx, %ecx
movq (%r15), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop