LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ChnMasterOG[P]KmerGO2/kmergo/kmer_union.cpp
// Function: distribute_kmer_uniformly(unsigned char, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void distribute_kmer_uniformly(uint8_t step, uint32_t num, std::string& out_kmer)
{
	if (step == 4) return;
	if (num % 4 == 0) out_kmer = "A" + out_kmer;
	else if (num % 4 == 1) out_kmer = "C" + out_kmer;
	else if (num % 4 == 2) out_kmer = "G" + out_kmer;
	else out_kmer = "T" + out_kmer;
	distribute_kmer_uniformly(step + 1, num / 4, out_kmer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x4, %eax
jne 0x40a4f6
jmp 0x40a5ee
movl -0x8(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x40a530
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x1c197d(%rip), %rsi    # 0x5cbe8d
callq 0x40bd30
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x49f020
leaq -0x30(%rbp), %rdi
callq 0x49efd0
jmp 0x40a5d5
movl -0x8(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x40a567
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq 0x1c19a4(%rip), %rsi    # 0x5cbeee
callq 0x40bd30
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x49f020
leaq -0x50(%rbp), %rdi
callq 0x49efd0
jmp 0x40a5d3
movl -0x8(%rbp), %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x40a59e
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rdi
leaq 0x1bffc9(%rip), %rsi    # 0x5ca54a
callq 0x40bd30
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x49f020
leaq -0x70(%rbp), %rdi
callq 0x49efd0
jmp 0x40a5d1
movq -0x10(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq 0x1c18e5(%rip), %rsi    # 0x5cbe95
callq 0x40bd30
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x49f020
leaq -0x90(%rbp), %rdi
callq 0x49efd0
jmp 0x40a5d3
jmp 0x40a5d5
movzbl -0x1(%rbp), %eax
addl $0x1, %eax
movl -0x8(%rbp), %esi
shrl $0x2, %esi
movq -0x10(%rbp), %rdx
movzbl %al, %edi
callq 0x40a4d0
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/kmer_union.cpp
// Function: show_Progress(unsigned long long)
static void show_Progress(uint64 allkmernumber)
{
	printf("STEP k-mer union start!\n");
	while (progress < allkmernumber && union_err_number == 0)
	{
		printf("\rTotal: %.2f%%  ", (double)progress * 100 / allkmernumber);
	}
	if (union_err_number == 0)
	{
		printf("\rTotal: 100.00%%\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1aafe5(%rip), %rdi    # 0x5b6388
movb $0x0, %al
callq 0x4faca0
movq 0x22f2cf(%rip), %rcx    # 0x63a680
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x9(%rbp)
jae 0x40b3cd
movw 0x22f2b7(%rip), %ax     # 0x63a67a
cwtl
cmpl $0x0, %eax
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x40b3d6
jmp 0x40b43b
movq 0x22f2a2(%rip), %xmm0   # 0x63a680
movaps 0x1aae8b(%rip), %xmm3   # 0x5b6270
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x1aae8f(%rip), %xmm2   # 0x5b6280
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x1aae50(%rip), %xmm1   # 0x5b6258
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
leaq 0x1aaf72(%rip), %rdi    # 0x5b63a1
movb $0x1, %al
callq 0x4faca0
jmp 0x40b3aa
movw 0x22f238(%rip), %ax     # 0x63a67a
cwtl
cmpl $0x0, %eax
jne 0x40b456
leaq 0x1aaf63(%rip), %rdi    # 0x5b63b2
movb $0x0, %al
callq 0x4faca0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/../kmc_api/kmer_api.h
// Function: CKmerAPI::CKmerAPI(unsigned int)
inline CKmerAPI(uint32 length = 0)
	{
		if(length)
		{
			if(length % 4)
				byte_alignment = 4 - (length % 4);	
			else
				byte_alignment = 0;

			no_of_rows = (((length + byte_alignment) % 32) ? (length + byte_alignment) / 32 + 1 : (length + byte_alignment) / 32); 
			//no_of_rows = (int)ceil((double)(length + byte_alignment) / 32);
			kmer_data = new uint64[no_of_rows];

			memset(kmer_data, 0, sizeof(*kmer_data) * no_of_rows);
		}
		else
		{
			kmer_data = NULL;
			no_of_rows = 0;
			byte_alignment = 0;
		}
		kmer_length = length;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x40b617
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x40b582
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
andl $0x3, %edx
movl $0x4, %ecx
subl %edx, %ecx
movb %cl, 0xc(%rax)
jmp 0x40b58a
movq -0x18(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movzbl 0xc(%rcx), %ecx
addl %ecx, %eax
andl $0x1f, %eax
cmpl $0x0, %eax
je 0x40b5b7
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movzbl 0xc(%rcx), %ecx
addl %ecx, %eax
shrl $0x5, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40b5ca
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movzbl 0xc(%rcx), %ecx
addl %ecx, %eax
shrl $0x5, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x42fb90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movl 0x10(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x401090
jmp 0x40b62d
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0x10(%rax)
movb $0x0, 0xc(%rax)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/../kmc_api/kmer_api.h
// Function: CKmerAPI::from_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool from_string(const std::string& kmer_string)
	{					
		for (uint32 ii = 0; ii < kmer_string.size(); ++ii)
		{
			if (num_codes[(uchar)kmer_string[ii]] == -1)
				return false;
		}
		return from_string_impl(kmer_string.begin(), static_cast<uint32>(kmer_string.length()));		
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x49f1f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x40b6b1
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x49f500
movzbl (%rax), %eax
movl %eax, %ecx
movq $0x1b8f8e0, %rax        # imm = 0x1B8F8E0
movsbl (%rax,%rcx), %eax
cmpl $-0x1, %eax
jne 0x40b6a4
movb $0x0, -0x1(%rbp)
jmp 0x40b6db
jmp 0x40b6a6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40b65f
movq -0x18(%rbp), %rdi
callq 0x49f110
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x49f200
movq -0x30(%rbp), %rdi
movl %eax, %edx
movq -0x28(%rbp), %rsi
callq 0x40c370
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/../kmc_api/kmer_api.h
// Function: CKmerAPI::operator<(CKmerAPI const&) const
inline bool operator<(const CKmerAPI &kmer) const
	{
			//if(kmer.kmer_length != kmer_length)
			//	return false;		

			//modified by KmerGO
			if(kmer.kmer_length != kmer_length)
				return kmer.kmer_length > kmer_length;

			for(uint32 i = 0; i < no_of_rows; i++)
				if(kmer.kmer_data[i] > kmer_data[i])
					return true;
				else
					if(kmer.kmer_data[i] < kmer_data[i])
						return false;
				
			return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
je 0x40b728
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x40b796
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x40b792
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
jbe 0x40b75f
movb $0x1, -0x1(%rbp)
jmp 0x40b796
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
jae 0x40b783
movb $0x0, -0x1(%rbp)
jmp 0x40b796
jmp 0x40b785
jmp 0x40b787
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40b72f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/../kmc_api/kmer_api.h
// Function: CKmerAPI::operator=(CKmerAPI const&)
inline CKmerAPI& operator=(const CKmerAPI &kmer)
	{
		if(kmer.kmer_length != kmer_length)		
		{
			if(kmer_length && kmer_data)
				delete [] kmer_data;
		
			kmer_length = kmer.kmer_length;
			byte_alignment = kmer.byte_alignment;
			no_of_rows = kmer.no_of_rows;
		
			kmer_data = new uint64[no_of_rows];
		}

		for(uint32 i = 0; i < no_of_rows; i++)
			kmer_data[i] = kmer.kmer_data[i];

		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
je 0x40b868
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x40b818
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x40b818
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x40b816
movq -0x28(%rbp), %rdi
callq 0x42eca0
jmp 0x40b818
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movb 0xc(%rcx), %cl
movb %cl, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x42fb90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x40b8a2
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x40b86f
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/../kmc_api/kmer_api.h
// Function: CKmerAPI::operator==(CKmerAPI const&) const
inline bool operator==(const CKmerAPI &kmer) const
	{
			if(kmer.kmer_length != kmer_length)
				return false;

			for(uint32 i = 0; i < no_of_rows; i++)
				if(kmer.kmer_data[i] != kmer_data[i])
					return false;

			return true;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
je 0x40b916
movb $0x0, -0x1(%rbp)
jmp 0x40b95e
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x40b95a
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
je 0x40b94d
movb $0x0, -0x1(%rbp)
jmp 0x40b95e
jmp 0x40b94f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40b91d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ChnMasterOG[P]KmerGO2/kmergo/kmer_filtering.cpp
// Function: show_Progress(unsigned long long)
static void show_Progress(uint64 allfilesize)
{
	printf("STEP k-mer filtering start!\n");
	while (progress < allfilesize)
	{
		printf("\rTotal: %.2f%%  ", (double)progress * 100 / allfilesize);
	}
	printf("\rTotal: 100.00%%\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1a051b(%rip), %rdi    # 0x5b652e
movb $0x0, %al
callq 0x4faca0
movq 0x224697(%rip), %rax    # 0x63a6b8
cmpq -0x8(%rbp), %rax
jae 0x416089
movq 0x224689(%rip), %xmm0   # 0x63a6b8
movaps 0x1a023a(%rip), %xmm3   # 0x5b6270
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x1a023e(%rip), %xmm2   # 0x5b6280
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x1a01ff(%rip), %xmm1   # 0x5b6258
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
leaq 0x1a0321(%rip), %rdi    # 0x5b63a1
movb $0x1, %al
callq 0x4faca0
jmp 0x41601a
leaq 0x1a0322(%rip), %rdi    # 0x5b63b2
movb $0x0, %al
callq 0x4faca0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/kmer_losertree.cpp
// Function: KmerLoserTree::KmerLoserTree(unsigned int, unsigned int)
KmerLoserTree::KmerLoserTree(uint32 c, uint32 k)
{
	capacity = c;
	CKmerAPI kmer_obj(k);
	for (uint32 i = 0; i < c; i++)
	{
		kmer_list.push_back(kmer_obj);
		counter_list.push_back(0);
	}
	kmer_list.push_back(kmer_obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x41f7d0
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x58(%rbp)
callq 0x41f7f0
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x50(%rbp)
callq 0x41f7d0
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x40b540
jmp 0x41f4e0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x41f54e
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x41f810
jmp 0x41f502
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movl $0x0, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x41f880
jmp 0x41f51c
jmp 0x41f51e
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x41f4e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x41f570
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40bcf0
jmp 0x41f570
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x41f810
jmp 0x41f561
leaq -0x28(%rbp), %rdi
callq 0x40bcf0
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x41f8b0
movq -0x58(%rbp), %rdi
callq 0x41f910
movq -0x48(%rbp), %rdi
callq 0x41f8b0
movq -0x30(%rbp), %rdi
callq 0x4d3c10
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/kmer_losertree.cpp
// Function: KmerLoserTree::adjust(unsigned int)
void KmerLoserTree::adjust(uint32 s)
{
	int t = (s + capacity) / 2;		//get the father node of s
	while (t > 0) {					//compare with the parent node until the root node of the loser tree
		if (!kmer_list[s].operator<(kmer_list[ls[t]]) && !kmer_list[s].operator==(kmer_list[ls[t]]))
		{
			swap(&s, &ls[t]);		//swap s and ls[t]
		}
		t /= 2;
	}
	ls[0] = s;						//the last winner is in ls[0]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl 0x18(%rcx), %eax
shrl %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x41f702
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x40b7a0
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x40b8b0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x40b7a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x40b6f0
testb $0x1, %al
jne 0x41f6ef
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x40b7a0
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x40b8b0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x40b7a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x40b8f0
testb $0x1, %al
jne 0x41f6ef
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x40b8b0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq -0xc(%rbp), %rsi
callq 0x41f5e0
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
jmp 0x41f632
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x40b8b0
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: ChnMasterOG[P]KmerGO2/kmergo/../kmc_api/kmer_api.h
// Function: CKmerAPI::CKmerAPI(CKmerAPI const&)
inline CKmerAPI(const CKmerAPI &kmer)
	{
		kmer_length = kmer.kmer_length;
		byte_alignment = kmer.byte_alignment;
		no_of_rows = kmer.no_of_rows;
		
		kmer_data = new uint64[no_of_rows];
			
		for(uint32 i = 0; i < no_of_rows; i++)
			kmer_data[i] = kmer.kmer_data[i];

	}

// 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)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movb 0xc(%rcx), %cl
movb %cl, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x42fb90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x4202ce
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42029b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ChnMasterOG[P]KmerGO2/kmergo/KmerGO.cpp
// Function: help_or_version(int, char**)
bool help_or_version(int argc, char** argv)
{
	const std::string version = "--version";
	const std::string help = "--help";
	for (int i = 1; i < argc; ++i)
	{
		if (argv[i] == version || argv[i] == help)
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x42ffd0
movq -0x80(%rbp), %rdx
leaq 0x1955c2(%rip), %rsi    # 0x5b67ec
leaq -0x30(%rbp), %rdi
callq 0x406db0
jmp 0x421235
leaq -0x31(%rbp), %rdi
callq 0x42fff0
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x42ffd0
movq -0x88(%rbp), %rdx
leaq 0x19559a(%rip), %rsi    # 0x5b67f6
leaq -0x68(%rbp), %rdi
callq 0x406db0
jmp 0x421267
leaq -0x69(%rbp), %rdi
callq 0x42fff0
movl $0x1, -0x70(%rbp)
movl -0x70(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x421337
movq -0x10(%rbp), %rax
movslq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4231d0
movb %al, -0x89(%rbp)
jmp 0x4212a0
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x4212d5
jmp 0x4212ac
movq -0x10(%rbp), %rax
movslq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4231d0
movb %al, -0x8a(%rbp)
jmp 0x4212c9
movb -0x8a(%rbp), %al
testb $0x1, %al
jne 0x4212d5
jmp 0x421327
movb $0x1, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
jmp 0x421342
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x42fff0
jmp 0x42136b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x42fff0
jmp 0x421362
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x49efd0
jmp 0x421362
jmp 0x421329
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x421277
movb $0x0, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x49efd0
leaq -0x30(%rbp), %rdi
callq 0x49efd0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x49efd0
movq -0x40(%rbp), %rdi
callq 0x4d3c10
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/KmerGO.cpp
// Function: print_info()
void print_info(void)
{
	std::cout << "KmerGO ver. " << KMERGO_VER << " (" << KMERGO_DATE << ")\n"
		<< "\nUsage:\nKmerGO <tool> [options]\n"
		<< "Tool:\n"
		<< "one of kmc3, union, filtering, cap3 or all\n"
		<< "Options:\n"
		<< "-i <string>: input files path (required)\n"
		<< "-o <string>: output files path (required)\n"
		<< "-t <string>: a csv file path of trait information (required when tool is filtering or all)\n"
		<< "-e <string>: temp files path (required when tool is kmc3 or all, default: ./)\n"
		<< "-m <int>: mode, 0-categorical, 1-continuous (default: 0)\n"
		<< "-k <int>: k-mer length (k from 14 to 256, default: 40)\n"
		<< "-ci <int>: minimal k-mer occurring times (default: 2)\n"
		<< "-cs <int>: maximal k-mer occurring times (default: 65535)\n"
		<< "-n <int>: number of processes (n from 1 to 256, default: 24)\n"
		<< "-assl <float>: when mode = 0, logical features ASS value (default: 0.8)\n"
		<< "-p <float>: numeric(mode=0) or logical(mode=1) features rank sum test p threshold value (default: 0.01)\n"
		<< "-assn <float>: when mode = 0, numeric features logistic regression ASS value (default: 0.8)\n"
		<< "-corr <float>: when mode = 1, numeric features coefficient of association threshold value (default: 0.8)\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x1b90900, %rdi        # imm = 0x1B90900
leaq 0x19546b(%rip), %rsi    # 0x5b67fd
callq 0x498c00
movq %rax, %rdi
leaq 0x195469(%rip), %rsi    # 0x5b680a
callq 0x498c00
movq %rax, %rdi
leaq 0x1996f9(%rip), %rsi    # 0x5baaa9
callq 0x498c00
movq %rax, %rdi
leaq 0x195451(%rip), %rsi    # 0x5b6810
callq 0x498c00
movq %rax, %rdi
leaq 0x1955a8(%rip), %rsi    # 0x5b6976
callq 0x498c00
movq %rax, %rdi
leaq 0x19543e(%rip), %rsi    # 0x5b681b
callq 0x498c00
movq %rax, %rdi
leaq 0x195450(%rip), %rsi    # 0x5b683c
callq 0x498c00
movq %rax, %rdi
leaq 0x195448(%rip), %rsi    # 0x5b6843
callq 0x498c00
movq %rax, %rdi
leaq 0x195465(%rip), %rsi    # 0x5b686f
callq 0x498c00
movq %rax, %rdi
leaq 0x195460(%rip), %rsi    # 0x5b6879
callq 0x498c00
movq %rax, %rdi
leaq 0x19547b(%rip), %rsi    # 0x5b68a3
callq 0x498c00
movq %rax, %rdi
leaq 0x195497(%rip), %rsi    # 0x5b68ce
callq 0x498c00
movq %rax, %rdi
leaq 0x1954e4(%rip), %rsi    # 0x5b692a
callq 0x498c00
movq %rax, %rdi
leaq 0x195524(%rip), %rsi    # 0x5b6979
callq 0x498c00
movq %rax, %rdi
leaq 0x19554f(%rip), %rsi    # 0x5b69b3
callq 0x498c00
movq %rax, %rdi
leaq 0x195578(%rip), %rsi    # 0x5b69eb
callq 0x498c00
movq %rax, %rdi
leaq 0x1955a0(%rip), %rsi    # 0x5b6a22
callq 0x498c00
movq %rax, %rdi
leaq 0x1955cc(%rip), %rsi    # 0x5b6a5d
callq 0x498c00
movq %rax, %rdi
leaq 0x1955fb(%rip), %rsi    # 0x5b6a9b
callq 0x498c00
movq %rax, %rdi
leaq 0x195635(%rip), %rsi    # 0x5b6ae4
callq 0x498c00
movq %rax, %rdi
leaq 0x19568f(%rip), %rsi    # 0x5b6b4d
callq 0x498c00
movq %rax, %rdi
leaq 0x1956dd(%rip), %rsi    # 0x5b6baa
callq 0x498c00
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/mmer.cpp
// Function: CMmer::CMmer(unsigned int)
CMmer::CMmer(uint32 _len)
{
	switch (_len)
	{
	case 5:
		norm = norm5;
		break;
	case 6:
		norm = norm6;
		break;
	case 7:
		norm = norm7;
		break;
	case 8:
		norm = norm8;
		break;
	case 9:
		norm = norm9;
		break;
	case 10:
		norm = norm10;
		break;
	case 11:
		norm = norm11;
		break;
	default:
		break;
	}
	len = _len;
	mask = (1 << _len * 2) - 1;
	str = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x423473
movq -0x18(%rbp), %rax
leaq 0x193a69(%rip), %rcx    # 0x5b6e5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
leaq 0x2174b9(%rip), %rcx    # 0x63a8c0
movq %rcx, 0x10(%rax)
jmp 0x423475
movq -0x20(%rbp), %rax
leaq 0x2184a8(%rip), %rcx    # 0x63b8c0
movq %rcx, 0x10(%rax)
jmp 0x423475
movq -0x20(%rbp), %rax
leaq 0x21c497(%rip), %rcx    # 0x63f8c0
movq %rcx, 0x10(%rax)
jmp 0x423475
movq -0x20(%rbp), %rax
leaq 0x22c486(%rip), %rcx    # 0x64f8c0
movq %rcx, 0x10(%rax)
jmp 0x423475
movq -0x20(%rbp), %rax
leaq 0x26c475(%rip), %rcx    # 0x68f8c0
movq %rcx, 0x10(%rax)
jmp 0x423475
movq -0x20(%rbp), %rax
leaq 0x36c464(%rip), %rcx    # 0x78f8c0
movq %rcx, 0x10(%rax)
jmp 0x423475
movq -0x20(%rbp), %rax
leaq 0x76c453(%rip), %rcx    # 0xb8f8c0
movq %rcx, 0x10(%rax)
jmp 0x423475
jmp 0x423475
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %ecx
shll %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/../kmc_api/mmer.h
// Function: CMmer::_si::_si()
_si()
		{
			init_norm(norm5, 5);
			init_norm(norm6, 6);
			init_norm(norm7, 7);
			init_norm(norm8, 8);
			init_norm(norm9, 9);
			init_norm(norm10, 10);
			init_norm(norm11, 11);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x21740d(%rip), %rdi    # 0x63a8c0
movl $0x5, %esi
callq 0x423530
leaq 0x2183fc(%rip), %rdi    # 0x63b8c0
movl $0x6, %esi
callq 0x423530
leaq 0x21c3eb(%rip), %rdi    # 0x63f8c0
movl $0x7, %esi
callq 0x423530
leaq 0x22c3da(%rip), %rdi    # 0x64f8c0
movl $0x8, %esi
callq 0x423530
leaq 0x26c3c9(%rip), %rdi    # 0x68f8c0
movl $0x9, %esi
callq 0x423530
leaq 0x36c3b8(%rip), %rdi    # 0x78f8c0
movl $0xa, %esi
callq 0x423530
leaq 0x76c3a7(%rip), %rdi    # 0xb8f8c0
movl $0xb, %esi
callq 0x423530
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/../kmc_api/mmer.h
// Function: CMmer::_si::init_norm(unsigned int*, unsigned int)
static void init_norm(uint32* norm, uint32 len)
		{
			uint32 special = 1 << len * 2;
			for(uint32 i = 0 ; i < special ; ++i)
			{				
				uint32 rev = get_rev(i, len);
				uint32 str_val = is_allowed(i, len) ? i : special;
				uint32 rev_val = is_allowed(rev, len) ? rev : special;
				norm[i] = MIN(str_val, rev_val);				
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x4235ea
movl -0x14(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x4235f0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x423660
testb $0x1, %al
jne 0x423580
jmp 0x423588
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x42358e
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x423660
testb $0x1, %al
jne 0x4235a5
jmp 0x4235ad
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x4235b3
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x4235c9
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4235cf
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x423555
addq $0x30, %rsp
popq %rbp
retq
// File: ChnMasterOG[P]KmerGO2/kmc_api/../kmc_api/mmer.h
// Function: CMmer::_si::get_rev(unsigned int, unsigned int)
static uint32 get_rev(uint32 mmer, uint32 len)
		{
			uint32 rev = 0;
			uint32 shift = len*2 - 2;
			for(uint32 i = 0 ; i < len ; ++i)
			{
				rev += (3 - (mmer & 3)) << shift;
				mmer >>= 2;
				shift -= 2;
			}
			return rev;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x423650
movl -0x4(%rbp), %ecx
andl $0x3, %ecx
movl $0x3, %eax
subl %ecx, %eax
movl -0x10(%rbp), %ecx
shll %cl, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x423613
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ChnMasterOG[P]KmerGO2/kmc_api/../kmc_api/mmer.h
// Function: CMmer::is_allowed(unsigned int, unsigned int)
static bool is_allowed(uint32 mmer, uint32 len)
	{
		if ((mmer & 0x3f) == 0x3f)            // TTT suffix
			return false;
		if ((mmer & 0x3f) == 0x3b)            // TGT suffix
			return false;
		if ((mmer & 0x3c) == 0x3c)            // TG* suffix
			return false;

		for (uint32 j = 0; j < len - 3; ++j)
		if ((mmer & 0xf) == 0)                // AA inside
			return false;
		else
			mmer >>= 2;

		if (mmer == 0)            // AAA prefix
			return false;
		if (mmer == 0x04)        // ACA prefix
			return false;
		if ((mmer & 0xf) == 0)    // *AA prefix
			return false;
	
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x3f, %eax
cmpl $0x3f, %eax
jne 0x42367e
movb $0x0, -0x1(%rbp)
jmp 0x423708
movl -0x8(%rbp), %eax
andl $0x3f, %eax
cmpl $0x3b, %eax
jne 0x42368f
movb $0x0, -0x1(%rbp)
jmp 0x423708
movl -0x8(%rbp), %eax
andl $0x3c, %eax
cmpl $0x3c, %eax
jne 0x4236a0
movb $0x0, -0x1(%rbp)
jmp 0x423708
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jae 0x4236db
movl -0x8(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x4236c5
movb $0x0, -0x1(%rbp)
jmp 0x423708
movl -0x8(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x8(%rbp)
jmp 0x4236d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4236a7
cmpl $0x0, -0x8(%rbp)
jne 0x4236e7
movb $0x0, -0x1(%rbp)
jmp 0x423708
cmpl $0x4, -0x8(%rbp)
jne 0x4236f3
movb $0x0, -0x1(%rbp)
jmp 0x423708
movl -0x8(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x423704
movb $0x0, -0x1(%rbp)
jmp 0x423708
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::OpenForRA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool CKMCFile::OpenForRA(const std::string &file_name)
{
	uint64 size;
	size_t result;

	if (file_pre || file_suf)
		return false;

	if (!OpenASingleFile(file_name + ".kmc_pre", file_pre, size, (char *)"KMCP"))
		return false;

	ReadParamsFrom_prefix_file_buf(size);

	fclose(file_pre);
	file_pre = NULL;
		
	if (!OpenASingleFile(file_name + ".kmc_suf", file_suf, size, (char *)"KMCS"))
		return false;

	sufix_file_buf = new uchar[size];
	result = fread(sufix_file_buf, 1, size, file_suf);
	if (result != size)
		return false;

	fclose(file_suf);
	file_suf = NULL;

	is_opened = opened_for_RA;
	prefix_index = 0;
	sufix_number = 0;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x42373d
movq -0x80(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x423746
movb $0x0, -0x1(%rbp)
jmp 0x4238fa
movq -0x18(%rbp), %rsi
leaq 0x1929ad(%rip), %rdx    # 0x5b60fe
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x41e940
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rdi, %rdx
addq $0x20, %rdx
leaq 0x19371a(%rip), %r8     # 0x5b6e94
leaq -0x20(%rbp), %rcx
callq 0x423920
movb %al, -0x81(%rbp)
jmp 0x42378b
movb -0x81(%rbp), %al
xorb $-0x1, %al
movb %al, -0x91(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x49efd0
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x4237ae
jmp 0x4237d1
movb $0x0, -0x1(%rbp)
jmp 0x4238fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x49efd0
jmp 0x423908
movq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x423ab0
movq -0x80(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5012c0
movq -0x80(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rsi
leaq 0x1928c0(%rip), %rdx    # 0x5b60c9
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x41e940
movq -0x80(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rcx
movq %rdi, %rdx
addq $0x28, %rdx
leaq 0x193660(%rip), %r8     # 0x5b6e99
callq 0x423920
movb %al, -0x92(%rbp)
jmp 0x423846
movb -0x92(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa9(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x49efd0
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x423869
jmp 0x423889
movb $0x0, -0x1(%rbp)
jmp 0x4238fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x49efd0
jmp 0x423908
movq -0x20(%rbp), %rdi
callq 0x42fb90
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x60(%rax)
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rdx
movq 0x28(%rax), %rcx
movl $0x1, %esi
callq 0x501c20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x4238c7
movb $0x0, -0x1(%rbp)
jmp 0x4238fa
movq -0x80(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5012c0
movq -0x80(%rbp), %rax
movq $0x0, 0x28(%rax)
movl $0x1, (%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x68(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4d3c10
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::OpenASingleFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _IO_FILE*&, unsigned long long&, char*)
bool CKMCFile::OpenASingleFile(const std::string &file_name, FILE *&file_handler, uint64 &size, char marker[])
{
	char _marker[4];
	size_t result;

	if ((file_handler = my_fopen(file_name.c_str(), "rb")) == NULL)
		return false;

	my_fseek(file_handler, 0, SEEK_END);
	size = my_ftell(file_handler);					//the size of a whole file

	my_fseek(file_handler, -4, SEEK_CUR);
	result = fread(_marker, 1, 4, file_handler);
	if (result == 0)
		return false;

	size = size - 4;							//the size of the file without the terminal marker
	if (strncmp(marker, _marker, 4) != 0)
	{
		fclose(file_handler);
		file_handler = NULL;
		return false;
	}

	rewind(file_handler);
	result = fread(_marker, 1, 4, file_handler);
	if (result == 0)
		return false;

	size = size - 4;							//the size of the file without initial and terminal markers 

	if (strncmp(marker, _marker, 4) != 0)
	{
		fclose(file_handler);
		file_handler = NULL;
		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)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a0a10
movq %rax, %rdi
leaq 0x19357c(%rip), %rsi    # 0x5b6ecb
callq 0x5019f0
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x42396a
movb $0x0, -0x1(%rbp)
jmp 0x423aa5
movq -0x20(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x506370
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x501d20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq $-0x4, %rsi
movl $0x1, %edx
callq 0x506370
leaq -0x34(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x501c20
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x4239db
movb $0x0, -0x1(%rbp)
jmp 0x423aa5
movq -0x28(%rbp), %rax
movq (%rax), %rcx
subq $0x4, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
movl $0x4, %edx
callq 0x401048
cmpl $0x0, %eax
je 0x423a24
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x5012c0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x423aa5
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x5066b0
leaq -0x34(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x501c20
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x423a5b
movb $0x0, -0x1(%rbp)
jmp 0x423aa5
movq -0x28(%rbp), %rax
movq (%rax), %rcx
subq $0x4, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
movl $0x4, %edx
callq 0x401048
cmpl $0x0, %eax
je 0x423aa1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x5012c0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x423aa5
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::CKMCFile()
CKMCFile::CKMCFile()
{
	file_pre = NULL;	
	file_suf = NULL;

	prefix_file_buf = NULL;
	sufix_file_buf = NULL;
	signature_map = NULL;

	is_opened = closed;
	end_of_file = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x50(%rax)
movl $0x0, (%rax)
movb $0x0, 0x18(%rax)
popq %rbp
retq
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::~CKMCFile()
CKMCFile::~CKMCFile()
{
	if (file_pre)
		fclose(file_pre);
	if (file_suf)
		fclose(file_suf);
	if (prefix_file_buf)
		delete[] prefix_file_buf;
	if (sufix_file_buf)
		delete[] sufix_file_buf;
	if (signature_map)
		delete[] signature_map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x42447c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5012c0
jmp 0x42447a
jmp 0x42447c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x424498
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5012c0
jmp 0x424496
jmp 0x424498
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4244c0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4244be
movq -0x18(%rbp), %rdi
callq 0x42eca0
jmp 0x4244c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x4244e8
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4244e6
movq -0x20(%rbp), %rdi
callq 0x42eca0
jmp 0x4244e8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x424510
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x42450e
movq -0x28(%rbp), %rdi
callq 0x42eca0
jmp 0x424510
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x407a00
nop
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::CheckKmer(CKmerAPI&, float&)
bool CKMCFile::CheckKmer(CKmerAPI &kmer, float &count)
{
	uint32 int_counter;
	if (CheckKmer(kmer, int_counter))
	{
		if (mode == 0)
			count = (float)int_counter;
		else
			memcpy(&count, &int_counter, counter_size);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x4245a0
testb $0x1, %al
jne 0x42454f
jmp 0x42458a
movq -0x30(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x42456b
movl -0x24(%rbp), %eax
cvtsi2ss %rax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x424584
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movl 0x80(%rax), %eax
movl %eax, %edx
leaq -0x24(%rbp), %rsi
callq 0x401080
movb $0x1, -0x1(%rbp)
jmp 0x42458e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::ReadNextKmer(CKmerAPI&, float&)
bool CKMCFile::ReadNextKmer(CKmerAPI &kmer, float &count)
{
	uint32 int_counter;
	if (ReadNextKmer(kmer, int_counter))
	{
		if (mode == 0)
			count = (float)int_counter;
		else
			memcpy(&count, &int_counter, counter_size);
		return true;
	}
	return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x424d00
testb $0x1, %al
jne 0x424caf
jmp 0x424cea
movq -0x30(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x424ccb
movl -0x24(%rbp), %eax
cvtsi2ss %rax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x424ce4
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movl 0x80(%rax), %eax
movl %eax, %edx
leaq -0x24(%rbp), %rsi
callq 0x401080
movb $0x1, -0x1(%rbp)
jmp 0x424cee
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::Reload_sufix_file_buf()
void CKMCFile::Reload_sufix_file_buf()
{
	auto to_read = MIN(suf_file_left_to_read, part_size);
	auto readed = fread(sufix_file_buf, 1, (size_t)to_read, file_suf);
	suf_file_left_to_read -= readed;
	if (readed != to_read)
	{
		std::cerr << "Error: some error while reading suffix file\n";
		exit(1);
	}
	index_in_partial_buf = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
cmpq 0x212099(%rip), %rax    # 0x637178
jae 0x4250ef
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4250fa
movq 0x212082(%rip), %rax    # 0x637178
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rdx
movq 0x28(%rax), %rcx
movl $0x1, %esi
callq 0x501c20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x42515d
movq $0x1b907e0, %rdi        # imm = 0x1B907E0
leaq 0x191d50(%rip), %rsi    # 0x5b6e9e
callq 0x498c00
movl $0x1, %edi
callq 0x4ef4f0
movq -0x20(%rbp), %rax
movq $0x0, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::Close()
bool CKMCFile::Close()
{
	if(is_opened)
	{
		if(file_pre)
		{
			fclose(file_pre);	
			file_pre = NULL;
		}
		if(file_suf)
		{
			fclose(file_suf);
			file_suf = NULL;
		}
	
		is_opened = closed;
		end_of_file = false;
		delete [] prefix_file_buf;
		prefix_file_buf = NULL;
		delete [] sufix_file_buf;
		sufix_file_buf = NULL;
		delete[] signature_map;
		signature_map = NULL;

		return true;
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
je 0x425592
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4254f1
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5012c0
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x425515
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5012c0
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movb $0x0, 0x18(%rax)
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x42553a
movq -0x20(%rbp), %rdi
callq 0x42eca0
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x42555d
movq -0x28(%rbp), %rdi
callq 0x42eca0
movq -0x18(%rbp), %rax
movq $0x0, 0x60(%rax)
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x425580
movq -0x30(%rbp), %rdi
callq 0x42eca0
movq -0x18(%rbp), %rax
movq $0x0, 0x50(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x425596
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::RestartListing()
bool CKMCFile::RestartListing(void)
{
	if(is_opened == opened_for_listing)
	{
		my_fseek(file_suf , 4 , SEEK_SET);
		suf_file_left_to_read = suffix_file_total_to_read;
		auto to_read = MIN(suf_file_left_to_read, part_size);
		auto readed = fread(sufix_file_buf, 1, to_read, file_suf);
		if (readed != to_read)
		{
			std::cerr << "Error: some error while reading suffix file\n";
			return false;
		}

		suf_file_left_to_read -= readed;
		prefix_index = 0;
		sufix_number = 0;
		index_in_partial_buf = 0;

		end_of_file = total_kmers == 0;

		return true;
	}
	return false;
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x2, (%rax)
jne 0x42569e
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x506370
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
cmpq 0x211b80(%rip), %rax    # 0x637178
jae 0x425608
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x425613
movq 0x211b69(%rip), %rax    # 0x637178
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rdx
movq 0x28(%rax), %rcx
movl $0x1, %esi
callq 0x501c20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x42565c
movq $0x1b907e0, %rdi        # imm = 0x1B907E0
leaq 0x19184d(%rip), %rsi    # 0x5b6e9e
callq 0x498c00
movb $0x0, -0x1(%rbp)
jmp 0x4256a2
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
cmpq $0x0, 0x98(%rax)
sete %cl
andb $0x1, %cl
movb %cl, 0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4256a2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChnMasterOG[P]KmerGO2/kmc_api/kmc_file.cpp
// Function: CKMCFile::SetMinCount(unsigned int)
bool CKMCFile::SetMinCount(uint32 x)
{
	if((original_min_count <= x) && (x <= max_count))
	{
		min_count = x;
		return true;
	} 
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0xb0(%rax), %eax
cmpl -0x14(%rbp), %eax
ja 0x4256f1
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpq 0x90(%rcx), %rax
ja 0x4256f1
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x8c(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4256f5
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::SetMaxCount(unsigned int)
bool CKMCFile::SetMaxCount(uint32 x)
{
	if((original_max_count >= x) && (x >= min_count))
	{
		max_count = x;
		return true; 
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xb8(%rax), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jb 0x425765
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8c(%rcx), %eax
jb 0x425765
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rcx, 0x90(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x425769
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq