LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::Info(unsigned int&, unsigned int&, unsigned int&, unsigned int&, unsigned int&, unsigned int&, unsigned long long&, unsigned long long&)
bool CKMCFile::Info(uint32 &_kmer_length, uint32 &_mode, uint32 &_counter_size, uint32 &_lut_prefix_length, uint32 &_signature_len, uint32 &_min_count, uint64 &_max_count, uint64 &_total_kmers)
{
	if(is_opened)
	{
		_kmer_length = kmer_length;
		_mode = mode;
		_counter_size = counter_size;
		_lut_prefix_length = lut_prefix_length;
		if (kmc_version == 0x200)
			_signature_len = signature_len;
		else
			_signature_len = 0; //for kmc1 there is no signature_len
		_min_count = min_count;
		_max_count = max_count;
		_total_kmers = total_kmers;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, (%rax)
je 0x425bd1
movq -0x40(%rbp), %rax
movl 0x78(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movl 0x7c(%rax), %edx
movq -0x20(%rbp), %rcx
movl %edx, (%rcx)
movl 0x80(%rax), %edx
movq -0x28(%rbp), %rcx
movl %edx, (%rcx)
movl 0x84(%rax), %edx
movq -0x30(%rbp), %rcx
movl %edx, (%rcx)
cmpl $0x200, 0xa4(%rax)      # imm = 0x200
jne 0x425b95
movq -0x40(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
jmp 0x425b9f
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x40(%rbp), %rax
movl 0x8c(%rax), %edx
movq 0x10(%rbp), %rcx
movl %edx, (%rcx)
movq 0x90(%rax), %rdx
movq 0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x98(%rax), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x425bd5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::Info(CKMCFileInfo&)
bool CKMCFile::Info(CKMCFileInfo& info)
{
	if (is_opened)
	{
		info.kmer_length = kmer_length;
		info.mode = mode;
		info.counter_size = counter_size;
		info.lut_prefix_length = lut_prefix_length;
		if (kmc_version == 0x200)
			info.signature_len = signature_len;
		else
			info.signature_len = 0; //for kmc1 there is no signature_len
		info.min_count = min_count;
		info.max_count = max_count;
		info.total_kmers = total_kmers;
		info.both_strands = both_strands;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
je 0x425c9d
movq -0x20(%rbp), %rax
movl 0x78(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movl 0x7c(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x4(%rcx)
movl 0x80(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x8(%rcx)
movl 0x84(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0xc(%rcx)
cmpl $0x200, 0xa4(%rax)      # imm = 0x200
jne 0x425c4d
movq -0x20(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x425c58
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x8c(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x14(%rcx)
movq 0x90(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x98(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x28(%rcx)
movb 0xa0(%rax), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x425ca1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::GetCountersForRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&)
bool CKMCFile::GetCountersForRead(const std::string& read, std::vector<uint32>& counters)
{
	if (is_opened != opened_for_RA)
		return false;

	if (read.length() < kmer_length)
	{
		counters.clear();
		return false;
	}

	if (kmc_version == 0x200)
	{		
		if (both_strands)
			return GetCountersForRead_kmc2_both_strands(read, counters);
		else
			return GetCountersForRead_kmc2(read, counters);
	}
	else if (kmc_version == 0)
	{
		if (both_strands)
			return GetCountersForRead_kmc1_both_strands(read,counters);
		else
			return GetCountersForRead_kmc1(read, counters);
	}
	else
		return false; //never should be here
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, (%rax)
je 0x425cda
movb $0x0, -0x1(%rbp)
jmp 0x425d9c
movq -0x18(%rbp), %rdi
callq 0x49f200
movq -0x28(%rbp), %rcx
movl 0x78(%rcx), %ecx
cmpq %rcx, %rax
jae 0x425d01
movq -0x20(%rbp), %rdi
callq 0x4281f0
movb $0x0, -0x1(%rbp)
jmp 0x425d9c
movq -0x28(%rbp), %rax
cmpl $0x200, 0xa4(%rax)      # imm = 0x200
jne 0x425d4e
movq -0x28(%rbp), %rax
testb $0x1, 0xa0(%rax)
je 0x425d36
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x425db0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x425d9c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4265d0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x425d9c
movq -0x28(%rbp), %rax
cmpl $0x0, 0xa4(%rax)
jne 0x425d98
movq -0x28(%rbp), %rax
testb $0x1, 0xa0(%rax)
je 0x425d80
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x426c50
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x425d9c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x427330
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x425d9c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::GetCountersForRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<float, std::allocator<float>>&)
bool CKMCFile::GetCountersForRead(const std::string& read, std::vector<float>& counters)
{
	if (is_opened != opened_for_RA)
		return false;
	std::vector<uint32> uint32_v;
	if (GetCountersForRead(read, uint32_v))
	{
		counters.clear();
		counters.resize(uint32_v.size());
		if (mode == 0)
		{
			for (uint32 i = 0; i < uint32_v.size(); ++i)
				counters[i] = static_cast<float>(uint32_v[i]);
		}
		else
		{
			for (uint32 i = 0; i < uint32_v.size(); ++i)
				memcpy(&counters[i], &uint32_v[i], counter_size);
		}

		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x1, (%rax)
je 0x42786d
movb $0x0, -0x1(%rbp)
jmp 0x4279de
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x41f7d0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x425cb0
movb %al, -0x59(%rbp)
jmp 0x427890
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x42789c
jmp 0x4279ca
movq -0x20(%rbp), %rdi
callq 0x428210
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x420d40
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x428230
jmp 0x4278c4
movq -0x58(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x427949
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x420d40
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x427947
movl -0x48(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x40b8b0
movl (%rax), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x7c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x40b8d0
movss -0x7c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4278d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41f8b0
jmp 0x4279ec
jmp 0x4279bd
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x420d40
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x4279bb
movq -0x20(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x40b8d0
movq %rax, -0x90(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x40b8b0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
movq -0x58(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, %edx
callq 0x401080
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x427950
jmp 0x4279bd
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x4279d5
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41f8b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4d3c10
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::count_for_kmer_kmc1(CKmerAPI&)
uint32 CKMCFile::count_for_kmer_kmc1(CKmerAPI& kmer)
{
	//recognize a prefix:

	uint64 pattern_prefix_value = kmer.kmer_data[0];

	uint32 pattern_offset = (sizeof(pattern_prefix_value)* 8) - (lut_prefix_length * 2) - (kmer.byte_alignment * 2);

	pattern_prefix_value = pattern_prefix_value >> pattern_offset;  //complements with 0
	if (pattern_prefix_value >= prefix_file_buf_size)
		return false;
	//look into the array with data

	int64 index_start = prefix_file_buf[pattern_prefix_value];
	int64 index_stop = prefix_file_buf[pattern_prefix_value + 1] - 1;

	uint64 counter = 0;
	if (BinarySearch(index_start, index_stop, kmer, counter, pattern_offset))
		return (uint32)counter;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
movl 0x84(%rax), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x40, %eax
subq %rcx, %rax
movq -0x18(%rbp), %rcx
movzbl 0xc(%rcx), %ecx
shll %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
shrq %cl, %rax
movq -0x48(%rbp), %rcx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x38(%rcx), %rax
jb 0x427a72
movl $0x0, -0x4(%rbp)
jmp 0x427ad2
movq -0x48(%rbp), %rdi
movq 0x30(%rdi), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%rdi), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x24(%rbp), %r9d
leaq -0x40(%rbp), %r8
callq 0x424750
testb $0x1, %al
jne 0x427ac2
jmp 0x427acb
movq -0x40(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x427ad2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::count_for_kmer_kmc2(CKmerAPI&, unsigned int)
uint32 CKMCFile::count_for_kmer_kmc2(CKmerAPI& kmer, uint32 bin_start_pos)
{
	//recognize a prefix:
	uint64 pattern_prefix_value = kmer.kmer_data[0];

	uint32 pattern_offset = (sizeof(pattern_prefix_value)* 8) - (lut_prefix_length * 2) - (kmer.byte_alignment * 2);

	pattern_prefix_value = pattern_prefix_value >> pattern_offset;  //complements with 0
	if (pattern_prefix_value >= prefix_file_buf_size)
		return false;
	//look into the array with data

	int64 index_start = *(prefix_file_buf + bin_start_pos + pattern_prefix_value);
	int64 index_stop = *(prefix_file_buf + bin_start_pos + pattern_prefix_value + 1) - 1;

	uint64 counter = 0;
	if (BinarySearch(index_start, index_stop, kmer, counter, pattern_offset))
		return (uint32)counter;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
movl 0x84(%rax), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x40, %eax
subq %rcx, %rax
movq -0x18(%rbp), %rcx
movzbl 0xc(%rcx), %ecx
shll %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
shrq %cl, %rax
movq -0x50(%rbp), %rcx
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x38(%rcx), %rax
jb 0x427b55
movl $0x0, -0x4(%rbp)
jmp 0x427bc9
movq -0x50(%rbp), %rdi
movq 0x30(%rdi), %rax
movl -0x1c(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq 0x30(%rdi), %rax
movl -0x1c(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x2c(%rbp), %r9d
leaq -0x48(%rbp), %r8
callq 0x424750
testb $0x1, %al
jne 0x427bb9
jmp 0x427bc2
movq -0x48(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x427bc9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmer_api.h
// Function: CKmerAPI::get_signature(unsigned int)
uint32 get_signature(uint32 sig_len)
	 {
		 uchar symb;
		 CMmer cur_mmr(sig_len);
		 
		 for(uint32 i = 0; i < sig_len; ++i)
		 {
			 symb = get_num_symbol(i);
			 cur_mmr.insert(symb);
		 }
		 CMmer min_mmr(cur_mmr);
		 for (uint32 i = sig_len; i < kmer_length; ++i)
		 {
			 symb = get_num_symbol(i);
			 cur_mmr.insert(symb);
			 
			 if (cur_mmr < min_mmr)
				 min_mmr = cur_mmr;
		 }
		 return min_mmr.get();
	 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x4233c0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x428149
movq -0x68(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x428f10
movb %al, -0xd(%rbp)
leaq -0x30(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x428b40
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x42811a
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x68(%rbp), %rcx
movl -0x5c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x4281d5
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x428f10
movb %al, -0xd(%rbp)
leaq -0x30(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x428b40
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x428b80
testb $0x1, %al
jne 0x4281aa
jmp 0x4281c8
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x4281ca
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x42816f
leaq -0x58(%rbp), %rdi
callq 0x428b20
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmer_api.h
// Function: CKmerAPI::SHR_insert2bits(unsigned char)
inline void SHR_insert2bits(uchar val)
	{
		for (uint32 i = no_of_rows - 1; i > 0; --i)
		{
			kmer_data[i] >>= 2;
			kmer_data[i] += kmer_data[i - 1] << 62;
		}
		kmer_data[0] >>= 2;
		kmer_data[no_of_rows - 1] &= ~((1ull << ((32 - (kmer_length + byte_alignment - (no_of_rows - 1) * 32)) * 2)) - 1);//mask falling of symbol
		kmer_data[0] += ((uint64)val << 62) >> (byte_alignment * 2);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jbe 0x428547
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movl -0x10(%rbp), %edx
movq (%rcx,%rdx,8), %rsi
shrq $0x2, %rsi
movq %rsi, (%rcx,%rdx,8)
movq (%rax), %rcx
movl -0x10(%rbp), %edx
subl $0x1, %edx
movl %edx, %edx
movq (%rcx,%rdx,8), %rdx
shlq $0x3e, %rdx
movq (%rax), %rax
movl -0x10(%rbp), %ecx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4284ff
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq (%rcx), %rdx
shrq $0x2, %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %edx
movzbl 0xc(%rax), %ecx
addl %ecx, %edx
movl 0x10(%rax), %ecx
subl $0x1, %ecx
shll $0x5, %ecx
subl %ecx, %edx
movl $0x20, %ecx
subl %edx, %ecx
shll %ecx
movl %ecx, %ecx
movl $0x1, %esi
shlq %cl, %rsi
subq $0x1, %rsi
xorq $-0x1, %rsi
movq (%rax), %rcx
movl 0x10(%rax), %edx
subl $0x1, %edx
movl %edx, %edx
andq (%rcx,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
movzbl -0x9(%rbp), %ecx
movl %ecx, %edx
shlq $0x3e, %rdx
movzbl 0xc(%rax), %ecx
shll %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq (%rax), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmer_api.h
// Function: CKmerAPI::SHL_insert2bits(unsigned char)
inline void SHL_insert2bits(uchar val)
	{
		kmer_data[0] <<= 2;
		if (byte_alignment)
		{
			uint64 mask = ~(((1ull << 2 * byte_alignment) - 1) << (64 - 2 * byte_alignment));
			kmer_data[0] &= mask;
		}
		for (uint32 i = 1; i < no_of_rows; ++i)
		{
			kmer_data[i - 1] += kmer_data[i] >> 62;
			kmer_data[i] <<= 2;
		}
		kmer_data[no_of_rows - 1] += (uint64)val << (62 - (((kmer_length - 1 + byte_alignment) & 31) * 2));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rcx
movq (%rcx), %rdx
shlq $0x2, %rdx
movq %rdx, (%rcx)
cmpb $0x0, 0xc(%rax)
je 0x42862b
movq -0x28(%rbp), %rax
movzbl 0xc(%rax), %ecx
shll %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
subq $0x1, %rdx
movzbl 0xc(%rax), %esi
shll %esi
movl $0x40, %ecx
subl %esi, %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
xorq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq (%rax), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
movl $0x1, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x428680
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movl -0x1c(%rbp), %edx
movq (%rcx,%rdx,8), %rsi
shrq $0x3e, %rsi
movq (%rax), %rcx
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movl %edx, %edx
addq (%rcx,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
shlq $0x2, %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x428632
movq -0x28(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movl %ecx, %edx
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movzbl 0xc(%rax), %eax
addl %eax, %ecx
andl $0x1f, %ecx
shll %ecx
movl $0x3e, %eax
subl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
shlq %cl, %rdx
movq -0x28(%rbp), %rcx
movq (%rcx), %rax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/mmer.h
// Function: CMmer::insert(unsigned char)
inline void CMmer::insert(uchar symb)
{
	str <<= 2;
	str += symb;
	str &= mask;

	current_val = norm[str];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll $0x2, %ecx
movl %ecx, (%rax)
movzbl -0x9(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x4(%rax), %ecx
andl (%rax), %ecx
movl %ecx, (%rax)
movq 0x10(%rax), %rcx
movl (%rax), %edx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmer_api.h
// Function: CKmerAPI::get_num_symbol(unsigned int)
inline uchar get_num_symbol(unsigned int pos)
	{
		if (pos >= kmer_length)
			return 0;

		uint32 current_row = (pos + byte_alignment) / 32;
		uint32 current_pos = ((pos + byte_alignment) % 32) * 2;
		uint64 mask = 0xc000000000000000 >> current_pos;
		uint64 symbol = kmer_data[current_row] & mask;
		symbol = symbol >> (64 - current_pos - 2);
		uchar* byte_ptr = reinterpret_cast<uchar*>(&symbol);
		return *byte_ptr;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jb 0x428f31
movb $0x0, -0x1(%rbp)
jmp 0x428fa7
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl 0xc(%rax), %edx
addl %edx, %ecx
shrl $0x5, %ecx
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movzbl 0xc(%rax), %edx
addl %edx, %ecx
andl $0x1f, %ecx
shll %ecx
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movabsq $-0x4000000000000000, %rdx # imm = 0xC000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
andq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x40, %ecx
subl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb (%rax), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmer_api.h
// Function: CKmerAPI::_si::_si()
_si()
		{
			for (int i = 0; i < 256; i++)
                num_codes[i] = -1;
			num_codes['A'] = num_codes['a'] = 0;
			num_codes['C'] = num_codes['c'] = 1;
			num_codes['G'] = num_codes['g'] = 2;
			num_codes['T'] = num_codes['t'] = 3;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x42a9a2
movslq -0xc(%rbp), %rcx
leaq 0x1764f4d(%rip), %rax   # 0x1b8f8e0
movb $-0x1, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x42a97f
movb $0x0, 0x1764f98(%rip)   # 0x1b8f941
movb $0x0, 0x1764f71(%rip)   # 0x1b8f921
movb $0x1, 0x1764f8c(%rip)   # 0x1b8f943
movb $0x1, 0x1764f65(%rip)   # 0x1b8f923
movb $0x2, 0x1764f82(%rip)   # 0x1b8f947
movb $0x2, 0x1764f5b(%rip)   # 0x1b8f927
movb $0x3, 0x1764f81(%rip)   # 0x1b8f954
movb $0x3, 0x1764f5a(%rip)   # 0x1b8f934
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/stats_ml/stats.cpp
// Function: spearman_correlation_coefficient(std::vector<float, std::allocator<float>>, std::vector<float, std::allocator<float>>)
float spearman_correlation_coefficient(std::vector<float> group1, std::vector<float> group2)
{
	std::vector<float> ranked_data1, ranked_data2;
	float d2 = 0;
	uint32_t n = group1.size();

	getrank(group1, ranked_data1);
	getrank(group2, ranked_data2);

	for (uint32_t i = 0; i < n; i++) d2 += (group1[i] - group2[i]) * (group1[i] - group2[i]);

	return 1.0 - 6.0 * d2 / n / (n * n - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40be60
leaq -0x40(%rbp), %rdi
callq 0x40be60
movq -0x98(%rbp), %rdi
movl $0x0, -0x44(%rbp)
callq 0x40fbc0
movq -0x98(%rbp), %rsi
movl %eax, -0x48(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x410770
jmp 0x42b21b
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x42a9e0
jmp 0x42b22a
leaq -0x60(%rbp), %rdi
callq 0x40c2b0
movq -0xa0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x410770
jmp 0x42b248
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42a9e0
jmp 0x42b25a
leaq -0x88(%rbp), %rdi
callq 0x40c2b0
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
cmpl -0x48(%rbp), %eax
jae 0x42b37a
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %eax
movl %eax, %esi
callq 0x40b8d0
movq -0xa0(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0xac(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, %esi
callq 0x40b8d0
movss -0xac(%rbp), %xmm0
movq -0x98(%rbp), %rdi
subss (%rax), %xmm0
movss %xmm0, -0xa4(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, %esi
callq 0x40b8d0
movq -0xa0(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0xa8(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, %esi
callq 0x40b8d0
movss -0xa8(%rbp), %xmm2
movss -0xa4(%rbp), %xmm0
subss (%rax), %xmm2
movss -0x44(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x42b270
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x42b3e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x40c2b0
jmp 0x42b3e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x40c2b0
jmp 0x42b3e8
movss -0x44(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x18bb95(%rip), %xmm0   # 0x5b6f20
mulsd %xmm0, %xmm1
movl -0x48(%rbp), %eax
movl %eax, %ecx
movl %ecx, %eax
cvtsi2sd %rcx, %xmm0
divsd %xmm0, %xmm1
imull %eax, %eax
decl %eax
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
movsd 0x18bb63(%rip), %xmm0   # 0x5b6f18
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x40c2b0
leaq -0x28(%rbp), %rdi
callq 0x40c2b0
movss -0xb0(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x40c2b0
leaq -0x28(%rbp), %rdi
callq 0x40c2b0
movq -0x68(%rbp), %rdi
callq 0x4d3c10
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/stats_ml/logistic_classifier.cpp
// Function: Logistic::Lw(Logistic_Param)
double Logistic::Lw(Logistic_Param p) {
	double l = 0.0L;
	for (uint32_t i = 0; i < dataSet.size(); i++) {
		double inner = innerWX(p, dataSet[i]);
		l += (dataSet[i].cls * inner - (log10(1 + exp(inner))));
	}
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x40(%rbp)
callq 0x418b60
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x42d062
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x416570
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rax, %rdx
callq 0x42d3c0
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x416570
cvtsi2sdl 0x18(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x4ce6c0
movaps %xmm0, %xmm1
movsd 0x189f03(%rip), %xmm0   # 0x5b6f18
addsd %xmm1, %xmm0
callq 0x4ce590
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x42cf9b
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/stats_ml/logistic_classifier.cpp
// Function: Logistic::gradient(double)
void Logistic::gradient(double lam) {
	for (uint32_t i = 0; i < param.w.size(); i++) {
		double tmp = 0.0L;
		for (uint32_t j = 0; j < dataSet.size(); j++) {
			tmp += (dataSet[j].cls - logiFun(param, dataSet[j])) * dataSet[j].features[i] * lam;
		}
		param.w[i] += (tmp);
	}
	double tmp = 0.0L;
	for (uint32_t j = 0; j < dataSet.size(); j++) {
		tmp += (dataSet[j].cls - logiFun(param, dataSet[j])) * lam;
	}
	param.d += tmp;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x48(%rbp)
addq $0x18, %rdi
callq 0x42d890
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x42d1c0
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x50(%rbp)
callq 0x418b60
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x42d189
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x416570
movq -0x40(%rbp), %rdi
cvtsi2sdl 0x18(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x416570
movq -0x68(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rax, %rdx
callq 0x42d350
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x416570
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x40b8d0
movsd -0x58(%rbp), %xmm0
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movsd -0x10(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x42d0c6
movq -0x40(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x42d8d0
movsd -0x70(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42d093
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
movq %rax, -0x78(%rbp)
callq 0x418b60
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x42d263
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x416570
movq -0x40(%rbp), %rdi
cvtsi2sdl 0x18(%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x88(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x416570
movq -0x40(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0x42d350
movaps %xmm0, %xmm1
movsd -0x80(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd -0x10(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x42d1cf
movq -0x40(%rbp), %rax
movsd -0x30(%rbp), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x90, %rsp
popq %rbp
retq
nop
// File: ChnMasterOG[P]KmerGO2/stats_ml/logistic_classifier.cpp
// Function: Logistic::samewb(Logistic_Param const&, Logistic_Param const&, double)
bool Logistic::samewb(const Logistic_Param& tparam, const Logistic_Param& param, double delta) {
	for (uint32_t i = 0; i < tparam.w.size(); i++) {
		if (fabs(tparam.w[i] - param.w[i]) > delta) {
			return false;
		}
	}
	if (fabs(tparam.d - param.d) > delta) {
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42d890
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x42d30f
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x42d8b0
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x42d8b0
movsd -0x40(%rbp), %xmm0
subsd (%rax), %xmm0
movaps 0x189c4f(%rip), %xmm1   # 0x5b6f40
pand %xmm1, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x42d302
movb $0x0, -0x1(%rbp)
jmp 0x42d33d
jmp 0x42d304
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x42d2a0
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
subsd 0x18(%rax), %xmm0
movaps 0x189c18(%rip), %xmm1   # 0x5b6f40
pand %xmm1, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x42d339
movb $0x0, -0x1(%rbp)
jmp 0x42d33d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/stats_ml/logistic_classifier.cpp
// Function: Logistic::innerWX(Logistic_Param const&, Logistic_Data const&)
double Logistic::innerWX(const Logistic_Param& p, const Logistic_Data& data) {
	if (p.w.size() != data.features.size()) {
		exit(0);
	}
	double innerP = 0.0L;
	for (uint32_t i = 0; i < p.w.size(); i++) {
		innerP += (p.w[i] * data.features[i]);
	}
	innerP += p.d;
	return innerP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42d890
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40fbc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x42d3fd
xorl %edi, %edi
callq 0x4ef4f0
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42d890
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x42d477
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x42d8b0
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x42d8f0
movsd -0x40(%rbp), %xmm0
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x42d40c
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/stats_ml/logistic_classifier.cpp
// Function: Logistic::predictClass(std::vector<Logistic_Data, std::allocator<Logistic_Data>>&)
void Logistic::predictClass(std::vector<Logistic_Data>& testDataSet) {
	for (uint32_t i = 0; i < testDataSet.size(); i++) {
		double py1 = 0.0L;
		double py0 = 0.0L;
		double inner = innerWX(param, testDataSet[i]);
		py1 = exp(inner) / (1 + exp(inner));
		py0 = 1 - py1;
		if (py1 >= py0) testDataSet[i].cls = 1;	// class 1
		else testDataSet[i].cls = 0;	// class 0
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x418b60
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x42d5ae
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x416570
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x42d3c0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x4ce6c0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x4ce6c0
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
movsd 0x1899d1(%rip), %xmm1   # 0x5b6f18
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x1899bc(%rip), %xmm0   # 0x5b6f18
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0x42d589
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x416570
movl $0x1, 0x18(%rax)
jmp 0x42d59e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x416570
movl $0x0, 0x18(%rax)
jmp 0x42d5a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42d4bf
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: williewillus[P]panda_scratchpad/src/communication/ClientSocket.cpp
// Function: communication::ClientSocket::Init()
int ClientSocket::Init() {
    	struct sockaddr_in server_addr; 

	// Communicate over TCP, IPv4
	if (( sockfd = socket( AF_INET, SOCK_STREAM, 0 )) < 0) 
    	{	 
        	cout << "Socket creation error" << endl; 
        	return -1; 
    	} 
   
    	memset(&server_addr, '0', sizeof(server_addr)); 
   	server_addr.sin_family = AF_INET; 
    	server_addr.sin_port = htons(sockport); 

    	// Convert IPv4 addresses from string to address struct in af family 
    	if ( inet_pton( AF_INET, sockaddr.c_str(), &server_addr.sin_addr ) <=0 )  
    	{ 
        	cout << "Invalid address" << endl; 
        	return -1; 
    	} 

	// Now that we've populated address and port, let's connect to the Qemu
	// socket listening on port *sockport*
	// TODO (jaya) : This is a blocking connect operation. The current timeout is too large
	// Need to use select() in non-blocking mode to reduce the timeout.
    	if ( connect(sockfd, (struct sockaddr*) &server_addr, sizeof(server_addr) ) < 0 ) 
    	{ 
        	cout << "Connection Failed" << endl;; 
        	return -1; 
    	} 
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6120
movq -0x28(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0xaece
movq 0x2a119(%rip), %rdi     # 0x34fc0
leaq 0x196a2(%rip), %rsi     # 0x24550
callq 0x6520
movq %rax, %rdi
movq 0x2a0db(%rip), %rsi     # 0x34f98
callq 0x6580
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaf97
leaq -0x20(%rbp), %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x6310
movq -0x28(%rbp), %rax
movw $0x2, -0x20(%rbp)
movl 0x28(%rax), %eax
movzwl %ax, %edi
callq 0x6090
movq -0x28(%rbp), %rdi
movw %ax, -0x1e(%rbp)
addq $0x8, %rdi
callq 0x6220
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x6930
cmpl $0x0, %eax
jg 0xaf4c
movq 0x2a098(%rip), %rdi     # 0x34fc0
leaq 0x19637(%rip), %rsi     # 0x24566
callq 0x6520
movq %rax, %rdi
movq 0x2a05a(%rip), %rsi     # 0x34f98
callq 0x6580
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaf97
movq -0x28(%rbp), %rax
movl (%rax), %edi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x6460
cmpl $0x0, %eax
jge 0xaf90
movq 0x2a054(%rip), %rdi     # 0x34fc0
leaq 0x19603(%rip), %rsi     # 0x24576
callq 0x6520
movq %rax, %rdi
movq 0x2a016(%rip), %rsi     # 0x34f98
callq 0x6580
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaf97
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: williewillus[P]panda_scratchpad/src/communication/ClientSocket.cpp
// Function: communication::ClientSocket::BuildLoadPluginMsg(communication::SockMessage&, communication::Plugins, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ClientSocket::BuildLoadPluginMsg(SockMessage& msg, Plugins plugin_name, string start, string end ) {
	msg.q_cmd = cLoadPlugin;
	msg.need_response = false;
	msg.q_cmd_options->plugin_name =plugin_name;
	msg.q_cmd_options->start = start;
	msg.q_cmd_options->end = end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x4(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xb640
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xb640
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x6060
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xb640
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
callq 0x6060
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/communication/ClientSocket.cpp
// Function: communication::ClientSocket::ReceiveReply(communication::SockMessage&)
SockError ClientSocket::ReceiveReply(SockMessage& msg) {
	SockError err = eNone;
	int valread;
	char buffer[BUFLEN];
	int bytes_read = 0;
	while(1) {
		valread = recv( sockfd, buffer, BUFLEN, 0);
    		if (valread <= 0){
			err = eOther;
			return err;
		}
		bytes_read += valread;
		string compare(buffer);
		//cout  << "Reply : " << buffer << " Bytes read = " << compare.find("cmEOF") << endl;
		string::size_type n = compare.find("cmEOF");
		if (n != string::npos){
			break;
		}
	}
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1080, %rsp           # imm = 0x1080
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1078(%rbp)
movl $0x3, -0x1c(%rbp)
movl $0x0, -0x1024(%rbp)
movq -0x1078(%rbp), %rax
movl (%rax), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %ecx, %ecx
callq 0x61a0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jg 0xb556
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb625
movl -0x20(%rbp), %ecx
movl -0x1024(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1024(%rbp)
leaq -0x1049(%rbp), %rdi
movq %rdi, -0x1080(%rbp)
callq 0x68b0
movq -0x1080(%rbp), %rdx
leaq -0x1048(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x6670
jmp 0xb596
leaq -0x1049(%rbp), %rdi
callq 0x6590
leaq -0x1048(%rbp), %rdi
leaq 0x19076(%rip), %rsi     # 0x24626
xorl %eax, %eax
movl %eax, %edx
callq 0x69a0
movq %rax, -0x1068(%rbp)
cmpq $-0x1, -0x1068(%rbp)
je 0xb5f6
movl $0x3, -0x106c(%rbp)
jmp 0xb600
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1058(%rbp)
movl %eax, -0x105c(%rbp)
leaq -0x1049(%rbp), %rdi
callq 0x6590
jmp 0xb631
movl $0x0, -0x106c(%rbp)
leaq -0x1048(%rbp), %rdi
callq 0x69d8
movl -0x106c(%rbp), %eax
testl %eax, %eax
je 0xb61a
jmp 0xb618
jmp 0xb61f
jmp 0xb51f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1080, %rsp           # imm = 0x1080
popq %rbp
retq
movq -0x1058(%rbp), %rdi
callq 0x68a0
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/tests/BaseTestCase.cpp
// Function: tests::BaseTestCase::Run(int, int)
int BaseTestCase::Run(const int change_fd, const int checkpoint) {
  DefaultFsFns default_fns;
  RecordCmFsOps cm(&default_fns);
  PassthroughCmFsOps pcm(&default_fns);
  if (checkpoint == 0) {
    cm_ = &cm;
  } else {
    cm_ = &pcm;
  }

  int res_1 = run(checkpoint);
  if (res_1 < 0) {
    return res_1;
  }

  if (checkpoint == 0) {
    int res_2 = cm.Serialize(change_fd);
    if (res_2 < 0) {
      return res_2;
    }
  }
  return res_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xbc40
movq -0xf0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0xfbf0
jmp 0xbab5
leaq -0xd8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12190
jmp 0xbac7
cmpl $0x0, -0x18(%rbp)
jne 0xbb0f
movq -0xf8(%rbp), %rax
leaq -0xb8(%rbp), %rcx
movq %rcx, 0x30(%rax)
jmp 0xbb21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0xbc1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0xbc12
movq -0xf8(%rbp), %rax
leaq -0xd8(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0xf8(%rbp), %rdi
movl -0x18(%rbp), %esi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movl %eax, -0xfc(%rbp)
jmp 0xbb3c
movl -0xfc(%rbp), %eax
movl %eax, -0xdc(%rbp)
cmpl $0x0, -0xdc(%rbp)
jge 0xbb89
movl -0xdc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xe0(%rbp)
jmp 0xbbe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xbc80
jmp 0xbc12
cmpl $0x0, -0x18(%rbp)
jne 0xbbd2
movl -0x14(%rbp), %esi
leaq -0xb8(%rbp), %rdi
callq 0x12010
movl %eax, -0x100(%rbp)
jmp 0xbba6
movl -0x100(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x0, -0xe4(%rbp)
jge 0xbbd0
movl -0xe4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xe0(%rbp)
jmp 0xbbe5
jmp 0xbbd2
movl -0xdc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xbc80
leaq -0xb8(%rbp), %rdi
callq 0xbca0
leaq -0x20(%rbp), %rdi
callq 0xbd00
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0xb8(%rbp), %rdi
callq 0xbca0
leaq -0x20(%rbp), %rdi
callq 0xbd00
movq -0xc0(%rbp), %rdi
callq 0x68a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/results/DataTestResult.cpp
// Function: tests::DataTestResult::PrintErrors(std::ostream&) const
ostream& DataTestResult::PrintErrors(ostream& os) const {
  unsigned int noted_errors = error_summary_;
  unsigned int shift = 0;
  while (noted_errors != 0) {
    if (noted_errors & 1) {
      os << (DataTestResult::ErrorType) (1 << shift);
    }
    ++shift;
    noted_errors >>= 1;
  }

  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xce68
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xce55
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl $0x1, %esi
shll %cl, %esi
callq 0xce80
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
jmp 0xce31
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/results/DataTestResult.cpp
// Function: tests::operator<<(std::ostream&, tests::DataTestResult::ErrorType)
ostream& operator<<(ostream& os, DataTestResult::ErrorType err) {
  switch (err) {
    case DataTestResult::kClean:
      break;
    case DataTestResult::kOldFilePersisted:
      os << "old_file_persisted";
      break;
    case DataTestResult::kFileMissing:
      os << "file_missing";
      break;
    case DataTestResult::kFileDataCorrupted:
      os << "file_data_corrupted";
      break;
    case DataTestResult::kFileMetadataCorrupted:
      os << "file_metadata_corrupted";
      break;
    case DataTestResult::kIncorrectBlockCount:
      os << "incorrect_block_count";
      break;      
    case DataTestResult::kOther:
      os << "other_error";
      break;
    case DataTestResult::kAutoCheckFailed:
      os << "auto_check_test_failed";
      break;
    default:
      os.setstate(std::ios_base::failbit);
  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x40, %rax
ja 0xcf3a
movq -0x18(%rbp), %rax
leaq 0x17879(%rip), %rcx     # 0x24724
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xcf4f
movq -0x8(%rbp), %rdi
leaq 0x17964(%rip), %rsi     # 0x24828
callq 0x6520
jmp 0xcf4f
movq -0x8(%rbp), %rdi
leaq 0x17962(%rip), %rsi     # 0x2483b
callq 0x6520
jmp 0xcf4f
movq -0x8(%rbp), %rdi
leaq 0x1795d(%rip), %rsi     # 0x24848
callq 0x6520
jmp 0xcf4f
movq -0x8(%rbp), %rdi
leaq 0x1795f(%rip), %rsi     # 0x2485c
callq 0x6520
jmp 0xcf4f
movq -0x8(%rbp), %rdi
leaq 0x17965(%rip), %rsi     # 0x24874
callq 0x6520
jmp 0xcf4f
movq -0x8(%rbp), %rdi
leaq 0x17969(%rip), %rsi     # 0x2488a
callq 0x6520
jmp 0xcf4f
movq -0x8(%rbp), %rdi
leaq 0x17963(%rip), %rsi     # 0x24896
callq 0x6520
jmp 0xcf4f
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x6380
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/results/FileSystemTestResult.cpp
// Function: FileSystemTestResult::PrintErrors(std::ostream&) const
void FileSystemTestResult::PrintErrors(ostream& os) const {
  if (error_summary_ == 0) {
    os << FileSystemTestResult::kCheckNotRun;
    return;
  }

  unsigned int noted_errors = error_summary_;
  unsigned int shift = 0;
  while (noted_errors != 0) {
    if (noted_errors & 1) {
      os << (FileSystemTestResult::ErrorType) (1 << shift) << " ";
    }
    ++shift;
    noted_errors >>= 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0xd02b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xd090
jmp 0xd082
movq -0x20(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xd082
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd06f
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl $0x1, %esi
shll %cl, %esi
callq 0xd090
movq %rax, %rdi
leaq 0x187ed(%rip), %rsi     # 0x25857
callq 0x6520
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
jmp 0xd03c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)