LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rbx
movq %rdi, %r14
addq $0x560, %rdi            # imm = 0x560
movl %esi, %r15d
movq %r15, %rsi
callq 0x9792
testb %al, %al
je 0x1ca2a
movb 0x25519(%rip), %al      # 0x41ec0
testb %al, %al
je 0x1ca49
movb 0x25533(%rip), %al      # 0x41ee8
testb %al, %al
je 0x1caa5
movq 0x4d0(%r14), %rax
movl (%rax,%r15,8), %esi
leaq 0x254d1(%rip), %r12     # 0x41ea0
movq %r14, %rdi
movq %r12, %rdx
callq 0x1bfa2
movq 0x4d0(%r14), %rax
movl 0x4(%rax,%r15,8), %esi
leaq 0x254db(%rip), %r15     # 0x41ec8
movq %r14, %rdi
movq %r15, %rdx
callq 0x1bfa2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d7d2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d690
movq %r14, %rdi
callq 0x1665a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x11c64(%rip), %rdi     # 0x2e695
leaq 0x1193e(%rip), %rsi     # 0x2e376
leaq 0x11c6e(%rip), %rcx     # 0x2e6ad
movl $0x11f, %edx            # imm = 0x11F
callq 0x52a0
leaq 0x25470(%rip), %rdi     # 0x41ec0
callq 0x5850
testl %eax, %eax
je 0x1c9af
leaq 0x2544c(%rip), %rax     # 0x41eb0
movq %rax, 0x25435(%rip)     # 0x41ea0
leaq 0x2542e(%rip), %rsi     # 0x41ea0
andq $0x0, 0x2542e(%rip)     # 0x41ea8
movb $0x0, 0x2542f(%rip)     # 0x41eb0
movq 0x24520(%rip), %rdi     # 0x40fa8
leaq 0x249f1(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x25425(%rip), %rdi     # 0x41ec0
callq 0x5290
jmp 0x1c9af
leaq 0x2543c(%rip), %rdi     # 0x41ee8
callq 0x5850
testl %eax, %eax
je 0x1c9bd
leaq 0x25418(%rip), %rax     # 0x41ed8
movq %rax, 0x25401(%rip)     # 0x41ec8
leaq 0x253fa(%rip), %rsi     # 0x41ec8
andq $0x0, 0x253fa(%rip)     # 0x41ed0
movb $0x0, 0x253fb(%rip)     # 0x41ed8
movq 0x244c4(%rip), %rdi     # 0x40fa8
leaq 0x24995(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x253f1(%rip), %rdi     # 0x41ee8
callq 0x5290
jmp 0x1c9bd
nop
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_DEPTH(unsigned int) const
int entry::get_indv_DEPTH(unsigned int indv) const
{
	assert(parsed_DP[indv] == true);
	if (DEPTH.empty())
		return -1;
	return DEPTH[indv];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x5b0, %rdi            # imm = 0x5B0
movl %esi, %ebx
movq %rbx, %rsi
callq 0x9792
testb %al, %al
je 0x1cbe2
movq 0x530(%r14), %rax
cmpq 0x538(%r14), %rax
je 0x1cbd7
movl (%rax,%rbx,4), %eax
jmp 0x1cbda
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x11b8d(%rip), %rdi     # 0x2e776
leaq 0x11786(%rip), %rsi     # 0x2e376
leaq 0x11b97(%rip), %rcx     # 0x2e78e
movl $0x136, %edx            # imm = 0x136
callq 0x52a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GQUALITY(unsigned int) const
double entry::get_indv_GQUALITY(unsigned int indv) const
{
	assert(parsed_GQ[indv] == true);
	if (GQUALITY.empty())
		return -1;
	return GQUALITY[indv];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x588, %rdi            # imm = 0x588
movl %esi, %ebx
movq %rbx, %rsi
callq 0x9792
testb %al, %al
je 0x1cc45
movq 0x518(%r14), %rax
cmpq 0x520(%r14), %rax
je 0x1cc35
movsd (%rax,%rbx,8), %xmm0
jmp 0x1cc3d
movsd 0x11343(%rip), %xmm0    # 0x2df80
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x11b70(%rip), %rdi     # 0x2e7bc
leaq 0x11723(%rip), %rsi     # 0x2e376
leaq 0x11b7a(%rip), %rcx     # 0x2e7d4
movl $0x13e, %edx            # imm = 0x13E
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GFILTER_vector(unsigned int, 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_indv_GFILTER_vector(unsigned int indv, vector<string> &out) const
{
	assert(parsed_FT[indv] == true);
	if (!GFILTER.empty())
		out = GFILTER[indv];
	else
		out.resize(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
addq $0x5d8, %rdi            # imm = 0x5D8
movl %esi, %r14d
movq %r14, %rsi
callq 0x9792
testb %al, %al
je 0x1ccb8
movq 0x548(%r15), %rsi
cmpq 0x550(%r15), %rsi
je 0x1cca9
imulq $0x18, %r14, %rax
addq %rax, %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xcca8
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xfd72
leaq 0x11b49(%rip), %rdi     # 0x2e808
leaq 0x116b0(%rip), %rsi     # 0x2e376
leaq 0x11b53(%rip), %rcx     # 0x2e820
movl $0x146, %edx            # imm = 0x146
callq 0x52a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
addq $0x5d8, %rdi            # imm = 0x5D8
movl %esi, %r15d
movq %r15, %rsi
callq 0x9792
testb %al, %al
je 0x1cdac
movq 0x548(%r14), %rax
cmpq 0x550(%r14), %rax
je 0x1cd8a
imulq $0x18, %r15, %r12
movq 0x8(%rax,%r12), %rcx
cmpq (%rax,%r12), %rcx
je 0x1cd8a
leaq 0x12110(%rip), %rsi     # 0x2ee37
movq %rbx, %rdi
callq 0x58b0
xorl %eax, %eax
leaq 0x117c9(%rip), %r15     # 0x2e501
movl %eax, %r13d
movq 0x548(%r14), %rcx
movq (%rcx,%r12), %rax
movq 0x8(%rcx,%r12), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %r13, %rcx
jbe 0x1cda2
testq %r13, %r13
je 0x1cd72
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58a0
movq 0x548(%r14), %rax
movq (%rax,%r12), %rax
movq %r13, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x58d0
leal 0x1(%r13), %eax
jmp 0x1cd38
leaq 0x1139c(%rip), %rsi     # 0x2e12d
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x58b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x11a55(%rip), %rdi     # 0x2e808
leaq 0x115bc(%rip), %rsi     # 0x2e376
leaq 0x11aa9(%rip), %rcx     # 0x2e86a
movl $0x14f, %edx            # imm = 0x14F
callq 0x52a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ce44
movq %rdi, %rbx
addq $0x600, %rdi            # imm = 0x600
callq 0x19dea
addq $0x608, %rbx            # imm = 0x608
cmpq %rbx, %rax
setne %al
popq %rbx
retq
leaq 0x117c2(%rip), %rdi     # 0x2e60d
leaq 0x11524(%rip), %rsi     # 0x2e376
leaq 0x11a91(%rip), %rcx     # 0x2e8ea
movl $0x167, %edx            # imm = 0x167
callq 0x52a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1f0(%rdi), %r14
leaq 0x560(%rdi), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movl 0x8(%rbx), %eax
cmpq %rax, %r12
jae 0x1cef6
movq %r14, %rdi
movq %r12, %rsi
callq 0x9792
testb %al, %al
je 0x1cef1
movq %r15, %rdi
movq %r12, %rsi
callq 0x9792
testb %al, %al
je 0x1cf01
movq 0x4e8(%rbx), %rax
addl (%rax,%r12,4), %ebp
incq %r12
jmp 0x1cec0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x114de(%rip), %rdi     # 0x2e3e6
leaq 0x11467(%rip), %rsi     # 0x2e376
leaq 0x11a2b(%rip), %rcx     # 0x2e941
movl $0x17b, %edx            # imm = 0x17B
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
callq 0x1ce64
movl %eax, %esi
leaq 0x34(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x1d6ba
andl $0x0, (%r12)
leaq 0x560(%r13), %rbx
xorl %ebp, %ebp
movl 0x8(%r13), %eax
cmpq %rax, %rbp
jae 0x1cffe
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9792
testb %al, %al
je 0x1cff9
movq %r14, %rdi
movq %rbp, %rsi
callq 0x9792
testb %al, %al
je 0x1cff9
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x9792
testb %al, %al
je 0x1d026
movq %r13, %rdi
movl %ebp, %esi
leaq 0x8(%rsp), %rdx
callq 0x1cb02
movslq 0x8(%rsp), %rax
testq %rax, %rax
js 0x1cfe3
movq 0x18(%rsp), %rcx
incl (%rcx,%rax,4)
incl (%r12)
movslq 0xc(%rsp), %rax
testq %rax, %rax
js 0x1cff9
movq 0x18(%rsp), %rcx
incl (%rcx,%rax,4)
incl (%r12)
incq %rbp
jmp 0x1cf88
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x1d710
leaq 0x18(%rsp), %rdi
callq 0xa18e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x113b9(%rip), %rdi     # 0x2e3e6
leaq 0x11342(%rip), %rsi     # 0x2e376
leaq 0x1192c(%rip), %rcx     # 0x2e967
movl $0x194, %edx            # imm = 0x194
callq 0x52a0
jmp 0x1d047
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xa18e
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_genotype_counts(std::vector<bool, std::allocator<bool>> const&, std::vector<bool, std::allocator<bool>> const&, unsigned int&, unsigned int&, unsigned int&) const
void entry::get_genotype_counts(const vector<bool> &include_indv, const vector<bool> &include_genotype, unsigned int &out_N_hom1, unsigned int &out_N_het, unsigned int &out_N_hom2) const
{
	out_N_hom1 = 0; out_N_hom2 = 0; out_N_het = 0;
	pair<int, int> genotype;
	if (ALT.size() > 1)
		LOG.error("Tried to return the genotype counts of a non-biallelic SNP", 99);

	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);
			if ((genotype.first > -1) && (genotype.second > -1))
			{
				if (genotype.first != genotype.second)
					out_N_het++;
				else if (genotype.first == 0)
					out_N_hom1++;
				else if (genotype.first == 1)
					out_N_hom2++;
				else
					LOG.error("Unknown allele in genotype", 98);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x18(%rsp)
andl $0x0, (%rcx)
movq %rdx, %r12
movq %r9, 0x20(%rsp)
andl $0x0, (%r9)
movq %rsi, %r13
movq %r8, 0x28(%rsp)
andl $0x0, (%r8)
movq %rdi, %rbp
andq $0x0, 0x10(%rsp)
movq 0x450(%rdi), %rax
subq 0x448(%rdi), %rax
cmpq $0x21, %rax
jb 0x1d0db
leaq 0x11928(%rip), %rsi     # 0x2e9d6
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5160
leaq 0x2440c(%rip), %rdi     # 0x414d0
leaq 0x38(%rsp), %rsi
pushq $0x63
popq %rdx
callq 0x2bf18
leaq 0x38(%rsp), %rdi
callq 0x5908
leaq 0x560(%rbp), %rax
movq %rax, 0x30(%rsp)
xorl %r15d, %r15d
leaq 0x58(%rsp), %r14
movl 0x8(%rbp), %eax
cmpq %rax, %r15
jae 0x1d1a9
movq %r13, %rdi
movq %r15, %rsi
callq 0x9792
testb %al, %al
je 0x1d16e
movq %r12, %rdi
movq %r15, %rsi
callq 0x9792
testb %al, %al
je 0x1d16e
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x9792
testb %al, %al
je 0x1d1b8
movq %rbp, %rdi
movl %r15d, %esi
leaq 0x10(%rsp), %rdx
callq 0x1cb02
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
movl %eax, %edx
orl %ecx, %edx
js 0x1d16e
cmpl %ecx, %eax
jne 0x1d160
cmpl $0x1, %eax
je 0x1d167
testl %eax, %eax
jne 0x1d176
movq 0x18(%rsp), %rax
jmp 0x1d16c
movq 0x28(%rsp), %rax
jmp 0x1d16c
movq 0x20(%rsp), %rax
incl (%rax)
incq %r15
jmp 0x1d0ef
movq %r14, %rbx
movq %r14, %rdi
leaq 0x11910(%rip), %rsi     # 0x2ea93
leaq 0xf(%rsp), %rdx
callq 0x5160
leaq 0x2433c(%rip), %rdi     # 0x414d0
movq %rbx, %rsi
pushq $0x62
popq %rdx
callq 0x2bf18
movq %rbx, %rdi
callq 0x5908
jmp 0x1d16e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11227(%rip), %rdi     # 0x2e3e6
leaq 0x111b0(%rip), %rsi     # 0x2e376
leaq 0x11844(%rip), %rcx     # 0x2ea11
movl $0x1b1, %edx            # imm = 0x1B1
callq 0x52a0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x1d1eb
jmp 0x1d1f2
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5908
jmp 0x1d1f5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x450(%rdi), %rsi
subq 0x448(%rdi), %rsi
sarq $0x5, %rsi
incq %rsi
movq %rsp, %rbx
andl $0x0, (%rbx)
movq %rcx, 0x8(%rsp)
movq %rcx, %rdi
movq %rbx, %rdx
callq 0x1db12
movq 0x450(%r13), %rsi
subq 0x448(%r13), %rsi
sarq $0x5, %rsi
incq %rsi
andl $0x0, (%rbx)
movq %rsp, %rbx
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1db12
andq $0x0, (%rbx)
leaq 0x560(%r13), %rbp
xorl %ebx, %ebx
movl 0x8(%r13), %eax
cmpq %rax, %rbx
jae 0x1d36d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x9792
testb %al, %al
je 0x1d365
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9792
testb %al, %al
je 0x1d365
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x9792
testb %al, %al
je 0x1d37c
movq %r13, %rdi
movl %ebx, %esi
movq %rsp, %rdx
callq 0x1cb02
movq 0x450(%r13), %rdi
subq 0x448(%r13), %rdi
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rax
sete %sil
cmpq %rdx, %rcx
sete %dl
orb %sil, %dl
movq 0x10(%rsp), %rsi
movq (%rsi), %rsi
shrq $0x5, %rdi
movslq %edi, %rdi
leaq (,%rcx,4), %r8
movq 0x8(%rsp), %r9
addq (%r9), %r8
xorl %r9d, %r9d
cmpq %rdi, %r9
jg 0x1d365
movq %rax, %r10
xorq %r9, %r10
movq %rcx, %r11
xorq %r9, %r11
orq %r10, %r11
movq %r8, %r10
jne 0x1d33f
incl (%r10)
incq %r9
addq $0x4, %rsi
jmp 0x1d31a
cmpq %r9, %rax
jne 0x1d34d
movq %rsi, %r10
testb %dl, %dl
je 0x1d333
jmp 0x1d336
cmpq %r9, %rcx
sete %r11b
cmpl $-0x1, %eax
setne %r14b
movq %rsi, %r10
testb %r11b, %r14b
jne 0x1d333
jmp 0x1d336
incq %rbx
jmp 0x1d27b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11063(%rip), %rdi     # 0x2e3e6
leaq 0x10fec(%rip), %rsi     # 0x2e376
leaq 0x1171d(%rip), %rcx     # 0x2eaae
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x52a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xcc7c
leaq 0x428(%r14), %r15
leaq 0x11a2d(%rip), %rsi     # 0x2ee37
movq %r15, %rdi
callq 0x12f17
xorl %ebp, %ebp
testb %al, %al
je 0x1d445
leaq 0x10d0e(%rip), %rsi     # 0x2e12d
movq %r15, %rdi
callq 0x12f17
testb %al, %al
je 0x1d445
leaq 0xfc92(%rip), %rsi      # 0x2d0c4
movq %r15, %rdi
callq 0x12f17
testb %al, %al
je 0x1d445
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_O2/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_n_allele_info(std::vector<char, std::allocator<char>>&) const
void entry::get_n_allele_info(vector<char> &out) const
{
	out.resize(sizeof(uint32_t));
	uint32_t n_allele_info = (uint32_t)ALT.size() + 1;
	uint32_t n_info = (uint32_t)(INFO.size()-N_INFO_removed);

	n_allele_info = n_allele_info << 16;
	n_allele_info = n_allele_info | n_info;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xcc7c
movl 0x450(%r14), %eax
subl 0x448(%r14), %eax
movq 0x488(%r14), %rcx
subq 0x480(%r14), %rcx
shrq $0x6, %rcx
subl 0x4c8(%r14), %ecx
andl $-0x20, %eax
shll $0xb, %eax
addl $0x10000, %eax          # imm = 0x10000
orl %ecx, %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xcc7c
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_O2/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)
andq $0x0, 0x10(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xcc7c
leaq 0x428(%r14), %rdx
movq %rsp, %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x1a12e
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
xorl %r12d, %r12d
movq %rsp, %r15
pushq $0x1
popq %rbp
movl %r12d, %r12d
movq 0x450(%r14), %rax
subq 0x448(%r14), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x1d5e1
movq %r15, %rdi
xorl %esi, %esi
callq 0xcc7c
movq %r12, %rdx
shlq $0x5, %rdx
addq 0x448(%r14), %rdx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x1a12e
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
incl %r12d
jmp 0x1d588
movq %rsp, %rdi
callq 0xe88a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d5fc
jmp 0x1d5fc
jmp 0x1d5fc
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe88a
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x104ba(%rip), %rsi     # 0x2e12d
movq %r14, %rdi
callq 0x12f17
testb %al, %al
je 0x1dd44
leaq 0x448(%rbx), %r15
movq 0x448(%rbx), %rdi
movq 0x450(%rbx), %rsi
movq %r14, %rdx
callq 0x1de0a
cmpq 0x450(%rbx), %rax
je 0x1dd39
leaq 0x3e0(%rbx), %rdx
leaq 0x10e7e(%rip), %rsi     # 0x2eb39
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x967d
leaq 0x1131e(%rip), %rdx     # 0x2efed
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x98b6
movl 0x400(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x2c1fc
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x9be3
leaq 0x237c9(%rip), %rdi     # 0x414d0
leaq 0x48(%rsp), %rsi
callq 0x2c0bc
leaq 0x48(%rsp), %rdi
callq 0x5908
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x28(%rsp), %rdi
callq 0x5908
leaq 0x68(%rsp), %rdi
callq 0x5908
movq %r15, %rdi
movq %r14, %rsi
callq 0xfda2
movb $0x1, 0x3da(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5908
jmp 0x1dd6c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0x1dd7b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
jmp 0x1dd8a
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %edx, %ebp
movq %rdi, %r14
addq $0x5b0, %rdi            # imm = 0x5B0
movl %esi, %ebx
movq %rbx, %rsi
callq 0x9cc0
orq %rdx, (%rax)
movq 0x530(%r14), %rax
movq 0x538(%r14), %rcx
cmpl $-0x1, %ebp
je 0x1ddf6
cmpq %rcx, %rax
jne 0x1ddfe
leaq 0x530(%r14), %rdi
movl 0x8(%r14), %esi
leaq 0xc(%rsp), %rdx
orl $-0x1, (%rdx)
callq 0x98fa
movq 0x530(%r14), %rax
jmp 0x1ddfe
cmpq %rcx, %rax
je 0x1de01
pushq $-0x1
popq %rbp
movl %ebp, (%rax,%rbx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x5770
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x448(%rbx), %rdi
xorl %esi, %esi
callq 0xfd72
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
pushq $0x2c
popq %rbp
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x48(%rsp,%rax)
jne 0x1df67
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5870
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1dc58
jmp 0x1df3d
movb $0x1, 0x3da(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x28(%rsp), %rdi
callq 0x5910
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1df92
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x28(%rsp), %rdi
callq 0x5910
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movq %rdi, %rbx
movq 0x500(%rdi), %rax
cmpq %rax, 0x508(%rdi)
jne 0x1e612
leaq 0x500(%rbx), %rdi
movl 0x8(%rbx), %esi
leaq 0xf(%rsp), %rdx
movb $0x2f, (%rdx)
callq 0x1ee92
movq 0x500(%rbx), %rax
movl %r14d, %esi
movb %bpl, (%rax,%rsi)
addq $0x560, %rbx            # imm = 0x560
movq %rbx, %rdi
callq 0x9cc0
orq %rdx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
movq 0x4d0(%rdi), %rax
cmpq %rax, 0x4d8(%rdi)
jne 0x1e673
leaq 0x4d0(%rbx), %rdi
movl 0x8(%rbx), %esi
movq %rsp, %rdx
orq $-0x1, (%rdx)
callq 0x1ee5e
movq 0x4d0(%rbx), %rax
movsbl %r15b, %ecx
leal -0x30(%rcx), %edx
cmpb $0x2e, %cl
pushq $-0x1
popq %rcx
cmovel %ecx, %edx
movsbl %r14b, %esi
leal -0x30(%rsi), %edi
cmpb $0x2e, %sil
cmovel %ecx, %edi
movl %ebp, %esi
movl %edx, (%rax,%rsi,8)
movl %edi, 0x4(%rax,%rsi,8)
addq $0x560, %rbx            # imm = 0x560
movq %rbx, %rdi
callq 0x9cc0
orq %rdx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x4d8(%rdi), %rax
cmpq 0x4d0(%rdi), %rax
jne 0x1e6f4
leaq 0x4d0(%rbx), %rdi
movl 0x8(%rbx), %esi
leaq 0x8(%rsp), %rdx
orq $-0x1, (%rdx)
callq 0x1ee5e
leaq 0xfa32(%rip), %rsi      # 0x2e12d
movq %r14, %rdi
callq 0x12f17
pushq $-0x1
popq %r15
movl %r15d, %r12d
testb %al, %al
je 0x1e71c
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x12782
movl %eax, %r12d
addq $0x20, %r14
leaq 0xfa06(%rip), %rsi      # 0x2e12d
movq %r14, %rdi
callq 0x12f17
testb %al, %al
je 0x1e741
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x12782
movl %eax, %r15d
movl %ebp, %esi
movq 0x4d0(%rbx), %rax
movl %r12d, (%rax,%rsi,8)
movl %r15d, 0x4(%rax,%rsi,8)
addq $0x560, %rbx            # imm = 0x560
movq %rbx, %rdi
callq 0x9cc0
orq %rdx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
addq $0x4e8, %rdi            # imm = 0x4E8
movl 0x8(%r15), %esi
callq 0x9c6c
movl %ebp, %r12d
movq 0x4e8(%r15), %rax
movl $0x2, (%rax,%r12,4)
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x1e7de
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1e5d4
addq $0x560, %r15            # imm = 0x560
movq %r15, %rdi
movq %r12, %rsi
callq 0x9cc0
orq %rdx, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
addq $0x588, %rdi            # imm = 0x588
movl %esi, %ebx
movq %rbx, %rsi
callq 0x9cc0
movsd 0x8(%rsp), %xmm1
orq %rdx, (%rax)
ucomisd 0xf6b2(%rip), %xmm1     # 0x2df80
movq 0x518(%r14), %rax
movq 0x520(%r14), %rcx
jne 0x1e8ef
jp 0x1e8ef
cmpq %rax, %rcx
je 0x1e934
movsd 0xf693(%rip), %xmm0     # 0x2df80
jmp 0x1e92f
cmpq %rax, %rcx
jne 0x1e923
leaq 0x518(%r14), %rdi
movl 0x8(%r14), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
callq 0x992e
movsd 0x8(%rsp), %xmm1
movq 0x518(%r14), %rax
movsd 0x10235(%rip), %xmm0    # 0x2eb60
minsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rbx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r12
addq $0x5d8, %rdi            # imm = 0x5D8
movl %esi, %r15d
movq %r15, %rsi
callq 0x9cc0
orq %rdx, (%rax)
leaq 0x548(%r12), %rbx
movq 0x548(%r12), %rdi
cmpq %rdi, 0x550(%r12)
jne 0x1e991
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x1eec0
movq 0x548(%r12), %rdi
imulq $0x18, %r15, %r13
addq %r13, %rdi
xorl %esi, %esi
callq 0xfd72
cmpq $0x0, 0x8(%r14)
je 0x1e9b9
leaq 0xf780(%rip), %rsi      # 0x2e12d
movq %r14, %rdi
callq 0x96f3
testb %al, %al
je 0x1e9c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x236f2(%rip), %al      # 0x420c0
testb %al, %al
je 0x1ea69
movb 0x2370c(%rip), %al      # 0x420e8
testb %al, %al
je 0x1eab4
movq 0x23555(%rip), %rax     # 0x41f40
leaq 0x2354e(%rip), %r15     # 0x41f40
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x5790
leaq 0x23549(%rip), %rdi     # 0x41f50
movq %r14, %rsi
callq 0x5690
leaq 0x236b2(%rip), %r14     # 0x420c8
pushq $0x3b
popq %rbp
leaq 0xf70d(%rip), %r12      # 0x2e12d
movq 0x23519(%rip), %rax     # 0x41f40
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rax,%r15)
jne 0x1e9b9
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5870
cmpq $0x0, 0x23688(%rip)     # 0x420d0
je 0x1ea20
movq %r14, %rdi
movq %r12, %rsi
callq 0x96f3
testb %al, %al
jne 0x1ea20
movq (%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0xfda2
jmp 0x1ea20
leaq 0x23650(%rip), %rdi     # 0x420c0
callq 0x5850
testl %eax, %eax
je 0x1e9d6
leaq 0x234bc(%rip), %rdi     # 0x41f40
callq 0x5330
movq 0x22520(%rip), %rdi     # 0x40fb0
leaq 0x234a9(%rip), %rsi     # 0x41f40
leaq 0x229e2(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x23616(%rip), %rdi     # 0x420c0
callq 0x5290
jmp 0x1e9d6
leaq 0x2362d(%rip), %rdi     # 0x420e8
callq 0x5850
testl %eax, %eax
je 0x1e9e4
leaq 0x23609(%rip), %rax     # 0x420d8
movq %rax, 0x235f2(%rip)     # 0x420c8
leaq 0x235eb(%rip), %rsi     # 0x420c8
andq $0x0, 0x235eb(%rip)     # 0x420d0
movb $0x0, 0x235ec(%rip)     # 0x420d8
movq 0x224b5(%rip), %rdi     # 0x40fa8
leaq 0x22986(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x235e2(%rip), %rdi     # 0x420e8
callq 0x5290
jmp 0x1e9e4
movq %rax, %rbx
leaq 0x235a6(%rip), %rdi     # 0x420c0
callq 0x5270
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
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 0xfd72
leaq 0xf5d8(%rip), %rsi      # 0x2e12d
movq %r12, %rdi
callq 0x12f17
testb %al, %al
je 0x1ebc7
leaq 0x20(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5770
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %r12
pushq $0x3b
popq %rbp
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x1ebb5
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x5870
movq %r14, %rdi
movq %r12, %rsi
callq 0xfda2
jmp 0x1eb8b
movq %rsp, %rdi
callq 0x5908
leaq 0x20(%rsp), %rdi
callq 0x5910
movq 0x468(%rbx), %rdi
movq 0x470(%rbx), %rsi
callq 0x1f6a6
movb $0x1, 0x3db(%rbx)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5908
leaq 0x20(%rsp), %rdi
callq 0x5910
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_INFO(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_INFO(const string &INFO_str)
{
	INFO.resize(0);
	if ((INFO_str.size() > 0) && (INFO_str != "."))
	{
		istringstream ss(INFO_str);
		string tmpstr;
		while(!ss.eof())
		{
			getline(ss, tmpstr, ';');

			istringstream ss2(tmpstr);
			getline(ss2, tmpstr, '=');
			pair<string, string> INFO_entry(tmpstr, ".");

			if (!ss2.eof())
			{	// If there is a value entry, read it now
				getline(ss2, tmpstr);
				INFO_entry.second = tmpstr;
			}
			else	// Otherwise, set it equal to 1
				INFO_entry.second = "1";

			INFO.push_back(INFO_entry);
		}
	}
	parsed_INFO = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
movq %rsi, %rbx
movq %rdi, (%rsp)
leaq 0x480(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1eef6
cmpq $0x0, 0x8(%rbx)
je 0x1ed5b
leaq 0xf4e4(%rip), %rsi      # 0x2e12d
movq %rbx, %rdi
callq 0x12f17
testb %al, %al
je 0x1ed5b
leaq 0x68(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x5770
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r13
leaq 0x1e8(%rsp), %r15
pushq $0x3d
popq %rbp
leaq 0xf49c(%rip), %r12      # 0x2e12d
leaq 0x28(%rsp), %rbx
movq 0x68(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x88(%rsp,%rax)
jne 0x1ed47
leaq 0x68(%rsp), %rdi
movq %r13, %rsi
pushq $0x3b
popq %rdx
callq 0x5870
movq %r15, %rdi
movq %r13, %rsi
pushq $0x8
popq %rdx
callq 0x5770
movq %r15, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x5870
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1ef26
movq 0x1e8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x208(%rsp,%rax)
jne 0x1ed16
movq %r15, %rdi
movq %r13, %rsi
callq 0x5090
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x5210
jmp 0x1ed27
leaq 0x48(%rsp), %rdi
leaq 0xe351(%rip), %rsi      # 0x2d073
callq 0x58b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d664
movq %rbx, %rdi
callq 0x1665a
movq %r15, %rdi
callq 0x5910
jmp 0x1ec96
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x68(%rsp), %rdi
callq 0x5910
movq (%rsp), %rax
movb $0x1, 0x3dc(%rax)
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ed7c
jmp 0x1ed81
movq %rax, %rbx
jmp 0x1eda0
movq %rax, %rbx
jmp 0x1ed93
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1665a
leaq 0x1e8(%rsp), %rdi
callq 0x5910
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x68(%rsp), %rdi
callq 0x5910
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
addq $0x448, %rdi            # imm = 0x448
decl %esi
movslq %esi, %r15
movq %rdi, 0x10(%rsp)
movq %r15, %rsi
callq 0xfd72
movl 0x6f0(%rbx), %eax
leaq 0x4(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rbx, 0x8(%rsp)
leaq 0x3c0(%rbx), %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
movq %r15, 0x20(%rsp)
leaq 0x48(%rsp), %rbp
leaq 0x28(%rsp), %rbx
cmpq 0x20(%rsp), %r14
je 0x2001e
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x1b356
movq %rbx, %r12
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5580
movq %rbp, %rdi
callq 0x5908
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %r13
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x1ffff
movsbl (%rbx,%r15), %edi
callq 0x5880
movb %al, (%rbx,%r15)
incq %r15
jmp 0x1ffe7
movq %r14, %rdi
shlq $0x5, %rdi
movq 0x10(%rsp), %rax
addq (%rax), %rdi
movq %r12, %rbx
movq %r12, %rsi
callq 0x5210
incq %r14
jmp 0x1ffa6
movq 0x8(%rsp), %rax
movb $0x1, 0x3da(%rax)
leaq 0x28(%rsp), %rdi
callq 0x5908
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20045
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 0xfda2
movl (%rbx), %r12d
leaq 0x600(%r14), %rdi
movq %rbp, %rsi
callq 0x1634c
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 0x20a4e
leaq 0xe1b2(%rip), %rcx      # 0x2ebdc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %eax
jmp 0x20a42
movl (%rsi), %eax
shll $0x2, %eax
jmp 0x20a42
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_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x4d0(%rdi), %rax
cmpq %rax, 0x4d8(%rdi)
jne 0x20d03
leaq 0x4d0(%rbx), %rdi
movl 0x8(%rbx), %esi
leaq 0x8(%rsp), %rdx
orq $-0x1, (%rdx)
callq 0x1ee5e
movq 0x4d0(%rbx), %rax
movl %ebp, %esi
movq (%r14), %rcx
movq %rcx, (%rax,%rsi,8)
addq $0x560, %rbx            # imm = 0x560
movq %rbx, %rdi
callq 0x9cc0
orq %rdx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GENOTYPE_and_PHASE(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&, char)
void bcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<string, string> &genotype, char phase)
{
	pair<int, int> a(-1,-1);
	if (genotype.first != ".")
		a.first = header::str2int(genotype.first);
	if (genotype.second != ".")
		a.second = header::str2int(genotype.second);

	set_indv_GENOTYPE_alleles(indv, a);
	set_indv_PHASE(indv, phase);
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
orq $-0x1, (%rsp)
leaq 0xd2f5(%rip), %rsi      # 0x2e12d
movq %rdx, %rdi
callq 0x12f17
testb %al, %al
je 0x20e52
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x12782
movl %eax, (%rsp)
addq $0x20, %r15
leaq 0xd2d0(%rip), %rsi      # 0x2e12d
movq %r15, %rdi
callq 0x12f17
testb %al, %al
je 0x20e78
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x12782
movl %eax, 0x4(%rsp)
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x20cc4
movsbl %r14b, %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x20d28
addq $0x560, %rbx            # imm = 0x560
movl %ebp, %esi
movq %rbx, %rdi
callq 0x9cc0
orq %rdx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GQUALITY(unsigned int, std::vector<char, std::allocator<char>> const&)
void bcf_entry::set_indv_GQUALITY(unsigned int indv, const vector<char> &in)
{
	float tmp;
	memcpy(&tmp, &in[0], sizeof(tmp));

	parsed_GQ[indv] = true;
	if (tmp == 0x7F800001)
	{
		if (GQUALITY.size() > 0)
			GQUALITY[indv] = -1;
		return;
	}
	if (GQUALITY.size() == 0)
		GQUALITY.resize(N_indv, -1);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdx), %rax
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
addq $0x588, %rdi            # imm = 0x588
movl %esi, %ebx
movq %rbx, %rsi
callq 0x9cc0
movss 0xc(%rsp), %xmm1
orq %rdx, (%rax)
ucomiss 0xd2f6(%rip), %xmm1     # 0x2e1e0
movq 0x518(%r14), %rax
movq 0x520(%r14), %rcx
jne 0x20f0b
jp 0x20f0b
cmpq %rax, %rcx
je 0x20f54
movsd 0xd077(%rip), %xmm0     # 0x2df80
jmp 0x20f4f
cmpq %rax, %rcx
jne 0x20f3f
leaq 0x518(%r14), %rdi
movl 0x8(%r14), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
callq 0x992e
movss 0xc(%rsp), %xmm1
movq 0x518(%r14), %rax
movss 0xdcb5(%rip), %xmm0     # 0x2ebfc
minss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rax,%rbx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GQUALITY(unsigned int, float const&)
void bcf_entry::set_indv_GQUALITY(unsigned int indv, const float &in)
{
	parsed_GQ[indv] = true;
	if ( (in == -1) or (in == 0x7F800001) )
	{
		if (GQUALITY.size() > 0)
			GQUALITY[indv] = -1;
		return;
	}
	if (GQUALITY.size() == 0)
		GQUALITY.resize(N_indv, -1);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r15
addq $0x588, %rdi            # imm = 0x588
movl %esi, %ebx
movq %rbx, %rsi
callq 0x9cc0
orq %rdx, (%rax)
movss (%r14), %xmm0
ucomiss 0xdc76(%rip), %xmm0     # 0x2ec00
movq 0x518(%r15), %rax
movq 0x520(%r15), %rcx
jne 0x20f9c
jnp 0x20feb
ucomiss 0xd23d(%rip), %xmm0     # 0x2e1e0
jne 0x20fa7
jnp 0x20feb
leaq 0x518(%r15), %r12
cmpq %rax, %rcx
jne 0x20fd4
movl 0x8(%r15), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rsp, %rdx
movq %rax, (%rdx)
movq %r12, %rdi
callq 0x992e
movss (%r14), %xmm0
ucomiss 0xdc21(%rip), %xmm0     # 0x2ebfc
jbe 0x20ffa
movq (%r12), %rax
movsd 0xdb77(%rip), %xmm0     # 0x2eb60
jmp 0x21002
cmpq %rax, %rcx
je 0x21007
movsd 0xcf88(%rip), %xmm0     # 0x2df80
jmp 0x21002
cvtss2sd %xmm0, %xmm0
movq (%r12), %rax
movsd %xmm0, (%rax,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop