LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_genotypes_by_filter_flag(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, bool)
void entry::filter_genotypes_by_filter_flag(const set<string> &filter_flags_to_remove, bool remove_all)
{
	// Filter genotypes by Filter Flags
	if (passed_filters == false)
		return;

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

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

	filter_genotypes_by_filter_status(filter_flags_to_remove, remove_all);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0xc(%rdi)
je 0x2bb05
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testb %bpl, %bpl
jne 0x2ba94
cmpq $0x0, 0x28(%rbx)
je 0x2bb05
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%r14)
jne 0x2baf5
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xf2f3(%rip), %rsi      # 0x3adb4
leaq 0xf33a(%rip), %rdx      # 0x3ae02
movq %rsp, %r15
movq %r15, %rdi
callq 0xc868
leaq 0x1e9ce(%rip), %rdi     # 0x4a4a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x3721e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2baf5
callq 0x5410
movq (%r14), %rax
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2bb23
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_HWE_pvalue(double)
void entry::filter_sites_by_HWE_pvalue(double min_HWE_pvalue)
{
	// Filter sites by HWE p-value
	// Note this assumes Biallelic SNPs.
	if(passed_filters == false)
		return;

	if (min_HWE_pvalue <= 0)
		return;

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

	parse_basic_entry(true);
	parse_genotype_entries(true);

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

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

	if (p_hwe < min_HWE_pvalue)
		passed_filters = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2c072
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2c072
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x2c020
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xefd9(%rip), %rsi      # 0x3afc2
leaq 0xf00b(%rip), %rdx      # 0x3affb
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xc868
leaq 0x1e4a4(%rip), %rdi     # 0x4a4a8
movq %r14, %rsi
movl $0x1, %edx
callq 0x3721e
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2c020
callq 0x5410
leaq 0x1c(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x23686
movl (%r15), %edi
movl (%r14), %esi
movl (%r12), %edx
leaq 0x50(%rsp), %r14
leaq 0x48(%rsp), %r8
leaq 0x40(%rsp), %r9
movq %r14, %rcx
callq 0x1f810
movsd 0x8(%rsp), %xmm0
ucomisd (%r14), %xmm0
jbe 0x2c072
movb $0x0, 0xc(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2c090
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c126
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2c126
movl %esi, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x3e0(%rbx), %r14
movq 0x3e8(%rbx), %rdx
cmpq 0x1f51d(%rip), %rdx     # 0x4b5f0
jne 0x2c101
testq %rdx, %rdx
je 0x2c0ed
movq 0x1f507(%rip), %rsi     # 0x4b5e8
movq (%r14), %rdi
callq 0x5470
testl %eax, %eax
jne 0x2c101
movl 0x400(%rbx), %eax
subl 0x1f50f(%rip), %eax     # 0x4b608
cmpl %ebp, %eax
jge 0x2c101
movb $0x0, 0xc(%rbx)
cmpb $0x1, 0xc(%rbx)
jne 0x2c113
movl 0x400(%rbx), %eax
movl %eax, 0x1f4f5(%rip)     # 0x4b608
leaq 0x1f4ce(%rip), %rdi     # 0x4b5e8
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x51f0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c49b
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xebaf(%rip), %rsi      # 0x3aeff
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x2c49b
leaq 0xeb98(%rip), %rsi      # 0x3aeff
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x2c469
cmpq $0x0, 0x1efa1(%rip)     # 0x4b320
jne 0x2c469
movq (%r14), %rsi
leaq 0x40(%rsp), %rdi
movl $0x8, %edx
callq 0x5820
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0xb8(%rsp), %rdi
callq 0x50b0
testb %al, %al
jne 0x2c3f3
leaq 0xea60(%rip), %rsi      # 0x3ae24
movq %rsp, %rdi
movq %r14, %rdx
callq 0xb7dd
leaq 0x1e0d2(%rip), %rdi     # 0x4a4a8
movq %rsp, %rsi
xorl %edx, %edx
callq 0x3721e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c3f3
callq 0x5410
leaq 0x40(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x1eef4(%rip), %r12     # 0x4b2f8
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x60(%rsp,%rax)
jne 0x2c446
movq %r14, %rdi
movq %r15, %rsi
callq 0x5590
movq %r12, %rdi
movq %r15, %rsi
callq 0x2ca08
movq %r14, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x5260
jmp 0x2c40e
leaq 0x40(%rsp), %rdi
callq 0x50a0
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c45f
callq 0x5410
leaq 0x40(%rsp), %rdi
callq 0x58a0
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x408(%rbx), %rsi
leaq 0x1ee72(%rip), %rdi     # 0x4b2f8
callq 0xe596
leaq 0x1ee6e(%rip), %rcx     # 0x4b300
cmpq %rcx, %rax
je 0x2c49b
movb $0x0, 0xc(%rbx)
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c4ca
callq 0x5410
jmp 0x2c4ca
jmp 0x2c4c7
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c4d9
callq 0x5410
leaq 0x40(%rsp), %rdi
callq 0x58a0
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e99d
movq %r13, %rsi
movq %r14, %rdx
callq 0x2ec2e
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2efb0
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2efb0
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2ec2e
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/output_log.cpp
// Function: output_log::open(bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void output_log::open(bool stout, bool sterr, const string &filename_prefix)
{
	if (stout)
	{
		output_to_screen = false;
		output_to_file = true;
	}

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x37139
movw $0x100, (%rbx)          # imm = 0x100
testb %dl, %dl
je 0x37142
movw $0x1, (%rbx)
cmpb $0x1, 0x1(%rbx)
jne 0x37198
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0xc7d8
leaq 0x4add(%rip), %rsi      # 0x3bc4a
movq %r14, %rdi
callq 0x5870
addq $0x8, %rbx
movq (%rsp), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x5060
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x37198
callq 0x5410
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x371a4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x371b5
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x371e8
leaq 0x8(%r14), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x54f0
leaq 0x8(%r14), %rdi
callq 0x52c0
cmpb $0x1, (%r14)
jne 0x3720a
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x12deb(%rip), %rdi     # 0x49ff0
callq 0x54f0
movq 0x12ddf(%rip), %rdi     # 0x49ff0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x492f(%rip), %rsi      # 0x3bc42
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0xb7dd
leaq 0x1e2f(%rip), %rsi      # 0x39156
movq %r15, %rdi
callq 0x5870
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x37350
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x3735d
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x371c8
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x37390
callq 0x5410
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x373a3
callq 0x5410
leaq 0x58(%rsp), %rdi
callq 0x52e0
leaq 0x68(%rsp), %r15
leaq 0x4896(%rip), %rsi      # 0x3bc4f
movl $0x7, %edx
movq %r15, %rdi
callq 0x54f0
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x56e0
movq %rax, %r15
leaq 0x4879(%rip), %rsi      # 0x3bc57
movl $0x8, %edx
movq %rax, %rdi
callq 0x54f0
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x56e0
movq %rax, %rdi
callq 0x51b0
leaq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x56c0
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x371c8
leaq 0x38(%rsp), %rdi
callq 0x58b0
movl %ebx, %edi
callq 0x5540
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37449
callq 0x5410
jmp 0x37449
movq %rax, %rbx
movq 0x12b30(%rip), %rsi     # 0x49f80
leaq 0x58(%rsp), %rdi
callq 0x5330
leaq 0xd8(%rsp), %rdi
callq 0x5100
jmp 0x37493
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x37480
callq 0x5410
jmp 0x37480
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37493
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/output_log.cpp
// Function: output_log::one_off_warning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void output_log::one_off_warning(string err_msg)
{
	static set<string> previous_warnings;
	if (previous_warnings.find(err_msg) == previous_warnings.end())
	{
		printLOG(err_msg + "\n");
		previous_warnings.insert(err_msg);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x1416b(%rip), %al      # 0x4b698
testb %al, %al
je 0x375b7
leaq 0x1412c(%rip), %rdi     # 0x4b668
movq %rbx, %rsi
callq 0xe596
leaq 0x14125(%rip), %rcx     # 0x4b670
cmpq %rcx, %rax
jne 0x375ab
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc7d8
leaq 0x1bde(%rip), %rsi      # 0x39156
movq %r15, %rdi
callq 0x5870
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x371c8
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3759c
callq 0x5410
leaq 0x140c5(%rip), %rdi     # 0x4b668
movq %rbx, %rsi
callq 0x2ca08
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5f7a
jmp 0x37535
jmp 0x375c3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x375d5
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/output_log.cpp
// Function: output_log::dbl2str[abi:cxx11](double, int)
string output_log::dbl2str(double n, int prc)
{
  std::ostringstream s2;
  if ( prc > 0 )
    s2.precision(prc);
  s2 << n;
  return s2.str();
}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xff00, %edi           # imm = 0xFF00
callq 0x56d0
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x378f4
movq %rbx, %rdi
movl $0x72, %esi
callq 0x5130
testq %rax, %rax
jne 0x37888
movq %rbx, %rdi
movl $0x52, %esi
callq 0x5130
testq %rax, %rax
je 0x378b7
leaq 0x237d(%rip), %rsi      # 0x39c0c
movq %r14, %rdi
callq 0x5520
movq %rax, %rbx
testq %rax, %rax
je 0x378aa
callq 0x3834f
movq %rbx, 0x30(%rax)
jmp 0x378ac
xorl %eax, %eax
testq %rbx, %rbx
je 0x378ea
andb $-0xd, 0x2(%rax)
jmp 0x378ec
leaq 0x442a(%rip), %rsi      # 0x3bce8
movq %r14, %rdi
callq 0x5520
movq %rax, %r14
testq %rax, %rax
je 0x378e3
movq %rbx, %rdi
callq 0x37995
movl %eax, %edi
callq 0x37913
movq %r14, 0x30(%rax)
jmp 0x378e5
xorl %eax, %eax
testq %r14, %r14
jne 0x378b1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4385(%rip), %rdi      # 0x3bc80
leaq 0x43b3(%rip), %rsi      # 0x3bcb5
leaq 0x43b3(%rip), %rcx      # 0x3bcbc
movl $0x93, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x1, %edi
movl $0x38, %esi
callq 0x52a0
movq %rax, %rbx
movl $0xfffcffff, %r14d      # imm = 0xFFFCFFFF
andl (%rax), %r14d
leal 0x10000(%r14), %r15d
movl %r15d, (%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x18(%rbx)
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x20(%rbx)
testl %ebp, %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
shll $0x14, %eax
andl $0xdffff, %r15d         # imm = 0xDFFFF
orl %eax, %r15d
orl $0xfff10000, %r14d      # imm = 0xFFF10000
cmpl $0x900001, %eax         # imm = 0x900001
cmovll %r15d, %r14d
movl %r14d, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x379ad
leal -0x30(%rax), %edx
incq %rcx
cmpb $0x9, %dl
ja 0x3799b
leal -0x30(%rax), %ecx
xorl %ebp, %ebp
cmpl $0x1, %eax
movl $0x0, %ebx
sbbl %ebx, %ebx
orl %ecx, %ebx
movl $0x75, %esi
callq 0x5130
testq %rax, %rax
cmovnel %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bgzf.c
// Function: bgzf_dopen
BGZF *bgzf_dopen(int fd, const char *mode)
{
	BGZF *fp = 0;
	assert(compressBound(BGZF_BLOCK_SIZE) < BGZF_MAX_BLOCK_SIZE);
	if (strchr(mode, 'r') || strchr(mode, 'R')) {
		_bgzf_file_t fpr;
		if ((fpr = _bgzf_dopen(fd, "r")) == 0) return 0;
		fp = bgzf_read_init();
		fp->fp = fpr;
	} else if (strchr(mode, 'w') || strchr(mode, 'W')) {
		FILE *fpw;
		if ((fpw = fdopen(fd, "w")) == 0) return 0;
		fp = bgzf_write_init(mode2level(mode));
		fp->fp = fpw;
	}
	fp->is_be = ed_is_big();
	return fp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl $0xff00, %edi           # imm = 0xFF00
callq 0x56d0
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x37a81
movq %rbx, %rdi
movl $0x72, %esi
callq 0x5130
testq %rax, %rax
jne 0x37a1a
movq %rbx, %rdi
movl $0x52, %esi
callq 0x5130
testq %rax, %rax
je 0x37a48
leaq 0x21eb(%rip), %rsi      # 0x39c0c
movl %ebp, %edi
callq 0x54c0
movq %rax, %rbx
testq %rax, %rax
je 0x37a3b
callq 0x3834f
movq %rbx, 0x30(%rax)
jmp 0x37a3d
xorl %eax, %eax
testq %rbx, %rbx
je 0x37a7a
andb $-0xd, 0x2(%rax)
jmp 0x37a7c
leaq 0x4299(%rip), %rsi      # 0x3bce8
movl %ebp, %edi
callq 0x54c0
movq %rax, %r14
testq %rax, %rax
je 0x37a73
movq %rbx, %rdi
callq 0x37995
movl %eax, %edi
callq 0x37913
movq %r14, 0x30(%rax)
jmp 0x37a75
xorl %eax, %eax
testq %r14, %r14
jne 0x37a42
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x41f8(%rip), %rdi      # 0x3bc80
leaq 0x4226(%rip), %rsi      # 0x3bcb5
leaq 0x4254(%rip), %rcx      # 0x3bcea
movl $0xa6, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5560
movq %rax, %r14
movq 0x30(%rbx), %rcx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x12, %edx
callq 0x5630
testl %eax, %eax
je 0x37b02
cmpl $0x12, %eax
jne 0x37af8
cmpb $0x1f, (%rsp)
jne 0x37af8
cmpb $-0x75, 0x1(%rsp)
jne 0x37af8
cmpb $0x8, 0x2(%rsp)
jne 0x37af8
testb $0x4, 0x3(%rsp)
jne 0x37b1b
orb $0x2, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x37b0b
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpw $0x6, 0xa(%rsp)
jne 0x37af8
cmpb $0x42, 0xc(%rsp)
jne 0x37af8
cmpb $0x43, 0xd(%rsp)
jne 0x37af8
cmpw $0x2, 0xe(%rsp)
jne 0x37af8
movzwl 0x10(%rsp), %r12d
movq 0x20(%rbx), %rdi
movzwl 0x10(%rsp), %eax
movw %ax, 0x10(%rdi)
movaps (%rsp), %xmm0
movups %xmm0, (%rdi)
leaq -0x11(%r12), %r15
addq $0x12, %rdi
movq 0x30(%rbx), %rcx
movl $0x1, %esi
movq %r15, %rdx
callq 0x5630
cmpl %eax, %r15d
jne 0x37c0c
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 0x1999(%rip), %rdx      # 0x39544
movl $0xfffffff1, %esi       # imm = 0xFFFFFFF1
movl $0x70, %ecx
callq 0x53c0
testl %eax, %eax
jne 0x37be3
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x4, %esi
callq 0x5360
movl %eax, %ebp
movq %r15, %rdi
callq 0x54a0
cmpl $0x1, %ebp
jne 0x37be3
testl %eax, %eax
je 0x37c14
orb $0x1, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x37afb
cmpl $0x0, 0x8(%rbx)
je 0x37c00
movl $0x0, 0xc(%rbx)
movq %r14, 0x10(%rbx)
movl %eax, 0x8(%rbx)
jmp 0x37b09
orb $0x4, (%rbx)
jmp 0x37afb
movl 0x48(%rsp), %eax
jmp 0x37beb
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x37cce
movq %rdi, %r14
testb $0x3, 0x2(%rdi)
jne 0x37ceb
movq %rdx, %r15
movq %rsi, %r12
xorl %ebx, %ebx
movq %r15, %rbp
subq %rbx, %rbp
jbe 0x37cad
movl 0x8(%r14), %eax
subl 0xc(%r14), %eax
jle 0x37c80
movl %eax, %r13d
cmpq %r13, %rbp
cmovbq %rbp, %r13
movslq 0xc(%r14), %rsi
addq 0x18(%r14), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x5380
addl %r13d, 0xc(%r14)
addq %r13, %r12
addq %r13, %rbx
xorl %ecx, %ecx
jmp 0x37c91
movq %r14, %rdi
callq 0x37aa0
movl $0x1, %ecx
testl %eax, %eax
je 0x37c97
testl %ecx, %ecx
je 0x37c43
jmp 0x37ca8
movl 0x8(%r14), %eax
subl 0xc(%r14), %eax
jg 0x37c55
movl $0x3, %ecx
jmp 0x37c91
cmpl $0x3, %ecx
jne 0x37cd2
movl 0xc(%r14), %eax
cmpl 0x8(%r14), %eax
jne 0x37cd9
movq 0x30(%r14), %rdi
callq 0x5560
movq %rax, 0x10(%r14)
movq $0x0, 0x8(%r14)
jmp 0x37cd9
xorl %ebx, %ebx
jmp 0x37cd9
movq $-0x1, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x401c(%rip), %rdi      # 0x3bd0e
leaq 0x3fbc(%rip), %rsi      # 0x3bcb5
leaq 0x4020(%rip), %rcx      # 0x3bd20
movl $0x162, %edx            # imm = 0x162
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
testb $0x3, 0x2(%rdi)
je 0x37d57
movq %rdi, %rbx
movl 0xc(%rdi), %esi
testl %esi, %esi
jle 0x37d57
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x37d65
testl %eax, %eax
js 0x37d59
movl %eax, %r14d
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rcx
movl $0x1, %esi
movq %r14, %rdx
callq 0x5880
cmpq %r14, %rax
jne 0x37d60
addq %r14, 0x10(%rbx)
movl 0xc(%rbx), %esi
testl %esi, %esi
jg 0x37d23
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
orb $0x4, (%rbx)
jmp 0x37d59
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %r13d
movq %rdi, %rbx
movq 0x20(%rdi), %rbp
movq 0x18(%rdi), %r14
movl (%rdi), %esi
sarl $0x14, %esi
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdi
movups %xmm0, 0x40(%rdi)
movq %r14, (%rdi)
movl %r13d, 0x8(%rdi)
leaq 0x12(%rbp), %rax
movq %rax, 0x18(%rdi)
movl $0xffe6, 0x20(%rdi)     # imm = 0xFFE6
leaq 0x1795(%rip), %rax      # 0x39544
xorl %r12d, %r12d
movl $0x8, %edx
movl $0xfffffff1, %ecx       # imm = 0xFFFFFFF1
movl $0x8, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x5070
addq $0x10, %rsp
movl $0x10000, %r15d         # imm = 0x10000
testl %eax, %eax
jne 0x37e00
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x51a0
cmpl $0x1, %eax
jne 0x37dfd
leaq 0x8(%rsp), %rdi
callq 0x5220
testl %eax, %eax
je 0x37e29
xorl %r12d, %r12d
testb %r12b, %r12b
je 0x37e0e
movl $0x0, 0xc(%rbx)
jmp 0x37e17
orb $0x1, (%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x30(%rsp), %eax
leal 0x1a(%rax), %r15d
movaps 0x3f78(%rip), %xmm0     # 0x3bdb0
movups %xmm0, (%rbp)
addl $0x19, %eax
movw %ax, 0x10(%rbp)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5300
movq %rax, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x5300
movslq %r15d, %rcx
movb %al, -0x8(%rbp,%rcx)
movb %ah, -0x7(%rbp,%rcx)
movl %eax, %edx
shrl $0x10, %edx
movb %dl, -0x6(%rbp,%rcx)
shrl $0x18, %eax
movb %al, -0x5(%rbp,%rcx)
movl %r13d, %edx
movb %dl, -0x4(%rbp,%rcx)
movb %dh, -0x3(%rbp,%rcx)
movl %r13d, %eax
shrl $0x10, %eax
movb %al, -0x2(%rbp,%rcx)
shrl $0x18, %edx
movb %dl, -0x1(%rbp,%rcx)
movb $0x1, %r12b
jmp 0x37e00
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testb $0x3, 0x2(%rdi)
je 0x37f3f
movq %rdx, %r14
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x37f32
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
movslq 0xc(%r12), %rdi
movl $0xff00, %ecx           # imm = 0xFF00
subq %rdi, %rcx
movq %r14, %rdx
subq %rax, %rdx
cmpq %rcx, %rdx
cmoval %ecx, %edx
addq 0x18(%r12), %rdi
movslq %edx, %r13
movq %r15, %rsi
movq %r13, %rdx
callq 0x5380
addl %r13d, %ebx
movl 0xc(%r12), %eax
addl %r13d, %eax
movl %eax, 0xc(%r12)
addq %r13, %r15
cmpl $0xff00, %eax           # imm = 0xFF00
jne 0x37f27
movq %r12, %rdi
callq 0x37d0a
testl %eax, %eax
jne 0x37f2f
movslq %ebx, %rax
cmpq %r14, %rax
jb 0x37ed5
movslq %ebx, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3e04(%rip), %rdi      # 0x3bd4a
leaq 0x3d68(%rip), %rsi      # 0x3bcb5
leaq 0x3e03(%rip), %rcx      # 0x3bd57
movl $0x239, %edx            # imm = 0x239
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x37fe0
movq %rdi, %rbx
testb $0x3, 0x2(%rdi)
je 0x37fb7
movq %rbx, %rdi
callq 0x37d0a
testl %eax, %eax
jne 0x37fe0
orl $0xfff00000, (%rbx)     # imm = 0xFFF00000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x37d65
movslq %eax, %rdx
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rcx
movl $0x1, %esi
callq 0x5880
movq 0x30(%rbx), %rdi
callq 0x5510
testl %eax, %eax
je 0x37fb7
orb $0x4, (%rbx)
jmp 0x37fe0
movq 0x30(%rbx), %rdi
callq 0x5450
testl %eax, %eax
jne 0x37fe0
movq 0x18(%rbx), %rdi
callq 0x5530
movq 0x20(%rbx), %rdi
callq 0x5530
movq %rbx, %rdi
callq 0x5530
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5560
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq $-0x1c, %rsi
movl $0x2, %edx
callq 0x5210
testl %eax, %eax
js 0x3807a
movq 0x30(%rbx), %rcx
movq %rsp, %r15
movl $0x1, %esi
movl $0x1c, %edx
movq %r15, %rdi
callq 0x5630
movq 0x30(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5210
movdqu 0xc(%r15), %xmm0
pcmpeqb 0x3c08(%rip), %xmm0     # 0x3bc60
movdqa (%r15), %xmm1
pcmpeqb 0x3c0b(%rip), %xmm1     # 0x3bc70
pand %xmm0, %xmm1
pmovmskb %xmm1, %ecx
xorl %eax, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
sete %al
jmp 0x3807c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
andl $0x30000, %ecx          # imm = 0x30000
orl %edx, %ecx
je 0x380aa
orl $0x8, %eax
movl %eax, (%rbx)
movq $-0x1, %rax
jmp 0x380da
movq %rsi, %r14
movq %rsi, %r15
sarq $0x10, %r15
movq 0x30(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5210
testl %eax, %eax
js 0x380e0
movzwl %r14w, %eax
movl $0x0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movl %eax, 0xc(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
orb $0x4, (%rbx)
jmp 0x380a1
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x1b17(%rip), %rsi      # 0x39c0c
callq 0x5520
xorl %ebx, %ebx
testq %rax, %rax
je 0x38145
movq %rax, %r14
movq %rsp, %rdi
movl $0x1, %esi
movl $0x10, %edx
movq %rax, %rcx
callq 0x5630
movq %rax, %r15
movq %r14, %rdi
callq 0x5450
cmpl $0x10, %r15d
jne 0x38145
movdqa (%rsp), %xmm0
pcmpeqb 0x3b39(%rip), %xmm0     # 0x3bc70
pmovmskb %xmm0, %eax
xorl %ebx, %ebx
cmpl $0xffff, %eax           # imm = 0xFFFF
sete %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %eax
cmpl 0x8(%rdi), %eax
jge 0x3818d
movq 0x18(%rbx), %rax
movslq 0xc(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%rbx)
movzbl (%rax,%rcx), %ebp
cmpl 0x8(%rbx), %edx
jne 0x3819e
movq 0x30(%rbx), %rdi
callq 0x5560
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x3819e
movq %rbx, %rdi
callq 0x37aa0
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
testl %eax, %eax
je 0x381a7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x0, 0x8(%rbx)
jne 0x3815f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x3819e
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bgzf.c
// Function: bgzf_getline
int bgzf_getline(BGZF *fp, int delim, kstring_t *str)
{
	int l, state = 0;
	unsigned char *buf = (unsigned char*)fp->uncompressed_block;
	str->l = 0;
	do {
		if (fp->block_offset >= fp->block_length) {
			if (bgzf_read_block(fp) != 0) { state = -2; break; }
			if (fp->block_length == 0) { state = -1; break; }
		}
		for (l = fp->block_offset; l < fp->block_length && buf[l] != delim; ++l);
		if (l < fp->block_length) state = 1;
		l -= fp->block_offset;
		if (str->l + l + 1 >= str->m) {
			str->m = str->l + l + 2;
			kroundup32(str->m);
			str->s = (char*)realloc(str->s, str->m);
		}
		memcpy(str->s + str->l, buf + fp->block_offset, l);
		str->l += l;
		fp->block_offset += l + 1;
		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;
		} 
	} while (state == 0);
	if (str->l == 0 && state < 0) return state;
	str->s[str->l] = 0;
	return str->l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %r12
movq $0x0, (%rdx)
leaq 0x1(%r12), %rax
movq %rax, (%rsp)
movl 0xc(%r14), %eax
cmpl 0x8(%r14), %eax
jl 0x38202
movq %r14, %rdi
callq 0x37aa0
movb $0x1, %cl
testl %eax, %eax
jne 0x3831b
cmpl $0x0, 0x8(%r14)
je 0x38322
movl 0x8(%r14), %ecx
movl 0xc(%r14), %eax
cmpl %ecx, %eax
setl %r13b
jge 0x3825c
movslq %eax, %rsi
movzbl (%r12,%rsi), %edi
movl %eax, %edx
cmpl %ebp, %edi
je 0x3826f
movslq %ecx, %rdi
movq (%rsp), %rdx
leaq (%rdx,%rsi), %r8
movl $0x1, %r9d
subl %ecx, %r9d
addq %rax, %r9
xorl %edx, %edx
movl %r9d, %r10d
addl %edx, %r10d
je 0x38260
movzbl (%r8,%rdx), %r10d
incq %rdx
cmpl %ebp, %r10d
jne 0x38239
addq %rdx, %rsi
cmpq %rdi, %rsi
setl %r13b
addl %eax, %edx
jmp 0x3826f
movl %eax, %edx
jmp 0x3826f
addq %rsi, %rdx
incq %rdx
cmpq %rdi, %rdx
setl %r13b
movl %ecx, %edx
subl %eax, %edx
movq (%rbx), %rax
movslq %edx, %r15
addq %r15, %rax
incq %rax
cmpq 0x8(%rbx), %rax
jb 0x382c8
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x5720
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movslq 0xc(%r14), %rsi
addq %r12, %rsi
movq %r15, %rdx
callq 0x5380
addq %r15, (%rbx)
movl 0xc(%r14), %eax
addl %r15d, %eax
incl %eax
movl %eax, 0xc(%r14)
cmpl 0x8(%r14), %eax
jl 0x38309
movq 0x30(%r14), %rdi
callq 0x5560
movq %rax, 0x10(%r14)
movq $0x0, 0x8(%r14)
testb %r13b, %r13b
je 0x381db
movl $0x1, %eax
xorl %ecx, %ecx
jmp 0x38327
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x38327
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq (%rbx), %rdx
testq %rdx, %rdx
sete %sil
testb %sil, %cl
jne 0x38340
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%rdx)
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bgzf.c
// Function: bgzf_read_init
static BGZF *bgzf_read_init()
{
	BGZF *fp;
	fp = (BGZF*)calloc(1, sizeof(BGZF));
	fp->is_write = 0;
	fp->uncompressed_block = malloc(BGZF_MAX_BLOCK_SIZE);
	fp->compressed_block = malloc(BGZF_MAX_BLOCK_SIZE);
#ifdef BGZF_CACHE
	fp->cache = kh_init(cache);
#endif
	return fp;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x52a0
movq %rax, %rbx
andb $-0x4, 0x2(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x18(%rbx)
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	if (argc != 2)
	{
		std::cerr << "Usage: ./test seed" << std::endl;
		std::cerr << "Provide a seed please" << std::endl;
		return 1;
	}

	g_seed = atoi(argv[1]);

	section_wrapper(test_containers, "containers");
	section_wrapper(test_others, "others");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x2, %edi
jne 0x2ed8
movq 0x8(%rsi), %rdi
callq 0x22d0
movl %eax, 0x31391(%rip)     # 0x341e0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x231cf(%rip), %rsi     # 0x2602d
leaq 0x231d2(%rip), %rdx     # 0x26037
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0x775c(%rip), %rdi      # 0xa5d4
movq %rbx, %rsi
callq 0x25c70
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e8e
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2319b(%rip), %rsi     # 0x26038
leaq 0x2319a(%rip), %rdx     # 0x2603e
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0x22069(%rip), %rdi     # 0x24f20
movq %rbx, %rsi
callq 0x25c70
movq -0x30(%rbp), %rdi
xorl %ebx, %ebx
cmpq %r14, %rdi
je 0x2f5a
callq 0x21b0
jmp 0x2f5a
movq 0x31111(%rip), %rbx     # 0x33ff0
leaq 0x2311e(%rip), %rsi     # 0x26004
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x230f6(%rip), %rsi     # 0x26017
movl $0x15, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl $0x1, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x2f75
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2f7f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_allocator.cpp
// Function: test_set_allocator_cplusplus()
void
test_set_allocator_cplusplus()
{
	ft::set<int> set;
	int* p;
	unsigned int i;

	// allocate an array with space for 5 elements using set's allocator:
	p = set.get_allocator().allocate(5);

	// construct values in-place on the array:
	for (i = 0; i < 5; i++)
		set.get_allocator().construct(&p[i], i);

	std::cout << "The allocated array contains:";
	for (i = 0; i < 5; i++)
		std::cout << ' ' << p[i];
	std::cout << std::endl;

	// destroy and deallocate:
	for (i = 0; i < 5; i++)
		set.get_allocator().destroy(&p[i]);
	set.get_allocator().deallocate(p, 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movl $0x14, %edi
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl %eax, (%rbx,%rax,4)
incq %rax
cmpq $0x5, %rax
jne 0x305e
movq 0x30f5f(%rip), %rdi     # 0x33fd0
leaq 0x22ff1(%rip), %rsi     # 0x26069
movl $0x1d, %edx
callq 0x2230
xorl %r12d, %r12d
movq 0x30f44(%rip), %r14     # 0x33fd0
leaq -0x21(%rbp), %r15
movb $0x20, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movl (%rbx,%r12,4), %esi
movq %rax, %rdi
callq 0x2330
incq %r12
cmpq $0x5, %r12
jne 0x3090
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x30ef9(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
leaq -0x58(%rbp), %rdi
callq 0x35fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3106
jmp 0x3106
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35fe
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_allocator.cpp
// Function: test_set_allocator_custom_allocator()
void
test_set_allocator_custom_allocator()
{
	ft::set<int, ft::less<int>, custom_allocator<int> > set;

	set.insert(-42);
	set.insert(0);
	set.insert(42);

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x3718
leaq -0xc(%rbp), %rsi
movl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x3718
leaq -0xc(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x3718
leaq -0x40(%rbp), %rdi
callq 0x33be
leaq -0x40(%rbp), %rdi
callq 0x3656
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x3197
jmp 0x3197
jmp 0x3197
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3656
movq %rbx, %rdi
callq 0x2340