LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5d9cb
jmp 0x5daa2
xorps %xmm0, %xmm0
ucomisd 0x48(%rsp), %xmm0
jb 0x5d9db
jmp 0x5daa2
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
xorl %r8d, %r8d
movl $0x1, %edx
movl %r8d, %esi
movl %r8d, %ecx
callq *0x28(%rax)
movq 0x8(%rsp), %rax
movb 0x15(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5da91
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x69f0
movq (%rsp), %rdx
leaq 0x18127(%rip), %rsi     # 0x75b4a
leaq 0x28(%rsp), %rdi
callq 0x67c0
jmp 0x5da2f
leaq 0x35bca(%rip), %rdi     # 0x93600
leaq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x712f0
jmp 0x5da47
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x27(%rsp), %rdi
callq 0x65f0
jmp 0x5da91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x5da85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x27(%rsp), %rdi
callq 0x65f0
jmp 0x5daa7
movq 0x8(%rsp), %rdi
movsd 0x48(%rsp), %xmm0
movq (%rdi), %rax
callq *0x58(%rax)
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5daed
jmp 0x5dbdb
cmpl $0x0, 0x5c(%rsp)
jg 0x5db10
movl 0x58(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x10bd0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jne 0x5db10
jmp 0x5dbdb
movq 0x18(%rsp), %rax
movb 0x15(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5dbaf
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69f0
movq 0x8(%rsp), %rdx
leaq 0x18054(%rip), %rsi     # 0x75b95
leaq 0x38(%rsp), %rdi
callq 0x67c0
jmp 0x5db4d
leaq 0x35aac(%rip), %rdi     # 0x93600
leaq 0x38(%rsp), %rsi
movl $0x1, %edx
callq 0x712f0
jmp 0x5db65
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x37(%rsp), %rdi
callq 0x65f0
jmp 0x5dbaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x5dba3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x37(%rsp), %rdi
callq 0x65f0
jmp 0x5dbe0
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
xorl %r8d, %r8d
movl $0x1, %ecx
movl %r8d, %esi
movl %r8d, %edx
callq *0x28(%rax)
movq 0x18(%rsp), %rdi
movl 0x5c(%rsp), %esi
movl 0x58(%rsp), %edx
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x69e0
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5dc22
jmp 0x5dd15
movb 0x57(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5dc45
movq 0x58(%rsp), %rdi
callq 0x4d120
testb $0x1, %al
jne 0x5dc40
jmp 0x5dc45
jmp 0x5dd15
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl $0x1, %r8d
movl %ecx, %esi
movl %ecx, %edx
callq *0x28(%rax)
movq 0x10(%rsp), %rax
movb 0x15(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5dcfb
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69f0
movq 0x8(%rsp), %rdx
leaq 0x17f51(%rip), %rsi     # 0x75bde
leaq 0x30(%rsp), %rdi
callq 0x67c0
jmp 0x5dc99
leaq 0x35960(%rip), %rdi     # 0x93600
leaq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x712f0
jmp 0x5dcb1
leaq 0x30(%rsp), %rdi
callq 0x6b50
leaq 0x2f(%rsp), %rdi
callq 0x65f0
jmp 0x5dcfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x5dcef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6b50
leaq 0x2f(%rsp), %rdi
callq 0x65f0
jmp 0x5dd1a
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
movb 0x57(%rsp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %edx
callq *0x60(%rax)
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5e494
jmp 0x5e5c4
xorps %xmm0, %xmm0
ucomisd 0x78(%rsp), %xmm0
jb 0x5e4a4
jmp 0x5e5c4
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq *0x28(%rax)
movq 0x10(%rsp), %rax
movb 0x15(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5e570
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69f0
movq 0x8(%rsp), %rdx
leaq 0x178ea(%rip), %rsi     # 0x75dec
leaq 0x30(%rsp), %rdi
callq 0x67c0
jmp 0x5e50e
leaq 0x350eb(%rip), %rdi     # 0x93600
leaq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x712f0
jmp 0x5e526
leaq 0x30(%rsp), %rdi
callq 0x6b50
leaq 0x2f(%rsp), %rdi
callq 0x65f0
jmp 0x5e570
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x5e564
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6b50
leaq 0x2f(%rsp), %rdi
callq 0x65f0
jmp 0x5e5cc
movq 0x10(%rsp), %rdi
leaq 0x74(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x6c(%rsp), %rcx
callq 0x4cb50
movl 0x70(%rsp), %edi
movl 0x74(%rsp), %esi
movl 0x6c(%rsp), %edx
leaq 0x60(%rsp), %rcx
leaq 0x58(%rsp), %r8
leaq 0x50(%rsp), %r9
callq 0x45220
movsd 0x60(%rsp), %xmm1
movsd 0x78(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5e5c4
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5e608
jmp 0x5e6a1
cmpl $0x1, 0xc(%rsp)
jge 0x5e614
jmp 0x5e6a1
movq (%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq *0x10(%rax)
movq (%rsp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
leaq 0x3610a(%rip), %rsi     # 0x94740
callq 0x2a430
testb $0x1, %al
jne 0x5e641
jmp 0x5e669
movq (%rsp), %rax
movl 0x400(%rax), %eax
subl 0x3610f(%rip), %eax     # 0x94760
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x5e667
movq (%rsp), %rax
movb $0x0, 0xc(%rax)
jmp 0x5e669
movq (%rsp), %rax
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x5e68a
movq (%rsp), %rax
movl 0x400(%rax), %eax
movl %eax, 0x360d6(%rip)     # 0x94760
movq (%rsp), %rsi
addq $0x3e0, %rsi            # imm = 0x3E0
leaq 0x360a4(%rip), %rdi     # 0x94740
callq 0x6060
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movb %r9b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0xf(%rsp)
je 0x6596e
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x65ef0
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x66440
jmp 0x65994
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x66440
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x65ef0
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movb %dl, %al
movb %sil, %dl
movq %rdi, 0x60(%rsp)
andb $0x1, %dl
movb %dl, 0x5f(%rsp)
andb $0x1, %al
movb %al, 0x5e(%rsp)
movq %rcx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x5f(%rsp)
je 0x711bd
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movb $0x1, 0x1(%rax)
testb $0x1, 0x5e(%rsp)
je 0x711d0
movq 0x18(%rsp), %rax
movb $0x1, (%rax)
movb $0x0, 0x1(%rax)
movq 0x18(%rsp), %rax
testb $0x1, 0x1(%rax)
je 0x71248
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x5855(%rip), %rdx      # 0x76a4a
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2a270
movq 0x8(%rsp), %rdi
callq 0x61a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x6070
jmp 0x71222
leaq 0x30(%rsp), %rdi
callq 0x6b50
jmp 0x71248
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6b50
jmp 0x7124d
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x69e0
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x1(%rax)
je 0x712b6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x64a0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x6320
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x712df
movq 0x8(%rsp), %rsi
movq 0x21d16(%rip), %rdi     # 0x92ff0
callq 0x64a0
movq 0x21d0a(%rip), %rdi     # 0x92ff0
callq 0x6320
addq $0x28, %rsp
retq
// File: 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:
subq $0x258, %rsp            # imm = 0x258
movl %edx, %eax
movq %rsi, %rdx
movq %rdi, 0x250(%rsp)
movq %rdx, 0x248(%rsp)
movsd %xmm0, 0x240(%rsp)
movsd %xmm1, 0x238(%rsp)
movl %eax, 0x234(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x5649(%rip), %rsi      # 0x76a42
leaq 0x1f0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe8d0
movq 0x30(%rsp), %rsi
leaq 0x2cd4(%rip), %rdx      # 0x740eb
leaq 0x210(%rsp), %rdi
callq 0xf4a0
jmp 0x71426
movq 0x28(%rsp), %rdi
leaq 0x210(%rsp), %rsi
callq 0x71280
jmp 0x7143a
leaq 0x210(%rsp), %rdi
callq 0x6b50
leaq 0x1f0(%rsp), %rdi
callq 0x6b50
leaq 0x58(%rsp), %rdi
callq 0x6360
leaq 0x68(%rsp), %rdi
leaq 0x55e5(%rip), %rsi      # 0x76a4f
callq 0x6540
movq %rax, 0x20(%rsp)
jmp 0x71476
movq 0x20(%rsp), %rdi
movsd 0x240(%rsp), %xmm0
callq 0x6ab0
movq %rax, 0x18(%rsp)
jmp 0x71490
movq 0x18(%rsp), %rdi
leaq 0x55bb(%rip), %rsi      # 0x76a57
callq 0x6540
movq %rax, 0x10(%rsp)
jmp 0x714a8
movq 0x10(%rsp), %rdi
movsd 0x238(%rsp), %xmm0
callq 0x6ab0
movq %rax, 0x8(%rsp)
jmp 0x714c2
movq 0x8(%rsp), %rdi
movq 0x21aca(%rip), %rsi     # 0x92f98
callq 0x65a0
jmp 0x714d5
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x6530
jmp 0x714e6
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x71280
jmp 0x714f7
leaq 0x38(%rsp), %rdi
callq 0x6b50
movl 0x234(%rsp), %edi
callq 0x66b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
jmp 0x71544
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
leaq 0x210(%rsp), %rdi
callq 0x6b50
leaq 0x1f0(%rsp), %rdi
callq 0x6b50
jmp 0x71591
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
jmp 0x71587
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x58(%rsp), %rdi
callq 0x63c0
movq 0x1e8(%rsp), %rdi
callq 0x69e0
nop
// File: 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:
subq $0x78, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpb $0x0, 0x231bc(%rip)     # 0x947f0
jne 0x71679
leaq 0x231b3(%rip), %rdi     # 0x947f0
callq 0x6a40
cmpl $0x0, %eax
je 0x71679
leaq 0x23172(%rip), %rdi     # 0x947c0
callq 0x5ec60
leaq -0x6036a(%rip), %rdi    # 0x112f0
leaq 0x2315f(%rip), %rsi     # 0x947c0
leaq 0x21f38(%rip), %rdx     # 0x935a0
callq 0x6490
leaq 0x2317c(%rip), %rdi     # 0x947f0
callq 0x62f0
movq 0x8(%rsp), %rsi
leaq 0x2313b(%rip), %rdi     # 0x947c0
callq 0x10b60
movq %rax, 0x60(%rsp)
leaq 0x2312a(%rip), %rdi     # 0x947c0
callq 0x10ba0
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x10b40
testb $0x1, %al
jne 0x716b5
jmp 0x7171f
movq 0x8(%rsp), %rsi
leaq 0x2a2a(%rip), %rdx      # 0x740eb
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2a270
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x71280
jmp 0x716df
leaq 0x38(%rsp), %rdi
callq 0x6b50
movq 0x8(%rsp), %rsi
leaq 0x230cb(%rip), %rdi     # 0x947c0
callq 0x5ed80
movq %rax, 0x18(%rsp)
movb %dl, 0x20(%rsp)
jmp 0x7171f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6b50
jmp 0x71724
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x69e0
nop
// File: 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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1b0(%rsp)
movsd %xmm0, 0x1a8(%rsp)
movl %esi, 0x1a4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x67a0
cmpl $0x0, 0x1a4(%rsp)
jle 0x718e9
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
movslq 0x1a4(%rsp), %rsi
callq 0x71a20
jmp 0x718cd
jmp 0x718e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6b30
jmp 0x71926
movsd 0x1a8(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x6ab0
jmp 0x718fe
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6570
jmp 0x7190f
leaq 0x28(%rsp), %rdi
callq 0x6b30
movq 0x10(%rsp), %rax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq 0x20(%rsp), %rdi
callq 0x69e0
// File: 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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x1b0(%rsp)
movsd %xmm0, 0x1a8(%rsp)
movl %esi, 0x1a4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x67a0
movl $0x4, %edi
callq 0x71a50
movl %eax, 0x10(%rsp)
jmp 0x71975
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %esi
leaq 0x28(%rsp), %rdi
callq 0x6af0
jmp 0x7198d
cmpl $0x0, 0x1a4(%rsp)
jle 0x719d0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
movslq 0x1a4(%rsp), %rsi
callq 0x71a20
jmp 0x719b4
jmp 0x719d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6b30
jmp 0x71a0c
movsd 0x1a8(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x6ab0
jmp 0x719e5
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6570
jmp 0x719f5
leaq 0x28(%rsp), %rdi
callq 0x6b30
movq 0x8(%rsp), %rax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq 0x18(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0xff00, %edi           # imm = 0xFF00
callq 0x68b0
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x71a9c
jmp 0x71abb
leaq 0x4fcd(%rip), %rdi      # 0x76a70
leaq 0x4ffb(%rip), %rsi      # 0x76aa5
movl $0x93, %edx
leaq 0x4ff6(%rip), %rcx      # 0x76aac
callq 0x6300
movq -0x18(%rbp), %rdi
movl $0x72, %esi
callq 0x6160
cmpq $0x0, %rax
jne 0x71ae3
movq -0x18(%rbp), %rdi
movl $0x52, %esi
callq 0x6160
cmpq $0x0, %rax
je 0x71b21
movq -0x10(%rbp), %rdi
leaq 0x304e(%rip), %rsi      # 0x74b3c
callq 0x6690
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x71b0a
movq $0x0, -0x8(%rbp)
jmp 0x71bb4
callq 0x72e40
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x71b8f
movq -0x18(%rbp), %rdi
movl $0x77, %esi
callq 0x6160
cmpq $0x0, %rax
jne 0x71b49
movq -0x18(%rbp), %rdi
movl $0x57, %esi
callq 0x6160
cmpq $0x0, %rax
je 0x71b8d
movq -0x10(%rbp), %rdi
leaq 0x4f84(%rip), %rsi      # 0x76ad8
callq 0x6690
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x71b6d
movq $0x0, -0x8(%rbp)
jmp 0x71bb4
movq -0x18(%rbp), %rdi
callq 0x71c80
movl %eax, %edi
callq 0x71bc0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x71b8f
callq 0x72ea0
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x3, %edx
shll $0x12, %edx
andl $0xfff3ffff, %ecx       # imm = 0xFFF3FFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x6310
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xfffcffff, %ecx       # imm = 0xFFFCFFFF
orl $0x10000, %ecx          # imm = 0x10000
movl %ecx, (%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x6780
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x6780
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x4(%rbp)
jge 0x71c2c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x71c32
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xfff, %edx            # imm = 0xFFF
shll $0x14, %edx
andl $0xfffff, %ecx          # imm = 0xFFFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
sarl $0x14, %eax
cmpl $0x9, %eax
jle 0x71c70
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
orl $0xfff00000, %ecx       # imm = 0xFFF00000
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x71cd9
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x71ccc
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x71ccc
jmp 0x71cd9
jmp 0x71cce
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x71c9a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x71cf9
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x75, %esi
callq 0x6160
cmpq $0x0, %rax
je 0x71d14
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0xff00, %edi           # imm = 0xFF00
callq 0x68b0
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x71d4b
jmp 0x71d6a
leaq 0x4d1e(%rip), %rdi      # 0x76a70
leaq 0x4d4c(%rip), %rsi      # 0x76aa5
movl $0xa6, %edx
leaq 0x4d75(%rip), %rcx      # 0x76ada
callq 0x6300
movq -0x18(%rbp), %rdi
movl $0x72, %esi
callq 0x6160
cmpq $0x0, %rax
jne 0x71d92
movq -0x18(%rbp), %rdi
movl $0x52, %esi
callq 0x6160
cmpq $0x0, %rax
je 0x71dcf
movl -0xc(%rbp), %edi
leaq 0x2da0(%rip), %rsi      # 0x74b3c
callq 0x65e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x71db8
movq $0x0, -0x8(%rbp)
jmp 0x71e61
callq 0x72e40
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x71e3c
movq -0x18(%rbp), %rdi
movl $0x77, %esi
callq 0x6160
cmpq $0x0, %rax
jne 0x71df7
movq -0x18(%rbp), %rdi
movl $0x57, %esi
callq 0x6160
cmpq $0x0, %rax
je 0x71e3a
movl -0xc(%rbp), %edi
leaq 0x4cd7(%rip), %rsi      # 0x76ad8
callq 0x65e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x71e1a
movq $0x0, -0x8(%rbp)
jmp 0x71e61
movq -0x18(%rbp), %rdi
callq 0x71c80
movl %eax, %edi
callq 0x71bc0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x71e3c
callq 0x72ea0
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x3, %edx
shll $0x12, %edx
andl $0xfff3ffff, %ecx       # imm = 0xFFF3FFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: check_header
static int check_header(const uint8_t *header)
{
	return (header[0] == 31 && header[1] == 139 && header[2] == 8 && (header[3] & 4) != 0
			&& unpackInt16((uint8_t*)&header[10]) == 6
			&& header[12] == 'B' && header[13] == 'C'
			&& unpackInt16((uint8_t*)&header[14]) == 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x1f, %ecx
movb %al, -0x9(%rbp)
jne 0x72110
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x8b, %ecx
movb %al, -0x9(%rbp)
jne 0x72110
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %ecx
xorl %eax, %eax
cmpl $0x8, %ecx
movb %al, -0x9(%rbp)
jne 0x72110
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %ecx
andl $0x4, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x72110
movq -0x8(%rbp), %rdi
addq $0xa, %rdi
callq 0x72120
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x6, %ecx
movb %al, -0x9(%rbp)
jne 0x72110
movq -0x8(%rbp), %rax
movzbl 0xc(%rax), %ecx
xorl %eax, %eax
cmpl $0x42, %ecx
movb %al, -0x9(%rbp)
jne 0x72110
movq -0x8(%rbp), %rax
movzbl 0xd(%rax), %ecx
xorl %eax, %eax
cmpl $0x43, %ecx
movb %al, -0x9(%rbp)
jne 0x72110
movq -0x8(%rbp), %rdi
addq $0xe, %rdi
callq 0x72120
cmpl $0x2, %eax
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: auton1[P]viterbi/bgzf.c
// Function: inflate_block
static int inflate_block(BGZF* fp, int block_length)
{
	z_stream zs;
	zs.zalloc = NULL;
	zs.zfree = NULL;
	zs.next_in = (Bytef*)fp->compressed_block + 18;
	zs.avail_in = block_length - 16;
	zs.next_out = (Bytef*)fp->uncompressed_block;
	zs.avail_out = BGZF_MAX_BLOCK_SIZE;

	if (inflateInit2(&zs, -15) != Z_OK) {
		fp->errcode |= BGZF_ERR_ZLIB;
		return -1;
	}
	if (inflate(&zs, Z_FINISH) != Z_STREAM_END) {
		inflateEnd(&zs);
		fp->errcode |= BGZF_ERR_ZLIB;
		return -1;
	}
	if (inflateEnd(&zs) != Z_OK) {
		fp->errcode |= BGZF_ERR_ZLIB;
		return -1;
	}
	return zs.total_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x12, %rax
movq %rax, -0x88(%rbp)
movl -0x14(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x10000, -0x68(%rbp)   # imm = 0x10000
leaq -0x88(%rbp), %rdi
movl $0xfffffff1, %esi       # imm = 0xFFFFFFF1
leaq 0x230b(%rip), %rdx      # 0x744af
movl $0x70, %ecx
callq 0x6480
cmpl $0x0, %eax
je 0x721e0
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x1, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7226e
leaq -0x88(%rbp), %rdi
movl $0x4, %esi
callq 0x6400
cmpl $0x1, %eax
je 0x7222c
leaq -0x88(%rbp), %rdi
callq 0x65c0
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x1, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7226e
leaq -0x88(%rbp), %rdi
callq 0x65c0
cmpl $0x0, %eax
je 0x72267
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x1, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7226e
movq -0x60(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_read
ssize_t bgzf_read(BGZF *fp, void *data, size_t length)
{
	ssize_t bytes_read = 0;
	uint8_t *output = (uint8_t*)data;
	if (length <= 0) return 0;
	assert(fp->is_write == 0);
	while (bytes_read < length) {
		int copy_length, available = fp->block_length - fp->block_offset;
		uint8_t *buffer;
		if (available <= 0) {
			if (bgzf_read_block(fp) != 0) return -1;
			available = fp->block_length - fp->block_offset;
			if (available <= 0) break;
		}
		copy_length = length - bytes_read < available? length - bytes_read : available;
		buffer = (uint8_t*)fp->uncompressed_block;
		memcpy(output, buffer + fp->block_offset, copy_length);
		fp->block_offset += copy_length;
		output += copy_length;
		bytes_read += copy_length;
	}
	if (fp->block_offset == fp->block_length) {
		fp->block_address = _bgzf_tell((_bgzf_file_t)fp->fp);
		fp->block_offset = fp->block_length = 0;
	}
	return bytes_read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
ja 0x722c8
movq $0x0, -0x8(%rbp)
jmp 0x72425
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0xe, %eax
sarl $0x1e, %eax
cmpl $0x0, %eax
jne 0x722db
jmp 0x722fa
leaq 0x481c(%rip), %rdi      # 0x76afe
leaq 0x47bc(%rip), %rsi      # 0x76aa5
movl $0x162, %edx            # imm = 0x162
leaq 0x481b(%rip), %rcx      # 0x76b10
callq 0x6300
jmp 0x722fc
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x723df
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jg 0x7235a
movq -0x10(%rbp), %rdi
callq 0x71e70
cmpl $0x0, %eax
je 0x7233c
movq $-0x1, -0x8(%rbp)
jmp 0x72425
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jg 0x72358
jmp 0x723df
jmp 0x7235a
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jae 0x72379
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x72381
movslq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rsi
movslq -0x34(%rbp), %rdx
callq 0x6430
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movslq -0x34(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x722fc
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x7241d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x66e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_flush
int bgzf_flush(BGZF *fp)
{
	if (!fp->is_write) return 0;
#ifdef BGZF_MT
	if (fp->mt) return mt_flush(fp);
#endif
	while (fp->block_offset > 0) {
		int block_length;
		block_length = deflate_block(fp, fp->block_offset);
		if (block_length < 0) return -1;
		if (fwrite(fp->compressed_block, 1, block_length, (FILE*)fp->fp) != (size_t)block_length) {
			fp->errcode |= BGZF_ERR_IO; // possibly truncated file
			return -1;
		}
		fp->block_address += block_length;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0xe, %eax
sarl $0x1e, %eax
cmpl $0x0, %eax
jne 0x72459
movl $0x0, -0x4(%rbp)
jmp 0x724f8
jmp 0x7245b
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x724f1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x72510
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x7248b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x724f8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movl $0x1, %esi
callq 0x6ad0
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x724dc
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x4, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x724f8
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x7245b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: deflate_block
static int deflate_block(BGZF *fp, int block_length)
{
	int comp_size = BGZF_MAX_BLOCK_SIZE;
	if (bgzf_compress(fp->compressed_block, &comp_size, fp->uncompressed_block, block_length, fp->compress_level) != 0) {
		fp->errcode |= BGZF_ERR_ZLIB;
		return -1;
	}
	fp->block_offset = 0;
	return comp_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x10000, -0x18(%rbp)   # imm = 0x10000
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl (%rax), %r8d
sarl $0x14, %r8d
leaq -0x18(%rbp), %rsi
callq 0x72ec0
cmpl $0x0, %eax
je 0x7257c
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x1, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7258d
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_write
ssize_t bgzf_write(BGZF *fp, const void *data, size_t length)
{
	const uint8_t *input = (const uint8_t*)data;
	int block_length = BGZF_BLOCK_SIZE, bytes_written = 0;
	assert(fp->is_write);
#ifdef BGZF_MT
	if (fp->mt) return mt_write(fp, data, length);
#endif
	while (bytes_written < length) {
		uint8_t* buffer = (uint8_t*)fp->uncompressed_block;
		int copy_length = block_length - fp->block_offset < length - bytes_written? block_length - fp->block_offset : length - bytes_written;
		memcpy(buffer + fp->block_offset, input, copy_length);
		fp->block_offset += copy_length;
		input += copy_length;
		bytes_written += copy_length;
		if (fp->block_offset == block_length && bgzf_flush(fp)) break;
	}
	return bytes_written;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xff00, -0x24(%rbp)    # imm = 0xFF00
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll $0xe, %eax
sarl $0x1e, %eax
cmpl $0x0, %eax
je 0x7262d
jmp 0x7264c
leaq 0x4506(%rip), %rdi      # 0x76b3a
leaq 0x446a(%rip), %rsi      # 0x76aa5
movl $0x239, %edx            # imm = 0x239
leaq 0x4500(%rip), %rcx      # 0x76b47
callq 0x6300
jmp 0x7264e
movslq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x72710
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0xc(%rcx), %eax
cltq
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x72696
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0xc(%rcx), %eax
cltq
movq %rax, -0x40(%rbp)
jmp 0x726a5
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x6430
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x7270b
movq -0x8(%rbp), %rdi
callq 0x72430
cmpl $0x0, %eax
je 0x7270b
jmp 0x72710
jmp 0x7264e
movslq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_close
int bgzf_close(BGZF* fp)
{
	int ret, block_length;
	if (fp == 0) return -1;
	if (fp->is_write) {
		if (bgzf_flush(fp) != 0) return -1;
		fp->compress_level = -1;
		block_length = deflate_block(fp, 0); // write an empty block
		fwrite(fp->compressed_block, 1, block_length, (FILE*)fp->fp);
		if (fflush((FILE*)fp->fp) != 0) {
			fp->errcode |= BGZF_ERR_IO;
			return -1;
		}
#ifdef BGZF_MT
		if (fp->mt) mt_destroy((mtaux_t*)fp->mt);
#endif
	}
	ret = fp->is_write? fclose((FILE*)fp->fp) : _bgzf_close(fp->fp);
	if (ret != 0) return -1;
	free(fp->uncompressed_block);
	free(fp->compressed_block);
	free_cache(fp);
	free(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7273f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72867
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0xe, %eax
sarl $0x1e, %eax
cmpl $0x0, %eax
je 0x727ec
movq -0x10(%rbp), %rdi
callq 0x72430
cmpl $0x0, %eax
je 0x7276e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72867
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
orl $0xfff00000, %ecx       # imm = 0xFFF00000
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x72510
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movl $0x1, %esi
callq 0x6ad0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x6680
cmpl $0x0, %eax
je 0x727ea
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x4, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72867
jmp 0x727ec
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0xe, %eax
sarl $0x1e, %eax
cmpl $0x0, %eax
je 0x7280f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x6550
movl %eax, -0x1c(%rbp)
jmp 0x7281f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x6550
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x72834
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72867
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x66a0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x66a0
movq -0x10(%rbp), %rdi
callq 0x72870
movq -0x10(%rbp), %rdi
callq 0x66a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_check_EOF
int bgzf_check_EOF(BGZF *fp)
{
	uint8_t buf[28];
	off_t offset;
	offset = _bgzf_tell((_bgzf_file_t)fp->fp);
	if (_bgzf_seek(fp->fp, -28, SEEK_END) < 0) return 0;
	_bgzf_read(fp->fp, buf, 28);
	_bgzf_seek(fp->fp, offset, SEEK_SET);
	return (memcmp("\037\213\010\4\0\0\0\0\0\377\6\0\102\103\2\0\033\0\3\0\0\0\0\0\0\0\0\0", buf, 28) == 0)? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x66e0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq $-0x1c, %rsi
movl $0x2, %edx
callq 0x6290
cmpl $0x0, %eax
jge 0x728e4
movl $0x0, -0x4(%rbp)
jmp 0x72939
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movl $0x1, %esi
movl $0x1c, %edx
callq 0x6840
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x6290
leaq -0x30(%rbp), %rsi
leaq 0x4263(%rip), %rdi      # 0x76b80
movl $0x1c, %edx
callq 0x61e0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_seek
int64_t bgzf_seek(BGZF* fp, int64_t pos, int where)
{
	int block_offset;
	int64_t block_address;

	if (fp->is_write || where != SEEK_SET) {
		fp->errcode |= BGZF_ERR_MISUSE;
		return -1;
	}
	block_offset = pos & 0xFFFF;
	block_address = pos >> 16;
	if (_bgzf_seek(fp->fp, block_address, SEEK_SET) < 0) {
		fp->errcode |= BGZF_ERR_IO;
		return -1;
	}
	fp->block_length = 0;  // indicates current block has not been loaded
	fp->block_address = block_address;
	fp->block_offset = block_offset;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0xe, %eax
sarl $0x1e, %eax
cmpl $0x0, %eax
jne 0x7297a
cmpl $0x0, -0x1c(%rbp)
je 0x729a8
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x8, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x72a2d
movq -0x18(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
sarq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x6290
cmpl $0x0, %eax
jge 0x72a04
movq -0x10(%rbp), %rax
movl (%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
orl $0x4, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x72a2d
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_is_bgzf
int bgzf_is_bgzf(const char *fn)
{
	uint8_t buf[16];
	int n;
	_bgzf_file_t fp;
	if ((fp = _bgzf_open(fn, "r")) == 0) return 0;
	n = _bgzf_read(fp, buf, 16);
	_bgzf_close(fp);
	if (n != 16) return 0;
	return memcmp(g_magic, buf, 16) == 0? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20e5(%rip), %rsi      # 0x74b3c
callq 0x6690
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x72a6f
movl $0x0, -0x4(%rbp)
jmp 0x72ad2
leaq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x6840
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6550
cmpl $0x10, -0x24(%rbp)
je 0x72aa1
movl $0x0, -0x4(%rbp)
jmp 0x72ad2
leaq -0x20(%rbp), %rax
movups (%rax), %xmm0
movaps 0x3fb1(%rip), %xmm1     # 0x76a60
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: auton1[P]viterbi/bgzf.c
// Function: bgzf_getc
int bgzf_getc(BGZF *fp)
{
	int c;
	if (fp->block_offset >= fp->block_length) {
		if (bgzf_read_block(fp) != 0) return -2; /* error */
		if (fp->block_length == 0) return -1; /* end-of-file */
	}
	c = ((unsigned char*)fp->uncompressed_block)[fp->block_offset++];
    if (fp->block_offset == fp->block_length) {
        fp->block_address = _bgzf_tell((_bgzf_file_t)fp->fp);
        fp->block_offset = 0;
        fp->block_length = 0;
    }
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x72b28
movq -0x10(%rbp), %rdi
callq 0x71e70
cmpl $0x0, %eax
je 0x72b13
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x72b8d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x72b26
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x72b8d
jmp 0x72b28
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0xc(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rdx)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x72b87
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x66e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)