LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b69c
leaq 0x6d0(%rbx), %rdi
movq %r14, %rsi
callq 0x215c2
movq %r14, %rdi
callq 0xa18e
leaq 0x468(%rbx), %r14
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
callq 0xfd72
movq 0x6d0(%rbx), %rsi
movq 0x6d8(%rbx), %rax
subq %rsi, %rax
cmpq $0x4, %rax
jne 0x214db
leaq 0xa0(%rbx), %rdi
callq 0x1311e
leaq 0x20(%rax), %rdi
leaq 0xd997(%rip), %rsi      # 0x2ee37
callq 0x96f3
testb %al, %al
je 0x214db
leaq 0xc094(%rip), %rsi      # 0x2d544
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5160
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x10122
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0x2156a
leaq 0xa0(%rbx), %r15
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
movl %ebp, %ebp
movq 0x6d0(%rbx), %rax
movq 0x6d8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
jbe 0x21550
cmpb (%rax,%rbp,4), %r12b
jno 0x21534
movq %r13, %rdi
leaq 0xcc18(%rip), %rsi      # 0x2e12d
leaq 0x7(%rsp), %rdx
callq 0x5160
movq %r14, %rdi
movq %r13, %rsi
callq 0x10122
movq %r13, %rdi
callq 0x5908
jmp 0x2154c
leaq (%rax,%rbp,4), %rsi
movq %r15, %rdi
callq 0x1311e
leaq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0xfda2
incl %ebp
jmp 0x214e9
movq 0x468(%rbx), %rdi
movq 0x470(%rbx), %rsi
callq 0x1f6a6
movb $0x1, 0x3db(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2157d
jmp 0x2158c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0x2158f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x219ba
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x219ba
movl %r14d, %eax
andb %bpl, %al
cmpb $0x1, %al
jne 0x21914
leaq 0xd59b(%rip), %rsi      # 0x2ee82
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5160
leaq 0x1fbd3(%rip), %rdi     # 0x414d0
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x2bf18
leaq 0x28(%rsp), %rdi
callq 0x5908
movl %ebp, 0x4(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rax
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x428(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5210
movl 0x10(%rsp), %ebp
cmpq $0x1, %rbp
setne 0x3(%rsp)
movq %rbx, %rdi
callq 0x1ce64
movl %eax, %r12d
leaq 0x8(%rsp), %r13
cmpl %r12d, %r15d
jae 0x21994
movq %rbx, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x1bfa2
incl %r15d
cmpq %rbp, 0x10(%rsp)
je 0x2196b
movb $0x1, 0x3(%rsp)
testb %r14b, %r14b
je 0x219a0
jmp 0x219b0
testb %r14b, %r14b
je 0x219a0
cmpl $0x1, %ebp
je 0x219ac
jmp 0x219b0
movb 0x3(%rsp), %al
andb 0x4(%rsp), %al
cmpb $0x1, %al
jne 0x219b0
movb $0x0, 0xc(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x5908
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x219e2
movq %rax, %rbx
jmp 0x219e7
jmp 0x219da
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21a2a
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2401a
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x24200
movq %r14, %rsi
callq 0x24200
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2401a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21c3f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xd25a(%rip), %rsi      # 0x2ee37
movq %r15, %rdi
callq 0x96f3
testb %al, %al
jne 0x21c35
movl %r14d, %eax
notl %eax
movl %ebp, %ecx
xorl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl %eax, %ecx
je 0x21c35
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x3e0(%rbx), %rdi
movq %r15, %rsi
callq 0xfe37
testb %al, %al
je 0x21c31
movl 0x400(%rbx), %eax
cmpl %r14d, %eax
setge %cl
cmpl %ebp, %eax
setle %al
testb %al, %cl
jne 0x21c35
movb $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22960
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x28(%rdx), %rax
orq 0x28(%rsi), %rax
je 0x2295b
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 0x22961
movq %r15, %rdi
callq 0x16988
addq $0x8, %r15
cmpq %r15, %rax
jne 0x2295b
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x16988
addq $0x8, %r14
cmpq %r14, %rax
jne 0x22957
jmp 0x2295b
// File: /workspace/github_cpp_makefile_star2_O2/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 0x230aa
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 0x230a6
movq %rdi, %rbx
movq (%rdi), %rax
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq %rbx, %rdi
callq 0x1ce64
cmpl %r14d, %eax
setge %cl
cmpl %ebp, %eax
setle %al
testb %al, %cl
jne 0x230a6
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23429
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x23422
movsd %xmm0, (%rsp)
movq (%rbx), %rax
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1c0d6
leaq 0xad47(%rip), %rsi      # 0x2e12d
movq %r14, %rdi
callq 0x96f3
testb %al, %al
jne 0x23405
leaq 0xba3e(%rip), %rsi      # 0x2ee37
leaq 0x8(%rsp), %rdi
callq 0x96f3
testb %al, %al
movsd (%rsp), %xmm0
ucomisd 0x460(%rbx), %xmm0
jbe 0x23418
movb $0x0, 0xc(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x5908
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
cmpb $0x0, 0xc(%rdi)
je 0x23586
movq %rdi, %rbx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
ucomisd 0x18(%rsp), %xmm1
jb 0x2347d
movsd 0x10(%rsp), %xmm0
ucomisd 0x9bcb(%rip), %xmm0     # 0x2d040
jne 0x2347d
jnp 0x23586
leaq 0x1f0(%rbx), %r14
leaq 0x218(%rbx), %rbp
xorl %r12d, %r12d
leaq 0x28(%rsp), %r15
xorl %r13d, %r13d
movq %r14, 0x20(%rsp)
movl 0x8(%rbx), %eax
cmpq %rax, %r12
jae 0x2355c
movq %r14, %rdi
movq %r12, %rsi
callq 0x9cc0
testq %rdx, (%rax)
je 0x23554
movq %rbp, %rdi
movq %r12, %rsi
callq 0x9cc0
testq %rdx, (%rax)
je 0x23554
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
pushq $0x1
popq %r8
xorl %r9d, %r9d
callq *0x20(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x2352e
movl %r13d, %r14d
movq %rbp, %r13
movq %r15, %rbp
movq %r15, %rdi
leaq 0xb881(%rip), %rsi      # 0x2ed80
leaq 0x7(%rsp), %rdx
callq 0x5160
leaq 0x1dfc0(%rip), %rdi     # 0x414d0
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x2bf18
movq %rbp, %rdi
callq 0x5908
movq %r13, %rbp
movl %r14d, %r13d
movq 0x20(%rsp), %r14
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1cba6
testl %eax, %eax
js 0x23551
cvtsi2sd %eax, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %r13d
incq %r12
jmp 0x2349b
movl %r13d, %eax
cvtsi2sd %rax, %xmm0
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
ucomisd %xmm2, %xmm0
ja 0x23582
ucomisd 0x10(%rsp), %xmm2
jbe 0x23586
movb $0x0, 0xc(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 0x238e0
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1f0(%rdi), %r14
xorl %r15d, %r15d
pushq $0x1
popq %rbp
xorl %r12d, %r12d
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jae 0x238cf
movq %r14, %rdi
movq %r15, %rsi
callq 0x9cc0
testq %rdx, (%rax)
je 0x238ca
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1cb56
xorl %ecx, %ecx
cmpb $0x7c, %al
setne %cl
addl %ecx, %r12d
incq %r15
jmp 0x23887
testl %r12d, %r12d
je 0x238d8
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2395f
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2395f
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rax
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x23950
leaq 0xb336(%rip), %rsi      # 0x2ec58
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x5160
leaq 0x1db95(%rip), %rdi     # 0x414d0
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x2bf18
leaq 0x18(%rsp), %rdi
callq 0x5908
movq (%rbx), %rax
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq *0x58(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
cmpb $0x0, 0xc(%rdi)
je 0x23a00
movl %edx, %ebx
movl %esi, %ebp
testl %esi, %esi
setle %al
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %cl
testb %cl, %al
jne 0x23a00
movq %rdi, %r14
cmpb $0x0, 0x15(%rdi)
jne 0x239e0
leaq 0xb2f1(%rip), %rsi      # 0x2eca3
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x5160
leaq 0x1db05(%rip), %rdi     # 0x414d0
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x2bf18
leaq 0x8(%rsp), %rdi
callq 0x5908
movq (%r14), %rax
pushq $0x1
popq %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq *0x50(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
cmpb $0x0, 0xc(%rdi)
je 0x23aa3
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testb %bpl, %bpl
jne 0x23a44
cmpq $0x0, 0x28(%rbx)
je 0x23aa3
movq (%r14), %rax
pushq $0x1
popq %r8
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x28(%rax)
cmpb $0x0, 0x15(%r14)
jne 0x23a93
leaq 0xb287(%rip), %rsi      # 0x2ecec
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x5160
leaq 0x1da52(%rip), %rdi     # 0x414d0
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x2bf18
leaq 0x8(%rsp), %rdi
callq 0x5908
movq (%r14), %rax
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x23f7e
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x23f7e
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rax
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x23f2c
leaq 0xaffc(%rip), %rsi      # 0x2eefa
leaq 0x40(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x5160
leaq 0x1d5b9(%rip), %rdi     # 0x414d0
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x2bf18
leaq 0x40(%rsp), %rdi
callq 0x5908
leaq 0x24(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x1c(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1d39c
movl (%r15), %edi
movl (%r14), %esi
movl (%r12), %edx
leaq 0x38(%rsp), %r14
leaq 0x30(%rsp), %r8
leaq 0x28(%rsp), %r9
movq %r14, %rcx
callq 0x19e28
movsd 0x10(%rsp), %xmm0
ucomisd (%r14), %xmm0
jbe 0x23f7e
movb $0x0, 0xc(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24015
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x24015
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
leaq 0x1e640(%rip), %rsi     # 0x42610
movq %r14, %rdi
callq 0xfe37
testb %al, %al
je 0x23ff0
movl 0x400(%rbx), %eax
subl 0x1e648(%rip), %eax     # 0x42630
cmpl %ebp, %eax
jge 0x23ff0
movb $0x0, 0xc(%rbx)
cmpb $0x1, 0xc(%rbx)
jne 0x24002
movl 0x400(%rbx), %eax
movl %eax, 0x1e62e(%rip)     # 0x42630
leaq 0x1e607(%rip), %rdi     # 0x42610
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5210
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2435d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xac0f(%rip), %rsi      # 0x2ee37
movq %r14, %rdi
callq 0x96f3
testb %al, %al
jne 0x2435d
leaq 0xabf8(%rip), %rsi      # 0x2ee37
movq %r14, %rdi
callq 0x12f17
testb %al, %al
je 0x2432b
cmpq $0x0, 0x1e0f1(%rip)     # 0x42348
jne 0x2432b
movq (%r14), %rsi
leaq 0x40(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x5860
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xb8(%rsp), %rdi
callq 0x50d0
testb %al, %al
jne 0x242ba
leaq 0xaac6(%rip), %rsi      # 0x2ed5c
movq %rsp, %rdi
movq %r14, %rdx
callq 0x967d
leaq 0x1d228(%rip), %rdi     # 0x414d0
movq %rsp, %rsi
xorl %edx, %edx
callq 0x2bf18
movq %rsp, %rdi
callq 0x5908
leaq 0x40(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x1e055(%rip), %r12     # 0x42320
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
pushq $0xa
popq %rbp
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x60(%rsp,%rax)
jne 0x2430d
movq %r14, %rdi
movq %r15, %rsi
callq 0x55c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x248d6
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x5280
jmp 0x242d8
leaq 0x40(%rsp), %rdi
callq 0x50a0
leaq 0x20(%rsp), %rdi
callq 0x5908
leaq 0x40(%rsp), %rdi
callq 0x58f8
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x408(%rbx), %rsi
leaq 0x1dfd8(%rip), %rdi     # 0x42320
callq 0xc0d2
leaq 0x1dfd4(%rip), %rcx     # 0x42328
cmpq %rcx, %rax
je 0x2435d
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
movq %rsp, %rdi
callq 0x5908
jmp 0x24381
jmp 0x2437e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5908
leaq 0x40(%rsp), %rdi
callq 0x58f8
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x265b7
movq %r13, %rsi
movq %r14, %rdx
callq 0x267b2
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x26a90
movq %r12, %rsi
movq %rbx, %rdx
callq 0x26a90
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x267b2
nop
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/parameters.cpp
// Function: parameters::print_help()
void parameters::print_help()
{
	unsigned int i;
	string in_str;

	if (argv.size() <= 1)
	{	// If there are no user parameters, display help.
		argv.push_back("--?");
		print_help();
	}

	for(i = 0; i < argv.size(); i++)
	{
		in_str = argv[i];
		if ((in_str == "-h") || (in_str == "-?") || (in_str == "-help") || (in_str == "--?") || (in_str == "--help") || (in_str == "--h"))
		{
			cout << endl << "Viterbi (" << VCFTOOLS_VERSION << ")" << endl;
			cout << "\u00A9 Adam Auton 2014" << endl << endl;
			cout << "Identify shared haplotypes using Viterbi algorithm." << endl;
			cout << endl;
			cout << endl;

			exit(0);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x540(%rdi), %rax
subq 0x538(%rdi), %rax
cmpq $0x21, %rax
jae 0x2bb4d
leaq 0x3c83(%rip), %rsi      # 0x2f79e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5160
leaq 0x538(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x10122
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x2bade
xorl %r13d, %r13d
leaq 0x28(%rsp), %r14
leaq 0x3c42(%rip), %rbp      # 0x2f79e
leaq 0x3c3f(%rip), %r15      # 0x2f7a2
leaq 0x3c3f(%rip), %r12      # 0x2f7a9
movl %r13d, %r13d
movq 0x538(%rbx), %rsi
movq 0x540(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x2bca8
movq %r13, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r14, %rdi
callq 0x5210
movq %r14, %rdi
leaq 0x3c03(%rip), %rsi      # 0x2f7aa
callq 0x96f3
testb %al, %al
jne 0x2bc0a
movq %r14, %rdi
leaq 0x3be5(%rip), %rsi      # 0x2f79f
callq 0x96f3
testb %al, %al
jne 0x2bc0a
movq %r14, %rdi
leaq 0x3bd6(%rip), %rsi      # 0x2f7a3
callq 0x96f3
testb %al, %al
jne 0x2bc0a
movq %r14, %rdi
movq %rbp, %rsi
callq 0x96f3
testb %al, %al
jne 0x2bc0a
movq %r14, %rdi
movq %r15, %rsi
callq 0x96f3
testb %al, %al
jne 0x2bc0a
movq %r14, %rdi
movq %r12, %rsi
callq 0x96f3
incl %r13d
testb %al, %al
je 0x2bb6a
movq 0x153b7(%rip), %rdi     # 0x40fc8
callq 0x51d0
leaq 0x3b90(%rip), %rsi      # 0x2f7ad
movq %rax, %rdi
callq 0x5480
leaq 0x16a3c(%rip), %rsi     # 0x42668
movq %rax, %rdi
callq 0x5400
leaq 0x2cda(%rip), %rsi      # 0x2e915
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
callq 0x51d0
movq 0x15376(%rip), %rdi     # 0x40fc8
leaq 0x3b5e(%rip), %rsi      # 0x2f7b7
callq 0x5480
movq %rax, %rdi
callq 0x51d0
movq %rax, %rdi
callq 0x51d0
movq 0x15353(%rip), %rdi     # 0x40fc8
leaq 0x3b4e(%rip), %rsi      # 0x2f7ca
callq 0x5480
movq %rax, %rdi
callq 0x51d0
movq 0x15338(%rip), %rdi     # 0x40fc8
callq 0x51d0
movq 0x1532c(%rip), %rdi     # 0x40fc8
callq 0x51d0
xorl %edi, %edi
callq 0x5570
leaq 0x28(%rsp), %rdi
callq 0x5908
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0x2bcd7
jmp 0x2bcd4
jmp 0x2bcd4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x2be5f
movw $0x100, (%rbx)          # imm = 0x100
testb %dl, %dl
je 0x2be6a
movw $0x1, (%rbx)
jmp 0x2bea3
testb $0x1, 0x1(%rbx)
je 0x2bea3
addq $0x8, %rbx
leaq 0x3cff(%rip), %rdx      # 0x2fb7a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rcx, %rsi
callq 0xfdce
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x5050
leaq 0x8(%rsp), %rdi
callq 0x5908
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2bee6
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x5400
leaq 0x8(%r14), %rdi
callq 0x52e0
cmpb $0x1, (%r14)
jne 0x2bf04
movq 0x150f4(%rip), %rdi     # 0x40ff0
movq %rbx, %rsi
callq 0x5400
movq 0x150e5(%rip), %rdi     # 0x40ff0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3bb5(%rip), %rsi      # 0x2fb72
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0x967d
leaq 0x113a(%rip), %rdx      # 0x2d10b
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x98b6
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x2beca
leaq 0x38(%rsp), %rdi
callq 0x5908
leaq 0x58(%rsp), %rdi
callq 0x5908
leaq 0x58(%rsp), %rdi
callq 0x5300
leaq 0x68(%rsp), %rdi
leaq 0x3b6a(%rip), %rsi      # 0x2fb7f
callq 0x5480
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x5720
leaq 0x3b58(%rip), %rsi      # 0x2fb87
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x5720
movq %rax, %rdi
callq 0x51d0
leaq 0x70(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x56f0
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x2beca
leaq 0x18(%rsp), %rdi
callq 0x5908
movl %ebx, %edi
callq 0x5570
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5908
jmp 0x2c08c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5360
jmp 0x2c0b4
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5908
jmp 0x2c0aa
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x1659f(%rip), %al      # 0x426c0
testb %al, %al
je 0x2c181
leaq 0x16564(%rip), %rdi     # 0x42690
movq %rbx, %rsi
callq 0xc0d2
leaq 0x1655d(%rip), %rcx     # 0x42698
cmpq %rcx, %rax
jne 0x2c177
leaq 0xfc4(%rip), %rdx       # 0x2d10b
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xfdce
movq %r14, %rdi
movq %r15, %rsi
callq 0x2beca
movq %rsp, %rdi
callq 0x5908
leaq 0x16521(%rip), %rdi     # 0x42690
movq %rbx, %rsi
callq 0x248d6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x16538(%rip), %rdi     # 0x426c0
callq 0x5850
testl %eax, %eax
je 0x2c125
andl $0x0, 0x16500(%rip)     # 0x42698
leaq 0x164f1(%rip), %rsi     # 0x42690
leaq 0x164f2(%rip), %rax     # 0x42698
andq $0x0, 0x164f2(%rip)     # 0x426a0
movq %rax, 0x164f3(%rip)     # 0x426a8
movq %rax, 0x164f4(%rip)     # 0x426b0
andq $0x0, 0x164f4(%rip)     # 0x426b8
leaq -0x7e2d(%rip), %rdi     # 0x2439e
leaq 0x152ae(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x164e2(%rip), %rdi     # 0x426c0
callq 0x5290
jmp 0x2c125
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5610
testl %ebp, %ebp
jle 0x2c2fe
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 0x5720
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x56f0
leaq 0x10(%rsp), %rdi
callq 0x58f0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x58f0
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5610
movq (%r14), %rax
movq -0x18(%rax), %rcx
orl $0x4, 0x20(%rsp,%rcx)
testl %ebp, %ebp
jle 0x2c385
movq -0x18(%rax), %rax
movl %ebp, %ecx
movq %rcx, 0x10(%rsp,%rax)
leaq 0x8(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x5720
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56f0
leaq 0x8(%rsp), %rdi
callq 0x58f0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x58f0
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5700
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x2c464
pushq $0x72
popq %rsi
movq %rbx, %rdi
callq 0x5140
testq %rax, %rax
jne 0x2c40c
pushq $0x52
popq %rsi
movq %rbx, %rdi
callq 0x5140
testq %rax, %rax
je 0x2c432
leaq 0x171b(%rip), %rsi      # 0x2db2e
movq %r14, %rdi
callq 0x5550
testq %rax, %rax
je 0x2c45a
movq %rax, %r14
callq 0x2cdec
movq %r14, 0x30(%rax)
andb $-0xd, 0x2(%rax)
jmp 0x2c45c
leaq 0x37cf(%rip), %rsi      # 0x2fc08
movq %r14, %rdi
callq 0x5550
testq %rax, %rax
je 0x2c45a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c4df
movl %eax, %edi
callq 0x2c483
jmp 0x2c428
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3735(%rip), %rdi      # 0x2fba0
leaq 0x3763(%rip), %rsi      # 0x2fbd5
leaq 0x3763(%rip), %rcx      # 0x2fbdc
movl $0x93, %edx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x52c0
movq %rax, %r14
movl $0x10000, %edi          # imm = 0x10000
callq 0x5600
movq %rax, 0x18(%r14)
movl $0x10000, %edi          # imm = 0x10000
callq 0x5600
movq %rax, 0x20(%r14)
testl %ebx, %ebx
pushq $-0x1
popq %rax
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_O2/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 0x2c4f7
leal -0x30(%rax), %edx
incq %rcx
cmpb $0x9, %dl
ja 0x2c4e5
leal -0x30(%rax), %ecx
xorl %ebp, %ebp
cmpl $0x1, %eax
movl $0x0, %ebx
sbbl %ebx, %ebx
orl %ecx, %ebx
pushq $0x75
popq %rsi
callq 0x5140
testq %rax, %rax
cmovnel %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5700
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x2c5ad
pushq $0x72
popq %rsi
movq %rbx, %rdi
callq 0x5140
testq %rax, %rax
jne 0x2c55a
pushq $0x52
popq %rsi
movq %rbx, %rdi
callq 0x5140
testq %rax, %rax
je 0x2c57f
leaq 0x15cd(%rip), %rsi      # 0x2db2e
movl %ebp, %edi
callq 0x5500
testq %rax, %rax
je 0x2c5a6
movq %rax, %r14
callq 0x2cdec
movq %r14, 0x30(%rax)
andb $-0xd, 0x2(%rax)
jmp 0x2c5a8
leaq 0x3682(%rip), %rsi      # 0x2fc08
movl %ebp, %edi
callq 0x5500
testq %rax, %rax
je 0x2c5a6
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c4df
movl %eax, %edi
callq 0x2c483
jmp 0x2c575
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x35ec(%rip), %rdi      # 0x2fba0
leaq 0x361a(%rip), %rsi      # 0x2fbd5
leaq 0x3648(%rip), %rcx      # 0x2fc0a
movl $0xa6, %edx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bgzf.c
// Function: bgzf_read_block
int bgzf_read_block(BGZF *fp)
{
	uint8_t header[BLOCK_HEADER_LENGTH], *compressed_block;
	int count, size = 0, block_length, remaining;
	int64_t block_address;
	block_address = _bgzf_tell((_bgzf_file_t)fp->fp);
	if (fp->cache_size && load_block_from_cache(fp, block_address)) return 0;
	count = _bgzf_read(fp->fp, header, sizeof(header));
	if (count == 0) { // no data read
		fp->block_length = 0;
		return 0;
	}
	if (count != sizeof(header) || !check_header(header)) {
		fp->errcode |= BGZF_ERR_HEADER;
		return -1;
	}
	size = count;
	block_length = unpackInt16((uint8_t*)&header[16]) + 1; // +1 because when writing this number, we used "-1"
	compressed_block = (uint8_t*)fp->compressed_block;
	memcpy(compressed_block, header, BLOCK_HEADER_LENGTH);
	remaining = block_length - BLOCK_HEADER_LENGTH;
	count = _bgzf_read(fp->fp, &compressed_block[BLOCK_HEADER_LENGTH], remaining);
	if (count != remaining) {
		fp->errcode |= BGZF_ERR_IO;
		return -1;
	}
	size += count;
	if ((count = inflate_block(fp, block_length)) < 0) return -1;
	if (fp->block_length != 0) fp->block_offset = 0; // Do not reset offset if this read follows a seek.
	fp->block_address = block_address;
	fp->block_length = count;
	cache_block(fp, size);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5590
movq %rax, %r14
movq 0x30(%rbx), %rcx
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x12
popq %rdx
callq 0x5680
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
andq %rax, %rcx
je 0x2c72b
cmpl $0x12, %ecx
jne 0x2c723
cmpb $0x1f, (%rsp)
jne 0x2c723
cmpb $-0x75, 0x1(%rsp)
jne 0x2c723
cmpb $0x8, 0x2(%rsp)
jne 0x2c723
testb $0x4, 0x3(%rsp)
je 0x2c723
cmpw $0x6, 0xa(%rsp)
jne 0x2c723
cmpb $0x42, 0xc(%rsp)
jne 0x2c723
cmpb $0x43, 0xd(%rsp)
jne 0x2c723
cmpw $0x2, 0xe(%rsp)
jne 0x2c723
movzwl 0x10(%rsp), %r12d
movq 0x20(%rbx), %rdi
movw %r12w, 0x10(%rdi)
movaps (%rsp), %xmm0
movups %xmm0, (%rdi)
leaq -0x11(%r12), %r15
addq $0x12, %rdi
movq 0x30(%rbx), %rcx
pushq $0x1
popq %rsi
movq %r15, %rdx
callq 0x5680
cmpl %eax, %r15d
jne 0x2c741
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movups %xmm0, 0x40(%rdi)
movq 0x20(%rbx), %rax
addq $0x12, %rax
movq %rax, (%rdi)
addl $-0xf, %r12d
movl %r12d, 0x8(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rdi)
movl $0x10000, 0x20(%rdi)    # imm = 0x10000
leaq 0xdf7(%rip), %rdx       # 0x2d4cf
pushq $-0xf
popq %rsi
pushq $0x70
popq %rcx
callq 0x53e0
testl %eax, %eax
jne 0x2c746
leaq 0x20(%rsp), %r15
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x5390
movl %eax, %ebp
xorl $0x1, %ebp
movq %r15, %rdi
callq 0x54e0
orl %ebp, %eax
jne 0x2c746
movl 0x48(%rsp), %eax
testl %eax, %eax
js 0x2c726
cmpl $0x0, 0x8(%rbx)
je 0x2c71a
andl $0x0, 0xc(%rbx)
movq %r14, 0x10(%rbx)
movl %eax, 0x8(%rbx)
jmp 0x2c72f
orb $0x2, (%rbx)
pushq $-0x1
popq %rax
jmp 0x2c731
andl $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
orb $0x4, (%rbx)
jmp 0x2c726
orb $0x1, (%rbx)
jmp 0x2c726