LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq $-0x1, (%rsp)
leaq 0x11111(%rip), %rsi     # 0x391ed
movq %rdx, %rdi
callq 0x50e0
testl %eax, %eax
je 0x280f8
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16afa
movl %eax, (%rsp)
addq $0x20, %r15
leaq 0x110ea(%rip), %rsi     # 0x391ed
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x28120
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16afa
movl %eax, 0x4(%rsp)
movq %rsp, %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x27f4a
movsbl %bpl, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x27fbc
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/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
movl %esi, %ebx
movq (%rdx), %rax
movss (%rax), %xmm1
movq 0x588(%rdi), %rax
movl %esi, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
ucomiss 0x1110f(%rip), %xmm1    # 0x392a0
movq 0x518(%rdi), %rax
movq 0x520(%rdi), %rcx
jne 0x281b2
jp 0x281b2
cmpq %rax, %rcx
je 0x28206
movsd 0x10e90(%rip), %xmm0    # 0x39040
jmp 0x281ff
cmpq %rax, %rcx
jne 0x281ef
movq %rdi, %r14
addq $0x518, %rdi            # imm = 0x518
movl 0x8(%r14), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movss %xmm1, 0xc(%rsp)
callq 0xbaf8
movss 0xc(%rsp), %xmm1
movq 0x518(%r14), %rax
movss 0x11a9d(%rip), %xmm0    # 0x39c94
minss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdx, %r14
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)
movss (%r14), %xmm0
ucomiss 0x11a56(%rip), %xmm0    # 0x39c98
movq 0x518(%rdi), %rax
movq 0x520(%rdi), %rcx
jne 0x28254
jnp 0x282a3
ucomiss 0x11045(%rip), %xmm0    # 0x392a0
jne 0x2825f
jnp 0x282a3
leaq 0x518(%rdi), %r15
cmpq %rax, %rcx
jne 0x2828d
movl 0x8(%rdi), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r15, %rdi
callq 0xbaf8
movss (%r14), %xmm0
ucomiss 0x11a00(%rip), %xmm0    # 0x39c94
jbe 0x282b2
movq (%r15), %rax
movsd 0x11957(%rip), %xmm0    # 0x39bf8
jmp 0x282b9
cmpq %rax, %rcx
je 0x282c0
movsd 0x10d90(%rip), %xmm0    # 0x39040
jmp 0x282b9
cvtss2sd %xmm0, %xmm0
movq (%r15), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_FILTER()
void bcf_entry::set_FILTER()
{
	FILTER_str = get_int_vector( &FILTER_pos, line );
	FILTER.resize(0);

	if ( (FILTER_str.size() == 1) and entry_header.FILTER_map[ FILTER_str[0] ].ID == "")
	{
		FILTER.push_back("PASS");
		return;
	}

	for (unsigned int ui=0; ui<FILTER_str.size(); ui++)
	{
		if ((int8_t)FILTER_str[ui] != (int8_t)0x80)
			FILTER.push_back( entry_header.FILTER_map[ FILTER_str[ui] ].ID );
		else
			FILTER.push_back( "." );
	}
	sort(FILTER.begin(), FILTER.end());
	parsed_FILTER = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x6ec(%rdi), %rdx
leaq 0x3c0(%rdi), %rcx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21570
movq 0x6d0(%rbx), %rdi
movaps (%r14), %xmm0
movups %xmm0, 0x6d0(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x6e0(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x28795
callq 0x5410
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x28795
callq 0x5410
leaq 0x468(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1300e
movq 0x6d0(%rbx), %rsi
movq 0x6d8(%rbx), %rax
movq %rax, %rcx
subq %rsi, %rcx
cmpq $0x4, %rcx
jne 0x287f2
leaq 0xa0(%rbx), %rdi
callq 0x17782
leaq 0x20(%rax), %rdi
leaq 0x11700(%rip), %rsi     # 0x39ed7
callq 0x50e0
testl %eax, %eax
je 0x288e3
movq 0x6d0(%rbx), %rsi
movq 0x6d8(%rbx), %rax
cmpq %rsi, %rax
je 0x2888d
leaq 0xa0(%rbx), %r15
movl $0x1, %r13d
xorl %r12d, %r12d
movq %rsp, %rbp
xorl %eax, %eax
cmpb (%rsi,%rax,4), %r12b
jno 0x28855
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
leaq 0x109c4(%rip), %rsi     # 0x391ed
leaq 0x109be(%rip), %rdx     # 0x391ee
callq 0xc85e
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1341e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2886d
callq 0x5410
jmp 0x2886d
leaq (%rsi,%rax,4), %rsi
movq %r15, %rdi
callq 0x17782
leaq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x13084
movl %r13d, %eax
movq 0x6d0(%rbx), %rsi
movq 0x6d8(%rbx), %rcx
subq %rsi, %rcx
sarq $0x2, %rcx
incl %r13d
cmpq %rax, %rcx
ja 0x28810
movq 0x468(%rbx), %r14
movq 0x470(%rbx), %r15
cmpq %r15, %r14
je 0x288cd
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 $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfcc6(%rip), %rsi      # 0x385b9
leaq 0xfcc3(%rip), %rdx      # 0x385bd
movq %rsp, %rdi
callq 0xc85e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1341e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x288d4
callq 0x5410
jmp 0x288d4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x28943
jmp 0x28948
jmp 0x2892d
movq %rax, %rbx
jmp 0x28948
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x28948
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_allele_type(bool, bool)
void entry::filter_sites_by_allele_type(bool keep_only_indels, bool remove_indels)
{
	if (passed_filters == false)
		return;

	if ((keep_only_indels == false) && (remove_indels == false))
		return;
	if ((keep_only_indels == true) && (remove_indels == true))
		LOG.error("Can't both keep and remove all indels!");

	string allele;
	unsigned int ref_len, N_alleles;
	bool is_indel;

	parse_basic_entry(true);
	is_indel = false;
	allele = REF;
	ref_len = allele.size();
	if (ref_len != 1)
		is_indel = true;
	N_alleles = get_N_alleles();
	for (unsigned int ui=1; ui<N_alleles; ui++)
	{
		get_allele(ui, allele);
		if (allele.size() != ref_len)
		{
			is_indel = true;
			break;
		}
	}

	if (keep_only_indels == true)
	{
		if (is_indel == false)
			passed_filters = false;
	}
	else if (remove_indels == true)
	{
		if (is_indel == true)
			passed_filters = false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, %r14d
movl %r14d, %eax
orb %bpl, %al
cmpb $0x1, %al
jne 0x28d52
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x28d52
movl %r14d, %eax
andb %bpl, %al
cmpb $0x1, %al
jne 0x28c98
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x112c1(%rip), %rsi     # 0x39f22
leaq 0x112e0(%rip), %rdx     # 0x39f48
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xc85e
leaq 0x2082c(%rip), %rdi     # 0x494a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x36ec8
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x28c98
callq 0x5410
movl %ebp, 0x4(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x428(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x51f0
movl 0x10(%rsp), %ebp
cmpq $0x1, %rbp
setne 0x3(%rsp)
movq %rbx, %rdi
callq 0x22eb0
movl %eax, %r15d
cmpl $0x2, %eax
jb 0x28d18
movl $0x1, %r12d
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x21e8e
cmpq %rbp, 0x10(%rsp)
jne 0x28d24
incl %r12d
cmpl %r12d, %r15d
jne 0x28cfb
testb %r14b, %r14b
je 0x28d2e
cmpl $0x1, %ebp
je 0x28d3a
jmp 0x28d3e
movb $0x1, 0x3(%rsp)
testb %r14b, %r14b
jne 0x28d3e
movb 0x3(%rsp), %al
andb 0x4(%rsp), %al
cmpb $0x1, %al
jne 0x28d3e
movb $0x0, 0xc(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x28d52
callq 0x5410
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
jne 0x28d84
jmp 0x28d89
jmp 0x28d72
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x28d89
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void entry::filter_sites(const set<string> &snps_to_keep, const string &snps_to_keep_file, const string &snps_to_exclude_file, bool keep_then_exclude)
{
	// Filter sites by user provided lists
	if (keep_then_exclude)
	{
		filter_sites_to_keep(snps_to_keep, snps_to_keep_file);
		filter_sites_to_exclude(snps_to_exclude_file);
	}
	else
	{
		filter_sites_to_exclude(snps_to_exclude_file);
		filter_sites_to_keep(snps_to_keep, snps_to_keep_file);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
testl %r8d, %r8d
je 0x28dcc
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2beaa
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2c0a6
movq %r14, %rsi
callq 0x2c0a6
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2beaa
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_position(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
void entry::filter_sites_by_position(const string &chr, int start_pos, int end_pos)
{
	// Filter sites by user provided position range
	if (passed_filters == false)
		return;

	if ((chr == "") || ((start_pos == -1) && (end_pos==numeric_limits<int>::max())))
		return;

	parse_basic_entry();

	if (CHROM == chr)
	{
		if ((POS < start_pos) || (POS > end_pos))
			passed_filters = false;
	}
	else
		passed_filters = false;
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x2900b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10f40(%rip), %rsi     # 0x39ed7
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x29001
movl %r14d, %eax
notl %eax
movl %ebp, %ecx
xorl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl %eax, %ecx
je 0x29001
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq 0x3e8(%rbx), %rdx
cmpq 0x8(%r15), %rdx
jne 0x28ffd
testq %rdx, %rdx
je 0x28fe8
movq (%r15), %rsi
movq 0x3e0(%rbx), %rdi
callq 0x5470
testl %eax, %eax
jne 0x28ffd
movl 0x400(%rbx), %eax
cmpl %r14d, %eax
setge %cl
cmpl %ebp, %eax
setle %al
testb %al, %cl
jne 0x29001
movb $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_chromosome(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&, 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&)
void entry::filter_sites_by_chromosome(const set<string> &chrs_to_keep, const set<string> &chrs_to_exclude)
{
	if (passed_filters == false)
		return;

	if (chrs_to_keep.empty() && chrs_to_exclude.empty())
		return;

	parse_basic_entry();

	if (!chrs_to_keep.empty())
	{
		if (chrs_to_keep.find(CHROM) == chrs_to_keep.end())
			passed_filters = false;
	}
	else
	{
		if (chrs_to_exclude.find(CHROM) != chrs_to_exclude.end())
			passed_filters = false;
	}
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x29fc2
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x28(%rdx), %rax
orq 0x28(%rsi), %rax
je 0x29fbd
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x3e0(%rbx), %rsi
cmpq $0x0, 0x28(%r15)
je 0x29fc3
movq %r15, %rdi
callq 0x1b8cc
addq $0x8, %r15
cmpq %r15, %rax
jne 0x29fbd
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1b8cc
addq $0x8, %r14
cmpq %r14, %rax
jne 0x29fb9
jmp 0x29fbd
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_number_of_alleles(int, int)
void entry::filter_sites_by_number_of_alleles(int min_alleles, int max_alleles)
{
	// Filter sites by the number of alleles (e.g. 2 for bi-allelic)
	if (passed_filters == false)
		return;

	if ((min_alleles <= 0) && (max_alleles == numeric_limits<int>::max()))
		return;

	int N_alleles;
	parse_basic_entry(true);
	N_alleles = get_N_alleles();
	if ((N_alleles < min_alleles) || (N_alleles > max_alleles))
		passed_filters = false;
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x2abd6
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
testl %esi, %esi
setle %al
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %cl
testb %cl, %al
jne 0x2abd2
movq %rdi, %rbx
movq (%rdi), %rax
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq %rbx, %rdi
callq 0x22eb0
cmpl %r14d, %eax
setge %cl
cmpl %ebp, %eax
setle %al
testb %al, %cl
jne 0x2abd2
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_quality(double)
void entry::filter_sites_by_quality(double min_quality)
{
	// Filter sites by quality
	if (passed_filters == false)
		return;

	if (min_quality < 0)
		return;

	parse_basic_entry(true);

	string alt_allele = get_ALT_allele(0);
	// The QUAL field has different definitions depending on the state of the
	// alternative allele. Here I treat them separately, although in this case
	// it is unnecessary.
	if ((alt_allele == ".") || (alt_allele == ""))
	{	// The case that the alternative allele is unknown
		// QUAL is -10log_10 p(variant)
			if (QUAL < min_quality)
				passed_filters = false;
	}
	else
	{	// The normal case
		// QUAL is -10log_10 p(no variant)
		if (QUAL < min_quality)
			passed_filters = false;
	}
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x2b08e
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2b087
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2201a
leaq 0xe1ab(%rip), %rsi      # 0x391ed
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x2b061
leaq 0xee82(%rip), %rsi      # 0x39ed7
leaq 0x8(%rsp), %rdi
callq 0x50e0
testl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x460(%rbx), %xmm0
jbe 0x2b074
movb $0x0, 0xc(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b087
callq 0x5410
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_mean_depth(double, double)
void entry::filter_sites_by_mean_depth(double min_mean_depth, double max_mean_depth)
{
	// Filter sites by mean depth
	if (passed_filters == false)
		return;

	if ((min_mean_depth <= 0) && (max_mean_depth == numeric_limits<double>::max()))
		return;

	int depth;

	unsigned int N_indv_included = 0;
	double depth_sum = 0.0;
	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if (include_indv[ui] == false)
			continue;

		if (include_genotype[ui] == true)
		{
			parse_genotype_entry(ui, false, false, true);

			if (entry_header.has_genotypes == false)
				LOG.error("Require Genotypes in VCF file in order to filter sites by mean depth");

			depth = get_indv_DEPTH(ui);
			if (depth >= 0)
			{
				depth_sum += depth;
			}
			N_indv_included++;
		}
	}
	double mean_depth = depth_sum / N_indv_included;

	if ((mean_depth < min_mean_depth) || (mean_depth > max_mean_depth))
		passed_filters = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
cmpb $0x0, 0xc(%rdi)
je 0x2b1f6
movq %rdi, %rbx
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
jb 0x2b0d7
movsd (%rsp), %xmm0
ucomisd 0xcf71(%rip), %xmm0     # 0x38040
jne 0x2b0d7
jnp 0x2b1f6
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x2b1d7
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
leaq 0x28(%rsp), %r14
leaq 0x18(%rsp), %r12
leaq 0x1e3ae(%rip), %r13     # 0x494a8
xorl %ebp, %ebp
movq 0x1f0(%rbx), %rsi
movl $0x1, %edx
movl %ebp, %ecx
shlq %cl, %rdx
movl %ebp, %ecx
shrl $0x6, %ecx
movq (%rsi,%rcx,8), %rsi
btq %rbp, %rsi
jae 0x2b1bc
movq 0x218(%rbx), %rsi
testq %rdx, (%rsi,%rcx,8)
je 0x2b1bc
movsd %xmm1, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x2b18f
movq %r14, 0x18(%rsp)
movq %r12, %rdi
leaq 0xecbc(%rip), %rsi      # 0x39e20
leaq 0xecf9(%rip), %rdx      # 0x39e64
callq 0xc85e
movq %r13, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x36ec8
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b18f
callq 0x5410
movq %rbx, %rdi
movl %ebp, %esi
callq 0x22bdc
testl %eax, %eax
js 0x2b1b0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
jmp 0x2b1b6
movsd 0x10(%rsp), %xmm1
incl %r15d
movl 0x8(%rbx), %eax
incl %ebp
cmpl %eax, %ebp
jb 0x2b0fc
movl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
jmp 0x2b1df
movsd 0xeb09(%rip), %xmm1     # 0x39ce8
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x2b1f2
ucomisd (%rsp), %xmm1
jbe 0x2b1f6
movb $0x0, 0xc(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b217
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_phase()
void entry::filter_sites_by_phase()
{
	// Filter out sites with unphased entries
	// TODO: Alter this to allow for a max/min level of unphased-ness.
	if (passed_filters == false)
		return;

	unsigned int count_unphased = 0;
	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if (include_indv[ui] == false)
			continue;

		parse_genotype_entry(ui, true);

		if (get_indv_PHASE(ui) != '|')
			count_unphased++;
	}

	if (count_unphased > 0)
		passed_filters = false;
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x2b668
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x2b664
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x1f0(%rbx), %rcx
movl %r14d, %edx
shrl $0x6, %edx
movq (%rcx,%rdx,8), %rcx
btq %r14, %rcx
jae 0x2b654
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x22b98
xorl %ecx, %ecx
cmpb $0x7c, %al
setne %cl
addl %ecx, %ebp
movl 0x8(%rbx), %eax
incl %r14d
cmpl %eax, %r14d
jb 0x2b60d
testl %ebp, %ebp
je 0x2b664
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_genotypes_by_quality_value(double)
void entry::filter_genotypes_by_quality_value(double min_genotype_quality)
{
	// Filter genotypes by quality
	if (passed_filters == false)
		return;

	if (min_genotype_quality <= 0)
		return;

	parse_genotype_entries(false, true);

	if (entry_header.has_genotypes == false)
		LOG.error("Require Genotypes in variant file in order to filter genotypes by Quality.");

	filter_genotypes_by_quality(min_genotype_quality);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2b701
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2b701
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x2b6f2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe63d(%rip), %rsi      # 0x39cf8
leaq 0xe680(%rip), %rdx      # 0x39d42
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xc85e
leaq 0x1ddd2(%rip), %rdi     # 0x494a8
movq %r14, %rsi
movl $0x1, %edx
callq 0x36ec8
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b6f2
callq 0x5410
movq (%rbx), %rax
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq *0x58(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b71d
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_genotypes_by_depth_range(int, int)
void entry::filter_genotypes_by_depth_range(int min_depth, int max_depth)
{
	// Filter genotypes by depth
	if (passed_filters == false)
		return;

	if ((min_depth <= 0) && (max_depth == numeric_limits<int>::max()))
		return;
	if (entry_header.has_genotypes == false)
		LOG.error("Require Genotypes in variant file in order to filter genotypes by Depth.");

	parse_genotype_entries(false, false, true);
	filter_genotypes_by_depth(min_depth, max_depth);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0xc(%rdi)
je 0x2b7c2
movl %edx, %ebx
movl %esi, %ebp
testl %esi, %esi
setle %al
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %cl
testb %cl, %al
jne 0x2b7c2
movq %rdi, %r14
cmpb $0x0, 0x15(%rdi)
jne 0x2b7a0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe5d7(%rip), %rsi      # 0x39d43
leaq 0xe618(%rip), %rdx      # 0x39d8b
movq %rsp, %r15
movq %r15, %rdi
callq 0xc85e
leaq 0x1dd23(%rip), %rdi     # 0x494a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x36ec8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2b7a0
callq 0x5410
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq *0x50(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2b7e0
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_genotypes_by_filter_flag(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)
void entry::filter_genotypes_by_filter_flag(const set<string> &filter_flags_to_remove, bool remove_all)
{
	// Filter genotypes by Filter Flags
	if (passed_filters == false)
		return;

	if ((remove_all == false) && (filter_flags_to_remove.empty()))
		return;

	parse_genotype_entries(false, false, false, true);
	if (entry_header.has_genotypes == false)
		LOG.error("Require Genotypes in variant file in order to filter genotypes by Filter Flag.");

	filter_genotypes_by_filter_status(filter_flags_to_remove, remove_all);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0xc(%rdi)
je 0x2b883
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testb %bpl, %bpl
jne 0x2b812
cmpq $0x0, 0x28(%rbx)
je 0x2b883
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%r14)
jne 0x2b873
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe54d(%rip), %rsi      # 0x39d8c
leaq 0xe594(%rip), %rdx      # 0x39dda
movq %rsp, %r15
movq %r15, %rdi
callq 0xc85e
leaq 0x1dc50(%rip), %rdi     # 0x494a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x36ec8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2b873
callq 0x5410
movq (%r14), %rax
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2b8a1
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_HWE_pvalue(double)
void entry::filter_sites_by_HWE_pvalue(double min_HWE_pvalue)
{
	// Filter sites by HWE p-value
	// Note this assumes Biallelic SNPs.
	if(passed_filters == false)
		return;

	if (min_HWE_pvalue <= 0)
		return;

	unsigned int b11, b12, b22;
	double p_hwe, p_lo, p_hi;

	parse_basic_entry(true);
	parse_genotype_entries(true);

	if (entry_header.has_genotypes == false)
		LOG.error("Require Genotypes in variant file to filter sites by HWE.");

	get_genotype_counts(b11, b12, b22);
	entry::SNPHWE(b12, b11, b22, p_hwe, p_lo, p_hi);

	if (p_hwe < min_HWE_pvalue)
		passed_filters = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2bdf0
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2bdf0
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x2bd9e
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe233(%rip), %rsi      # 0x39f9a
leaq 0xe265(%rip), %rdx      # 0x39fd3
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xc85e
leaq 0x1d726(%rip), %rdi     # 0x494a8
movq %r14, %rsi
movl $0x1, %edx
callq 0x36ec8
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bd9e
callq 0x5410
leaq 0x1c(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x23432
movl (%r15), %edi
movl (%r14), %esi
movl (%r12), %edx
leaq 0x50(%rsp), %r14
leaq 0x48(%rsp), %r8
leaq 0x40(%rsp), %r9
movq %r14, %rcx
callq 0x1f694
movsd 0x8(%rsp), %xmm0
ucomisd (%r14), %xmm0
jbe 0x2bdf0
movb $0x0, 0xc(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2be0e
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_thinning(int)
void entry::filter_sites_by_thinning(int min_SNP_distance)
{
	// Filter sites so that no two SNPs are within some minimum distance
	if (passed_filters == false)
		return;

	if (min_SNP_distance < 1)
		return;

	parse_basic_entry();
	if (CHROM == thin_chrom)
	{
		int distance_from_last_SNP = POS - thin_pos;
		if (distance_from_last_SNP < min_SNP_distance)
			passed_filters = false;
	}
	if (passed_filters == true)
		thin_pos = POS;
	thin_chrom = CHROM;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x2bea4
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2bea4
movl %esi, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x3e0(%rbx), %r14
movq 0x3e8(%rbx), %rdx
cmpq 0x1e79f(%rip), %rdx     # 0x4a5f0
jne 0x2be7f
testq %rdx, %rdx
je 0x2be6b
movq 0x1e789(%rip), %rsi     # 0x4a5e8
movq (%r14), %rdi
callq 0x5470
testl %eax, %eax
jne 0x2be7f
movl 0x400(%rbx), %eax
subl 0x1e791(%rip), %eax     # 0x4a608
cmpl %ebp, %eax
jge 0x2be7f
movb $0x0, 0xc(%rbx)
cmpb $0x1, 0xc(%rbx)
jne 0x2be91
movl 0x400(%rbx), %eax
movl %eax, 0x1e777(%rip)     # 0x4a608
leaq 0x1e750(%rip), %rdi     # 0x4a5e8
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x51f0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_to_exclude(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void entry::filter_sites_to_exclude(const string &snps_to_exclude_file)
{
	// Filter sites by user provided list
	if(passed_filters == false)
		return;

	if (snps_to_exclude_file == "")
		return;

	if (snps_to_exclude_file != "" && snps_to_exclude.empty())
	{
		ifstream in(snps_to_exclude_file.c_str());
		string tmp;
		if (!in.is_open())
		{
			LOG.error("Could not open SNPs to Exclude file" + snps_to_exclude_file, 0);
		}
		while (!in.eof())
		{
			in >> tmp;
			snps_to_exclude.insert(tmp);
			in.ignore(numeric_limits<streamsize>::max(), '\n');
		}
		in.close();
	}

	parse_basic_entry();

	if (snps_to_exclude.find(ID) != snps_to_exclude.end())
		passed_filters = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
cmpb $0x0, 0xc(%rdi)
je 0x2c219
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xde09(%rip), %rsi      # 0x39ed7
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x2c219
leaq 0xddf2(%rip), %rsi      # 0x39ed7
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x2c1e7
cmpq $0x0, 0x1e223(%rip)     # 0x4a320
jne 0x2c1e7
movq (%r14), %rsi
leaq 0x40(%rsp), %rdi
movl $0x8, %edx
callq 0x5820
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0xb8(%rsp), %rdi
callq 0x50b0
testb %al, %al
jne 0x2c171
leaq 0xdcba(%rip), %rsi      # 0x39dfc
movq %rsp, %rdi
movq %r14, %rdx
callq 0xb777
leaq 0x1d354(%rip), %rdi     # 0x494a8
movq %rsp, %rsi
xorl %edx, %edx
callq 0x36ec8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c171
callq 0x5410
leaq 0x40(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x1e176(%rip), %r12     # 0x4a2f8
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x60(%rsp,%rax)
jne 0x2c1c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x5590
movq %r12, %rdi
movq %r15, %rsi
callq 0x2c796
movq %r14, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x5260
jmp 0x2c18c
leaq 0x40(%rsp), %rdi
callq 0x50a0
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c1dd
callq 0x5410
leaq 0x40(%rsp), %rdi
callq 0x58a0
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x408(%rbx), %rsi
leaq 0x1e0f4(%rip), %rdi     # 0x4a2f8
callq 0xe5ba
leaq 0x1e0f0(%rip), %rcx     # 0x4a300
cmpq %rcx, %rax
je 0x2c219
movb $0x0, 0xc(%rbx)
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c248
callq 0x5410
jmp 0x2c248
jmp 0x2c245
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c257
callq 0x5410
leaq 0x40(%rsp), %rdi
callq 0x58a0
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/variant_file_filters.cpp
// Function: variant_file::filter_individuals(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&, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void variant_file::filter_individuals(const set<string> &indv_to_keep, const set<string> &indv_to_exclude, const string &indv_to_keep_filename, const string &indv_to_exclude_filename, bool keep_then_exclude)
{
	// Filter individuals by user provided lists
	if (keep_then_exclude)
	{
		filter_individuals_by_keep_list(indv_to_keep, indv_to_keep_filename);
		filter_individuals_by_exclude_list(indv_to_exclude, indv_to_exclude_filename);
	}
	else
	{
		filter_individuals_by_exclude_list(indv_to_exclude, indv_to_exclude_filename);
		filter_individuals_by_keep_list(indv_to_keep, indv_to_keep_filename);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testl %r9d, %r9d
je 0x2e671
movq %r13, %rsi
movq %r14, %rdx
callq 0x2e902
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2ec80
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2ec80
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2e902
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/output_log.cpp
// Function: output_log::open(bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void output_log::open(bool stout, bool sterr, const string &filename_prefix)
{
	if (stout)
	{
		output_to_screen = false;
		output_to_file = true;
	}

	if (sterr)
	{
		output_to_screen = true;
		output_to_file = false;
	}

	if (output_to_file)
		LOG.open((filename_prefix + ".log").c_str(), ios::out);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x36de1
movw $0x100, (%rbx)          # imm = 0x100
testb %dl, %dl
je 0x36dec
movw $0x1, (%rbx)
jmp 0x36e42
testb $0x1, 0x1(%rbx)
je 0x36e42
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0xc7c8
leaq 0x3e03(%rip), %rsi      # 0x3ac1a
movq %r14, %rdi
callq 0x5870
addq $0x8, %rbx
movq (%rsp), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x5060
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x36e42
callq 0x5410
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x36e4e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x36e5f
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/output_log.cpp
// Function: output_log::printLOG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void output_log::printLOG(string s)
{
	if (output_to_file)
		LOG << s; LOG.flush();
	if (output_to_screen)
		cerr << s; cerr.flush();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x1(%rdi)
jne 0x36e92
leaq 0x8(%r14), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x54f0
leaq 0x8(%r14), %rdi
callq 0x52c0
cmpb $0x1, (%r14)
jne 0x36eb4
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x12141(%rip), %rdi     # 0x48ff0
callq 0x54f0
movq 0x12135(%rip), %rdi     # 0x48ff0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/output_log.cpp
// Function: output_log::error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double, int)
void output_log::error(string err_msg, double value1, double value2, int error_code)
{
	printLOG("Error: " + err_msg + "\n");
	stringstream ss;
	ss << "Value1=" << value1 << " Value2=" << value2 << endl;
	printLOG(ss.str());
	exit(error_code);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movl %edx, %ebx
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x3c55(%rip), %rsi      # 0x3ac12
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0xb777
leaq 0x1185(%rip), %rsi      # 0x38156
movq %r15, %rdi
callq 0x5870
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x36ffa
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x37007
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x36e72
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x3703a
callq 0x5410
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3704d
callq 0x5410
leaq 0x58(%rsp), %rdi
callq 0x52e0
leaq 0x68(%rsp), %r15
leaq 0x3bbc(%rip), %rsi      # 0x3ac1f
movl $0x7, %edx
movq %r15, %rdi
callq 0x54f0
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x56e0
movq %rax, %r15
leaq 0x3b9f(%rip), %rsi      # 0x3ac27
movl $0x8, %edx
movq %rax, %rdi
callq 0x54f0
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x56e0
movq %rax, %rdi
callq 0x51b0
leaq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x56c0
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x36e72
leaq 0x38(%rsp), %rdi
callq 0x58b0
movl %ebx, %edi
callq 0x5540
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x370f3
callq 0x5410
jmp 0x370f3
movq %rax, %rbx
movq 0x11e86(%rip), %rsi     # 0x48f80
leaq 0x58(%rsp), %rdi
callq 0x5330
leaq 0xd8(%rsp), %rdi
callq 0x5100
jmp 0x3713d
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x3712a
callq 0x5410
jmp 0x3712a
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3713d
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/output_log.cpp
// Function: output_log::one_off_warning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void output_log::one_off_warning(string err_msg)
{
	static set<string> previous_warnings;
	if (previous_warnings.find(err_msg) == previous_warnings.end())
	{
		printLOG(err_msg + "\n");
		previous_warnings.insert(err_msg);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x134c1(%rip), %al      # 0x4a698
testb %al, %al
je 0x37261
leaq 0x13482(%rip), %rdi     # 0x4a668
movq %rbx, %rsi
callq 0xe5ba
leaq 0x1347b(%rip), %rcx     # 0x4a670
cmpq %rcx, %rax
jne 0x37255
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc7c8
leaq 0xf34(%rip), %rsi       # 0x38156
movq %r15, %rdi
callq 0x5870
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36e72
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x37246
callq 0x5410
leaq 0x1341b(%rip), %rdi     # 0x4a668
movq %rbx, %rsi
callq 0x2c796
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5f7a
jmp 0x371df
jmp 0x3726d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3727f
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/output_log.cpp
// Function: output_log::dbl2str[abi:cxx11](double, int)
string output_log::dbl2str(double n, int prc)
{
  std::ostringstream s2;
  if ( prc > 0 )
    s2.precision(prc);
  s2 << n;
  return s2.str();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %ebp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x55d0
testl %ebp, %ebp
jle 0x373d2
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
movl %ebp, %ecx
movq %rcx, 0x18(%rsp,%rax)
leaq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x56e0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c0
movq 0x11bca(%rip), %rsi     # 0x48fc0
leaq 0x10(%rsp), %rdi
callq 0x51e0
leaq 0x80(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq 0x11b9c(%rip), %rsi     # 0x48fc0
leaq 0x10(%rsp), %rdi
callq 0x51e0
leaq 0x80(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/output_log.cpp
// Function: output_log::dbl2str_fixed[abi:cxx11](double, int)
string output_log::dbl2str_fixed(double n, int prc)
{
  std::ostringstream s2;
  s2 << setiosflags( ios::fixed );
  if ( prc > 0 )
    s2.precision(prc);
  s2 << n;
  return s2.str();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movl %esi, %ebp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x55d0
movq (%r14), %rax
movq -0x18(%rax), %rcx
orl $0x4, 0x20(%rsp,%rcx)
testl %ebp, %ebp
jle 0x37481
movq -0x18(%rax), %rax
movl %ebp, %ecx
movq %rcx, 0x10(%rsp,%rax)
leaq 0x8(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x56e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c0
movq 0x11b1c(%rip), %rsi     # 0x48fc0
leaq 0x8(%rsp), %rdi
callq 0x51e0
leaq 0x78(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x11aef(%rip), %rsi     # 0x48fc0
leaq 0x8(%rsp), %rdi
callq 0x51e0
leaq 0x78(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_open
BGZF *bgzf_open(const char *path, const char *mode)
{
	BGZF *fp = 0;
	assert(compressBound(BGZF_BLOCK_SIZE) < BGZF_MAX_BLOCK_SIZE);
	if (strchr(mode, 'r') || strchr(mode, 'R')) {
		_bgzf_file_t fpr;
		if ((fpr = _bgzf_open(path, "r")) == 0) return 0;
		fp = bgzf_read_init();
		fp->fp = fpr;
	} else if (strchr(mode, 'w') || strchr(mode, 'W')) {
		FILE *fpw;
		if ((fpw = fopen(path, "w")) == 0) return 0;
		fp = bgzf_write_init(mode2level(mode));
		fp->fp = fpw;
	}
	fp->is_be = ed_is_big();
	return fp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xff00, %edi           # imm = 0xFF00
callq 0x56d0
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x37588
movq %rbx, %rdi
movl $0x72, %esi
callq 0x5130
testq %rax, %rax
jne 0x37530
movq %rbx, %rdi
movl $0x52, %esi
callq 0x5130
testq %rax, %rax
je 0x37556
leaq 0x16b7(%rip), %rsi      # 0x38bee
movq %r14, %rdi
callq 0x5520
testq %rax, %rax
je 0x3757e
movq %rax, %r14
callq 0x37fa3
movq %r14, 0x30(%rax)
andb $-0xd, 0x2(%rax)
jmp 0x37580
leaq 0x375b(%rip), %rsi      # 0x3acb8
movq %r14, %rdi
callq 0x5520
testq %rax, %rax
je 0x3757e
movq %rax, %r14
movq %rbx, %rdi
callq 0x37609
movl %eax, %edi
callq 0x375a7
jmp 0x3754c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x36c1(%rip), %rdi      # 0x3ac50
leaq 0x36ef(%rip), %rsi      # 0x3ac85
leaq 0x36ef(%rip), %rcx      # 0x3ac8c
movl $0x93, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_write_init
static BGZF *bgzf_write_init(int compress_level) // compress_level==-1 for the default level
{
	BGZF *fp;
	fp = (BGZF*)calloc(1, sizeof(BGZF));
	fp->is_write = 1;
	fp->uncompressed_block = malloc(BGZF_MAX_BLOCK_SIZE);
	fp->compressed_block = malloc(BGZF_MAX_BLOCK_SIZE);
	fp->compress_level = compress_level < 0? Z_DEFAULT_COMPRESSION : compress_level; // Z_DEFAULT_COMPRESSION==-1
	if (fp->compress_level > 9) fp->compress_level = Z_DEFAULT_COMPRESSION;
	return fp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x1, %edi
movl $0x38, %esi
callq 0x52a0
movq %rax, %r14
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x18(%r14)
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x20(%r14)
testl %ebx, %ebx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %ebx, %eax
shll $0x14, %eax
leal 0x10000(%rax), %ecx
cmpl $0x900001, %eax         # imm = 0x900001
movl $0xfff10000, %eax       # imm = 0xFFF10000
cmovll %ecx, %eax
movl %eax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: mode2level
static int mode2level(const char *__restrict mode)
{
	int i, compress_level = -1;
	for (i = 0; mode[i]; ++i)
		if (mode[i] >= '0' && mode[i] <= '9') break;
	if (mode[i]) compress_level = (int)mode[i] - '0';
	if (strchr(mode, 'u')) compress_level = 0;
	return compress_level;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rcx
movzbl (%rcx), %eax
testl %eax, %eax
je 0x37621
leal -0x30(%rax), %edx
incq %rcx
cmpb $0x9, %dl
ja 0x3760f
leal -0x30(%rax), %ecx
xorl %ebp, %ebp
cmpl $0x1, %eax
movl $0x0, %ebx
sbbl %ebx, %ebx
orl %ecx, %ebx
movl $0x75, %esi
callq 0x5130
testq %rax, %rax
cmovnel %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_dopen
BGZF *bgzf_dopen(int fd, const char *mode)
{
	BGZF *fp = 0;
	assert(compressBound(BGZF_BLOCK_SIZE) < BGZF_MAX_BLOCK_SIZE);
	if (strchr(mode, 'r') || strchr(mode, 'R')) {
		_bgzf_file_t fpr;
		if ((fpr = _bgzf_dopen(fd, "r")) == 0) return 0;
		fp = bgzf_read_init();
		fp->fp = fpr;
	} else if (strchr(mode, 'w') || strchr(mode, 'W')) {
		FILE *fpw;
		if ((fpw = fdopen(fd, "w")) == 0) return 0;
		fp = bgzf_write_init(mode2level(mode));
		fp->fp = fpw;
	}
	fp->is_be = ed_is_big();
	return fp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl $0xff00, %edi           # imm = 0xFF00
callq 0x56d0
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x376dd
movq %rbx, %rdi
movl $0x72, %esi
callq 0x5130
testq %rax, %rax
jne 0x3768a
movq %rbx, %rdi
movl $0x52, %esi
callq 0x5130
testq %rax, %rax
je 0x376af
leaq 0x155d(%rip), %rsi      # 0x38bee
movl %ebp, %edi
callq 0x54c0
testq %rax, %rax
je 0x376d6
movq %rax, %r14
callq 0x37fa3
movq %r14, 0x30(%rax)
andb $-0xd, 0x2(%rax)
jmp 0x376d8
leaq 0x3602(%rip), %rsi      # 0x3acb8
movl %ebp, %edi
callq 0x54c0
testq %rax, %rax
je 0x376d6
movq %rax, %r14
movq %rbx, %rdi
callq 0x37609
movl %eax, %edi
callq 0x375a7
jmp 0x376a5
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x356c(%rip), %rdi      # 0x3ac50
leaq 0x359a(%rip), %rsi      # 0x3ac85
leaq 0x35c8(%rip), %rcx      # 0x3acba
movl $0xa6, %edx
callq 0x5280