LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/BGL_Dijkstra.cc
// Function: initialize_distances_from_source(boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS> const&)
distance_map_t initialize_distances_from_source(
								const graph_t &graph)
{
	map<vertex_descriptor, float> distances;
	
	int num_nodes = num_vertices(graph);

	for (int i = 0; i < num_nodes; ++i)
	{
		distances[vertex(i,graph)] = INFINITY;
	}

	return distances;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq 0x20(%rsi), %r15
subq 0x18(%rsi), %r15
shrq $0x5, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
movq %rsp, %r14
cmpq %r12, %r15
je 0x97c3
movq %r12, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6a6a
movl $0x7f800000, (%rax)     # imm = 0x7F800000
incq %r12
jmp 0x97a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x70ae
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/BGL_Dijkstra.cc
// Function: initialize_distances_from_source_and_mutex_maps(boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS> const&, std::map<unsigned long, std::shared_ptr<std::mutex>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<std::mutex>>>>&, std::map<unsigned long, std::shared_ptr<std::mutex>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<std::mutex>>>>&)
distance_map_t initialize_distances_from_source_and_mutex_maps(
								const graph_t &graph,
								mutex_map_t &distance_mutexes,
								mutex_map_t &predecessor_mutexes)
{
	map<vertex_descriptor, float> distances;
	
	int num_nodes = num_vertices(graph);

	for (int i = 0; i < num_nodes; ++i)
	{
		vertex_descriptor current_vertex = vertex(i,graph);
		distances[current_vertex] = INFINITY;
		//if (DEBUG) std::cout<<"i bet that infinity is a really big negative. it is "<< INFINITY <<std::endl;
		distance_mutexes[current_vertex] = mutex_ptr(new std::mutex);
		predecessor_mutexes[current_vertex] = mutex_ptr(new std::mutex);
	}

	return distances;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, (%rsp)
andq $0x0, 0x28(%rdi)
movq 0x20(%rsi), %rbx
subq 0x18(%rsi), %rbx
movq %rdx, %r13
shrq $0x5, %rbx
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
leaq 0x20(%rsp), %rbp
pushq $0x28
popq %r15
leaq 0x8(%rsp), %r12
cmpq %r14, %rbx
je 0x9f1b
movq %r14, 0x20(%rsp)
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0xaf02
movl $0x7f800000, (%rax)     # imm = 0x7F800000
movq %r15, %rdi
callq 0x3280
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
andq $0x0, 0x20(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xc2e0
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb040
movq %rax, %rdi
movq %r12, %rsi
callq 0xc37c
leaq 0x10(%rsp), %rdi
callq 0xb404
movq %r15, %rdi
callq 0x3280
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
andq $0x0, 0x20(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xc2e0
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0xb040
movq %rax, %rdi
movq %r12, %rsi
callq 0xc37c
leaq 0x10(%rsp), %rdi
callq 0xb404
incq %r14
jmp 0x9e6d
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f30
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xb404
jmp 0x9f46
jmp 0x9f43
jmp 0x9f43
movq %rax, %r14
movq (%rsp), %rdi
callq 0x70ae
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/reset.cc
// Function: main
int main() 
{
	int j = 42;
	reset(j);  // j is passed by reference; the value in j is changed
	cout << "j = " << j  << endl;  // prints j = 0

	j = 42;    // restore the original value of j
	reset(&j);                     // changes j but not the address of j
	cout << "j = "  << j << endl;  // prints j = 0

	j = 42;    // restore the original value of j
	int *p = &j;
	reset(p); // changes object to which p points not the address in p
	cout << "j = "  << *p << endl;  // prints j = 0

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dfc(%rip), %rbx      # 0x3fd8
leaq 0xe21(%rip), %r14       # 0x2004
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/onlyuser[P]Sandbox/test_c/c++14/main.cpp
// Function: A::~A()
~A()
    {
        if(m_buf) {
            std::cout << "A::~A(\"" << m_buf << "\")" << std::endl;
            delete []m_buf;
            return;
        }
        std::cout << "A::~A()" << std::endl;
    }

// Assembly:
pushq %rbx
cmpq $0x0, (%rdi)
je 0x17c3
movq %rdi, %rbx
movq 0x4851(%rip), %rdi      # 0x5fd8
leaq 0x1944(%rip), %rsi      # 0x30d2
callq 0x10c0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x10c0
leaq 0x192a(%rip), %rsi      # 0x30cf
movq %rax, %rdi
callq 0x10c0
movq %rax, %rdi
callq 0x1070
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17de
popq %rbx
jmp 0x10f0
movq 0x480e(%rip), %rdi      # 0x5fd8
leaq 0x1909(%rip), %rsi      # 0x30da
callq 0x10c0
movq %rax, %rdi
callq 0x1070
popq %rbx
retq
movq %rax, %rdi
callq 0x19ed
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::SkipList(int)
SkipList::SkipList(int maxl) {
  max_level = maxl;
  if (max_level == 0) max_level = 1;
  if (max_level > MAX_LEVEL) max_level = MAX_LEVEL;
  head = new node();
  tail = new node();
  head->key = -1;
  head->topLevel = max_level;
  tail->key = INT_MAX;
  tail->topLevel = max_level;
  for (int i = 0; i < MAX_LEVEL; i++) {
	for (int k = 0; k < FANOUT; k++) {
	  head->nexts[i][k].nxt = tail;
	  head->nexts[i][k].prefix = INT_MAX;
	}
  }
  count = 0;
  pointer_follows = 0;
  for (int i = 0; i <= FANOUT; i++) {
	drop_down_pred[i] = 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
adcl $0x0, %esi
cmpl $0xd, %esi
pushq $0xd
popq %rbp
cmovll %esi, %ebp
movl %ebp, 0x10(%rdi)
movl $0x348, %edi            # imm = 0x348
callq 0x10d0
movq %rax, %r14
xorl %r12d, %r12d
movl $0x348, %edx            # imm = 0x348
movq %rax, %rdi
xorl %esi, %esi
callq 0x1060
movq %r14, (%rbx)
movl $0x348, %edi            # imm = 0x348
callq 0x10d0
movq %rax, %r15
movl $0x348, %edx            # imm = 0x348
movq %rax, %rdi
xorl %esi, %esi
callq 0x1060
movq %r15, 0x8(%rbx)
orl $-0x1, (%r14)
movl %ebp, 0x4(%r14)
movl $0x7fffffff, (%r15)     # imm = 0x7FFFFFFF
movl %ebp, 0x4(%r15)
addq $0x10, %r14
cmpq $0xd, %r12
je 0x12e2
xorl %eax, %eax
cmpq $0x40, %rax
je 0x12d9
movq %r15, (%r14,%rax)
movl $0x7fffffff, -0x8(%r14,%rax) # imm = 0x7FFFFFFF
addq $0x10, %rax
jmp 0x12c0
incq %r12
addq $0x40, %r14
jmp 0x12b8
andq $0x0, 0x28(%rbx)
xorl %eax, %eax
cmpq $0x5, %rax
je 0x12f9
andl $0x0, 0x14(%rbx,%rax,4)
incq %rax
jmp 0x12e9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::~SkipList()
SkipList::~SkipList() {
  node* ptr = head;
  while (ptr != NULL && ptr != tail) {
	node* tmp = ptr;
	ptr = ptr->nexts[0][0].nxt;
	delete tmp;
  }
  if (head) delete head;
  if (tail) delete tail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rbx), %rdi
testq %rax, %rax
je 0x1330
cmpq %rdi, %rax
je 0x1330
movq 0x10(%rax), %r14
movl $0x348, %esi            # imm = 0x348
movq %rax, %rdi
callq 0x10e0
movq %r14, %rax
jmp 0x130c
movq (%rbx), %rax
testq %rax, %rax
je 0x1349
movl $0x348, %esi            # imm = 0x348
movq %rax, %rdi
callq 0x10e0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x135f
movl $0x348, %esi            # imm = 0x348
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::fastFindNode(int)
int SkipList::fastFindNode(int key) {
  node* pred = head;
  int lFound = -1;
  for (int level = pred->topLevel-1; level >= 0; level--) {
	node* curr = pred->nexts[level][FANOUT-1].nxt;
	while (key > pred->nexts[level][FANOUT-1].prefix) {
	  pred = curr;
	  curr = pred->nexts[level][FANOUT-1].nxt;
	  inc();
	}
	int extra = 0;
	while (key > pred->nexts[level][extra].prefix) extra++;
	if (lFound == -1 && key == pred->nexts[level][extra].prefix) {
	  return level;
	}
	curr = pred->nexts[level][extra].nxt;
	if (extra > 0) {
	  pred = pred->nexts[level][extra-1].nxt;
	  inc();
	}
  }
  return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r11
movl 0x4(%r11), %ecx
movl 0x2c(%rdi), %edx
movl 0x28(%rdi), %r8d
leal -0x1(%rcx), %r9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xfffffffe, %r10d      # imm = 0xFFFFFFFE
testl %ecx, %ecx
jle 0x142f
movl %r9d, %r15d
shlq $0x6, %r15
decq %rcx
movl %ecx, %ebx
shlq $0x6, %rbx
movq 0x40(%r11,%rbx), %r12
movq %r11, %r14
cmpl %esi, 0x38(%r14,%rbx)
jge 0x13dc
movq %r12, %r11
movq 0x40(%r12,%rbx), %r12
movq %r11, %r14
cmpl $0x1, %edx
jne 0x13bc
incl %r8d
movl %r8d, 0x28(%rdi)
jmp 0x13b9
leaq 0x8(%r14), %r11
leaq (%r14,%r15), %r12
addq $0x8, %r12
xorl %r15d, %r15d
decq %r15
leaq 0x10(%r12), %r13
cmpl %esi, (%r12)
movq %r13, %r12
jl 0x13eb
je 0x142d
cmpq $-0x1, %r15
je 0x1422
movl %r10d, %r14d
subl %r15d, %r14d
addq %rbx, %r11
shlq $0x4, %r14
movq 0x8(%r14,%r11), %r14
cmpl $0x1, %edx
jne 0x1422
incl %r8d
movl %r8d, 0x28(%rdi)
decl %r9d
movq %r14, %r11
jmp 0x139c
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::insert(int)
int SkipList::insert(int key) {
  node *preds[max_level][FANOUT], *succs[max_level][FANOUT];
  for (int i = 0; i < max_level; i++) {
	for (int k = 0; k < FANOUT; k++) {
	  preds[i][k] = NULL;
	  succs[i][k] = NULL;
	}
  }
  int found = findNode(key, preds, succs);
  if (found != -1) return 0;
  node* add = new node();
  add->key = key;
  int topLevel = randomLevel(max_level);
  add->topLevel = topLevel;
  for (int level = 0; level< add->topLevel; level++) {
	for (int k = 0; k < FANOUT; k++) {
	  add->nexts[level][k].nxt = succs[level][k];
	  add->nexts[level][k].prefix = succs[level][k]->key;
	  node* pr = preds[level][k];
	  if (pr) {
		// scoot rest down
		for (int j = FANOUT-2; j >= k; j--) {
		  pr->nexts[level][j+1].nxt = pr->nexts[level][j].nxt;
		  pr->nexts[level][j+1].prefix = pr->nexts[level][j].prefix;
		}
		pr->nexts[level][k].nxt = add;
		pr->nexts[level][k].prefix  = key;
	  }
	}
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r13
movl 0x10(%rdi), %edx
movq %rsp, %r14
movq %rdx, %rax
shlq $0x5, %rax
subq %rax, %r14
movq %r14, %rsp
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
movq %r14, %rdx
movq %r15, %rsi
cmpq %rcx, %rax
je 0x18d9
xorl %edi, %edi
cmpq $0x4, %rdi
je 0x18cc
andq $0x0, (%rdx,%rdi,8)
andq $0x0, (%rsi,%rdi,8)
incq %rdi
jmp 0x18b7
incq %rax
addq $0x20, %rsi
addq $0x20, %rdx
jmp 0x18b0
movq %r13, %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x165c
xorl %ecx, %ecx
cmpl $-0x1, %eax
jne 0x19eb
movq %r15, -0x38(%rbp)
movq %r14, -0x40(%rbp)
movl $0x348, %edi            # imm = 0x348
callq 0x10d0
movq %rax, %r12
movl $0x348, %edx            # imm = 0x348
movq %rax, %rdi
xorl %esi, %esi
callq 0x1060
movl %ebx, (%r12)
movl 0x10(%r13), %edi
callq 0x1439
xorl %r10d, %r10d
movl %eax, 0x4(%r12)
movq %r12, %rcx
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
testl %eax, %eax
cmovlel %r10d, %eax
movq %rax, -0x48(%rbp)
pushq $0x40
popq %rsi
pushq $0x2
popq %rax
cmpq -0x48(%rbp), %r10
je 0x19e8
movq %r10, %r8
shlq $0x5, %r8
movq -0x38(%rbp), %rcx
leaq (%rcx,%r8), %r9
movq %r10, -0x50(%rbp)
shlq $0x6, %r10
movq -0x30(%rbp), %rcx
leaq (%rcx,%r10), %r11
addq -0x40(%rbp), %r8
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x19d8
movq (%r9,%rcx,8), %rdx
movq %rcx, %r14
shlq $0x4, %r14
movq %rdx, 0x8(%r14,%r11)
movl (%rdx), %edx
movl %edx, (%r14,%r11)
movq (%r8,%rcx,8), %rdx
testq %rdx, %rdx
je 0x19d3
movl %ebx, %r13d
leaq 0x8(%rdx), %r15
addq %rsi, %rdx
movq %rax, %rdi
cmpq %rcx, %rdi
jl 0x19c4
movq -0x10(%rdx), %rbx
movq %rbx, (%rdx)
movl -0x18(%rdx), %ebx
movl %ebx, -0x8(%rdx)
addq $-0x10, %rdx
decq %rdi
jmp 0x19a9
addq %r10, %r15
movq %r12, 0x8(%r14,%r15)
movl %r13d, (%r14,%r15)
movl %r13d, %ebx
incq %rcx
jmp 0x1977
movq -0x50(%rbp), %r10
incq %r10
addq $0x40, %rsi
jmp 0x1948
pushq $0x1
popq %rcx
movl %ecx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::init_list(int, int, int)
SkipList* SkipList::init_list(int sz, int high, int max_level) {
  SkipList* skip = new SkipList(max_level);
  int count = 0;
  while (count < sz) {
	if (skip->insert(rand() % high) > 0) {
	  count++;
	}
  }
  return skip;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebx
movl %edi, %ebp
pushq $0x30
popq %rdi
callq 0x10d0
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1242
xorl %r15d, %r15d
cmpl %ebp, %r15d
jge 0x1a3f
callq 0x1050
cltd
idivl %ebx
movq %r14, %rdi
movl %edx, %esi
callq 0x186c
addl %eax, %r15d
jmp 0x1a23
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x10e0
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::detailed_print()
void SkipList::detailed_print() {
  node* ptr = head;
  while (ptr != tail) {
	printf("[K:%02d ", ptr->key);
	for (int level = 0; level < ptr->topLevel; level++) {
	  printf("N: ");
	  for (int k = 0; k < FANOUT; k++) {
		if (ptr->nexts[level][k].prefix == INT_MAX) {
		  printf("ND ");
		} else {		
		  printf("%02d ", ptr->nexts[level][k].nxt->key);
		}
	  }
	}
	printf("]\n");
	ptr = ptr->nexts[0][0].nxt;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11f0(%rip), %r12      # 0x3025
leaq 0x11df(%rip), %r13      # 0x301b
movq %rdi, (%rsp)
movq (%rbx), %rbx
movq (%rsp), %rax
cmpq 0x8(%rax), %rbx
je 0x1ed4
movl (%rbx), %esi
leaq 0x11be(%rip), %rdi      # 0x3018
xorl %eax, %eax
callq 0x1040
leaq 0x10(%rbx), %rbp
xorl %r14d, %r14d
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jge 0x1ebf
leaq 0x11a9(%rip), %rdi      # 0x3021
xorl %eax, %eax
callq 0x1040
xorl %r15d, %r15d
cmpq $0x40, %r15
je 0x1eb6
cmpl $0x7fffffff, -0x8(%rbp,%r15) # imm = 0x7FFFFFFF
jne 0x1e9f
movq %r12, %rdi
xorl %eax, %eax
callq 0x1040
jmp 0x1eb0
movq (%rbp,%r15), %rax
movl (%rax), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x1040
addq $0x10, %r15
jmp 0x1e82
incq %r14
addq $0x40, %rbp
jmp 0x1e68
leaq 0x15eb(%rip), %rdi      # 0x34b1
callq 0x1100
addq $0x10, %rbx
jmp 0x1e40
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: fillRandom(SkipList*, int)
void fillRandom(SkipList* skip, int sz) {
  int count = 0;
  while (count < sz) {
	int rnd = rand() % sz;
	if (skip->insert(rnd) > 0) {
	  printf("%d ", rnd);
	  count++;
	}
  }
  skip->pretty_print();
  //  skip->detailed_print();
  printf("\nInserted %d keys randomly\n", count);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0xfa6(%rip), %r15       # 0x3088
xorl %ebx, %ebx
cmpl %ebp, %ebx
jge 0x2112
callq 0x1050
cltd
idivl %ebp
movl %edx, %r12d
movq %r14, %rdi
movl %edx, %esi
callq 0x186c
testl %eax, %eax
je 0x20e4
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1040
incl %ebx
jmp 0x20e4
movq %r14, %rdi
callq 0x1ee4
leaq 0xf6b(%rip), %rdi       # 0x308c
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: fillForward(SkipList*, int)
void fillForward(SkipList* skip, int sz) {
  int count = 0;
  while (count < sz) {
	if (skip->insert(count) > 0) {
	  count++;
	}
  }
  printf("Inserted %d keys forwards\n", count);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
cmpl %ebp, %ebx
jge 0x214f
movq %r14, %rdi
movl %ebx, %esi
callq 0x186c
addl %eax, %ebx
jmp 0x213d
leaq 0xf52(%rip), %rdi       # 0x30a8
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: fillBackward(SkipList*, int)
void fillBackward(SkipList* skip, int sz) {
  int count = 0;
  while (count < sz) {
	if (skip->insert(sz-count-1) > 0) {
	  count++;
	}
  }
  printf("Inserted %d keys backwards\n", count);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
cmpl %ebp, %ebx
jge 0x2184
movl %ebx, %esi
notl %esi
addl %ebp, %esi
movq %r14, %rdi
callq 0x186c
addl %eax, %ebx
jmp 0x216e
leaq 0xf38(%rip), %rdi       # 0x30c3
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: empty_fill(int, void (*)(SkipList*, int))
SkipList* empty_fill(int sz, void (*fill)(SkipList*, int)) {
  int maxl = floor(log(sz)/log(FANOUT)) + 1;
  SkipList* skip = new SkipList(maxl);
  fill(skip, sz);
  return skip;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x2b8a
divsd 0xe57(%rip), %xmm0      # 0x3008
callq 0x1120
addsd 0xe52(%rip), %xmm0      # 0x3010
cvttsd2si %xmm0, %r15d
pushq $0x30
popq %rdi
callq 0x10d0
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1242
movq %r14, %rdi
movl %ebp, %esi
callq *%rbx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x10e0
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist-extra.cc
// Function: perfect_test(int)
int perfect_test(int sz) {
  printf("Testing perfect skiplist lookups... ");
  int maxl = floor(log(sz)/log(FANOUT)) + 1;
  SkipList* sk = perfect_list(sz, maxl);
  for (int i = 0; i < sz; i++) {
	assert (sk->lookup(i) > 0);
  }
  assert (sk->lookup(99) <= 0);
  printf("PASSED\n");
  printf("Testing perfect skiplist inserts... ");
  perfect_insert_test(sk);
  printf("PASSED\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0xae7(%rip), %rdi       # 0x338d
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1040
movl %ebx, %edi
callq 0x2b8a
divsd 0x74a(%rip), %xmm0      # 0x3008
callq 0x1120
addsd 0x745(%rip), %xmm0      # 0x3010
cvttsd2si %xmm0, %esi
movl %ebx, %edi
callq 0x1a63
movq %rax, %r14
testl %ebx, %ebx
cmovlel %ebp, %ebx
cmpl %ebp, %ebx
je 0x2911
movq %r14, %rdi
movl %ebp, %esi
callq 0x1368
incl %ebp
testl %eax, %eax
jne 0x28de
leaq 0xab9(%rip), %rdi       # 0x33b2
leaq 0x7f3(%rip), %rsi       # 0x30f3
leaq 0xabd(%rip), %rcx       # 0x33c4
movl $0x221, %edx            # imm = 0x221
callq 0x1070
pushq $0x63
popq %rsi
movq %r14, %rdi
callq 0x1368
testl %eax, %eax
jne 0x2942
leaq 0xba9(%rip), %rdi       # 0x34d0
callq 0x1100
leaq 0xaa7(%rip), %rdi       # 0x33da
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x2204
leaq 0x796(%rip), %rdi       # 0x30df
leaq 0x7a3(%rip), %rsi       # 0x30f3
leaq 0xa6d(%rip), %rcx       # 0x33c4
movl $0x223, %edx            # imm = 0x223
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O2/ChnMasterOG[P]KmerGO2/kmergo/KmerGO_io.h
// Function: getFiles(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, bool)
inline void getFiles(std::string path, std::vector<std::string>& files, bool absolute_path)
{
	char path_str[1024];
	strcpy(path_str, path.c_str());
	files.clear();

#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
	char path_buf[1024] = "";	// absolute path

	/* get real path */
	_fullpath(path_buf, path_str, 1024);
	if (path_buf[strlen(path_buf) - 1] != '\\')
	{
		path_buf[strlen(path_buf)] = '\\';
		path_buf[strlen(path_buf) + 1] = '\0';
	}
	/* get files */
	std::string p;
	int64 hFile = 0;
	struct _finddata_t fileinfo;
	if ((hFile = _findfirst(p.assign(std::string(path_buf)).append("*").c_str(), &fileinfo)) != -1) {
		do
		{
			if (fileinfo.name[0] == '.') continue;
			if (absolute_path == true) files.push_back(p.assign(std::string(path_buf)).append(fileinfo.name));
			else files.push_back(fileinfo.name);
		} while (_findnext(hFile, &fileinfo) == 0);
		_findclose(hFile);
	}
#elif defined(__linux__) || defined(linux)
	/* get files */
	DIR* dp;
	struct dirent* dirp;
	if ((dp = opendir(path_str)) != NULL)
	{
		while ((dirp = readdir(dp)) != NULL) {
			if (dirp->d_name[0] == '.') continue;
			if (absolute_path == true) files.push_back(joinPath(path_str, dirp->d_name));
			else files.push_back(dirp->d_name);
		}
	}
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp            # imm = 0x478
movl %edx, %ebx
movq %rsi, %r14
movq (%rdi), %rsi
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0x4010a0
movq %r14, %rdi
callq 0x40618c
movq %r15, %rdi
callq 0x546f20
testq %rax, %rax
je 0x405ed0
movq %rax, %r15
leaq 0x50(%rsp), %r13
leaq 0x30(%rsp), %rbp
movq %r15, %rdi
callq 0x547180
testq %rax, %rax
je 0x405ed0
movq %rax, %r12
cmpb $0x2e, 0x13(%rax)
je 0x405e2b
addq $0x13, %r12
testb %bl, %bl
je 0x405ea8
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x405d40
movq %r13, %rdi
movq %r12, %rsi
leaq 0xf(%rsp), %rdx
callq 0x405d40
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x405fcb
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4061f4
movq %rbp, %rdi
callq 0x484210
movq %r13, %rdi
callq 0x484210
leaq 0x10(%rsp), %rdi
callq 0x484210
jmp 0x405e2b
movq %rbp, %rdi
movq %r12, %rsi
leaq 0xe(%rsp), %rdx
callq 0x405d40
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4061f4
movq %rbp, %rdi
callq 0x484210
jmp 0x405e2b
addq $0x478, %rsp            # imm = 0x478
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x405f14
jmp 0x405f1b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x484210
jmp 0x405f00
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x484210
jmp 0x405f0f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x484210
jmp 0x405f1e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4b8e10
// File: /workspace/github_cpp_makefile_star2_O2/ChnMasterOG[P]KmerGO2/kmergo/KmerGO_io.h
// Function: joinPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::string joinPath(std::string path1, std::string path2)
{
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
	/* replace / to \ */
	while (1)
	{
		std::string::size_type position;
		position = path1.find("/");
		if (position == path1.npos) break;
		path1 = path1.replace(position, 1, "\\");
	}
	while (1)
	{
		std::string::size_type position;
		position = path2.find("/");
		if (position == path2.npos) break;
		path2 = path2.replace(position, 1, "\\");
	}
	/* join two paths */
	std::string::iterator it = path1.end();
	--it;
	if (*it != '\\') path1.insert(path1.end(), '\\');
#elif defined(__linux__) || defined(linux)
	/* replace \ to / */
	while (1)
	{
		std::string::size_type position;
		position = path1.find("\\");
		if (position == path1.npos) break;
		path1 = path1.replace(position, 1, "/");
	}
	while (1)
	{
		std::string::size_type position;
		position = path2.find("\\");
		if (position == path2.npos) break;
		path2 = path2.replace(position, 1, "/");
	}
	/* join two paths */
	std::string::iterator it = path1.end();
	--it;
	if (*it != '/') path1.insert(path1.end(), '/');
#endif
	path1.insert(path1.size(), path2);
	return path1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x19613b(%rip), %r12    # 0x59c121
leaq 0x1a0baf(%rip), %r13    # 0x5a6b9c
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x485d70
cmpq $-0x1, %rax
je 0x406021
movq %r14, %rdi
movq %rax, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x4853d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x483e40
jmp 0x405ff0
leaq 0x1960f9(%rip), %r12    # 0x59c121
leaq 0x1a0b6d(%rip), %r13    # 0x5a6b9c
pushq $0x1
popq %rbp
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x485d70
cmpq $-0x1, %rax
je 0x406063
movq %r15, %rdi
movq %rax, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x4853d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x483e40
jmp 0x406032
movq (%r14), %rax
movq 0x8(%r14), %rsi
cmpb $0x2f, -0x1(%rax,%rsi)
je 0x406086
addq %rsi, %rax
pushq $0x2f
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x484cf0
movq 0x8(%r14), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4852e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x484160
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ChnMasterOG[P]KmerGO2/kmergo/kmer_union.cpp
// Function: distribute_kmer_nonuniformly(unsigned char, unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void distribute_kmer_nonuniformly(uint8_t step, uint32_t num, uint32_t maxnum, std::string& out_kmer)
{
	if (step == 4) return;
	if (num < 4 * maxnum / 10) {
		out_kmer += "A"; distribute_kmer_nonuniformly(step + 1, num, 4 * maxnum / 10, out_kmer);
	}
	else if (num < 7 * maxnum / 10) {
		out_kmer += "C"; distribute_kmer_nonuniformly(step + 1, num - 4 * maxnum / 10, 3 * maxnum / 10, out_kmer);
	}
	else if (num < 9 * maxnum / 10) {
		out_kmer += "G"; distribute_kmer_nonuniformly(step + 1, num - 7 * maxnum / 10, 2 * maxnum / 10, out_kmer);
	}
	else {
		out_kmer += "T"; distribute_kmer_nonuniformly(step + 1, num - 9 * maxnum / 10, maxnum / 10, out_kmer);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r13d
movl %esi, %ebp
movl %edi, %r14d
pushq $0xa
popq %r15
incb %r14b
cmpb $0x5, %r14b
je 0x4074b8
leal (,%r13,4), %eax
xorl %edx, %edx
divl %r15d
movl %eax, %r12d
cmpl %ebp, %eax
jbe 0x407449
movq %rbx, %rdi
leaq 0x1ab9f1(%rip), %rsi    # 0x5b2e2d
callq 0x4859c0
incb %r14b
movl %r12d, %r13d
jmp 0x407414
imull $0x7, %r13d, %eax
xorl %edx, %edx
divl %r15d
cmpl %ebp, %eax
jbe 0x40746c
movq %rbx, %rdi
leaq 0x1aba2e(%rip), %rsi    # 0x5b2e8e
callq 0x4859c0
leal (%r13,%r13,2), %r13d
jmp 0x4074a5
movl %eax, %ecx
leal (%r13,%r13,8), %eax
xorl %edx, %edx
divl %r15d
cmpl %ebp, %eax
jbe 0x407493
movq %rbx, %rdi
leaq 0x1aa064(%rip), %rsi    # 0x5b14ea
movl %ecx, %r12d
callq 0x4859c0
addl %r13d, %r13d
jmp 0x4074a5
movl %eax, %r12d
movq %rbx, %rdi
leaq 0x1ab995(%rip), %rsi    # 0x5b2e35
callq 0x4859c0
movl %r13d, %eax
xorl %edx, %edx
divl %r15d
subl %r12d, %ebp
movl %eax, %r13d
jmp 0x407411
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x4, %edi
je 0x40755a
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movl %esi, %eax
andl $0x3, %eax
leaq 0x194d7a(%rip), %rcx    # 0x59c268
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1ab92f(%rip), %rsi    # 0x5b2e2d
jmp 0x407519
leaq 0x1a9fe3(%rip), %rsi    # 0x5b14ea
jmp 0x407519
leaq 0x1ab925(%rip), %rsi    # 0x5b2e35
jmp 0x407519
leaq 0x1ab975(%rip), %rsi    # 0x5b2e8e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x408269
movq %rbx, %rdi
movq %r15, %rsi
callq 0x484260
movq %r15, %rdi
callq 0x484210
incb %r14b
shrl $0x2, %ebp
movzbl %r14b, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4074c7
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x194507(%rip), %rdi    # 0x59c3b9
callq 0x4e7600
movq %rbx, %xmm0
punpckldq 0x1943bc(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1943c4(%rip), %xmm0   # 0x59c290
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
leaq 0x1944b2(%rip), %r14    # 0x59c396
movq 0x20e7f5(%rip), %rax    # 0x6166e0
cmpq %rbx, %rax
jae 0x407f36
cmpw $0x0, 0x20e7e2(%rip)    # 0x6166da
jne 0x407f36
movsd 0x20e7de(%rip), %xmm1   # 0x6166e0
unpcklps 0x194377(%rip), %xmm1   # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x19437f(%rip), %xmm1   # 0x59c290
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x19433b(%rip), %xmm0   # 0x59c260
divsd (%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4dfea0
jmp 0x407ee4
cmpw $0x0, 0x20e79c(%rip)    # 0x6166da
je 0x407f48
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x194458(%rip), %rdi    # 0x59c3a7
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4dfea0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x407fcf
movl %ebx, %eax
andl $0x3, %eax
movb $0x4, %cl
subb %al, %cl
testl %eax, %eax
movzbl %cl, %ecx
cmovel %eax, %ecx
movb %cl, 0xc(%r14)
movzbl %cl, %r15d
addl %ebx, %r15d
movl %r15d, %eax
andl $0x1f, %eax
shrl $0x5, %r15d
cmpl $0x1, %eax
sbbl $-0x1, %r15d
movl %r15d, 0x10(%r14)
shll $0x3, %r15d
movq %r15, %rdi
callq 0x414e30
movq %rax, (%r14)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x401090
jmp 0x407fdd
andq $0x0, (%r14)
andl $0x0, 0x10(%r14)
movb $0x0, 0xc(%r14)
movl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, %rax
movq (%rsi), %rsi
movq 0x8(%rax), %rdx
xorl %ecx, %ecx
movq $0x1b6b940, %rax        # imm = 0x1B6B940
movl %ecx, %ecx
cmpq %rcx, %rdx
jbe 0x408013
movzbl (%rsi,%rcx), %r8d
incl %ecx
cmpb $-0x1, (%rax,%r8)
jne 0x407ffb
xorl %eax, %eax
retq
jmp 0x40848a
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x8(%rdi), %eax
cmpl %eax, 0x8(%rsi)
jne 0x40804d
movl 0x10(%rdi), %eax
movq (%rsi), %rdx
movq (%rdi), %rsi
xorl %edi, %edi
movq %rdi, %rcx
cmpq %rcx, %rax
je 0x408054
movq (%rdx,%rcx,8), %r8
movq (%rsi,%rcx,8), %r9
cmpq %r9, %r8
ja 0x408051
leaq 0x1(%rcx), %rdi
cmpq %r9, %r8
jae 0x40802b
xorl %edi, %edi
jmp 0x408054
seta %al
retq
movb $0x1, %dil
cmpq %rax, %rcx
setb %al
andb %dil, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl 0x8(%rdi), %ecx
cmpl %ecx, %eax
jne 0x40807c
movl 0x10(%rbx), %r15d
movq (%rbx), %rax
jmp 0x4080b3
testl %ecx, %ecx
je 0x408091
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x408091
callq 0x413f40
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movb 0xc(%r14), %al
movb %al, 0xc(%rbx)
movl 0x10(%r14), %r15d
movl %r15d, 0x10(%rbx)
leaq (,%r15,8), %rdi
callq 0x414e30
movq %rax, (%rbx)
movq (%r14), %rcx
xorl %edx, %edx
cmpq %r15, %rdx
jae 0x4080ca
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
jmp 0x4080b8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x8(%rsi), %eax
cmpl 0x8(%rdi), %eax
jne 0x408101
movl 0x10(%rdi), %ecx
movq (%rsi), %rdx
movq (%rdi), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
sete %al
je 0x408100
movq (%rdx,%rdi,8), %r8
leaq 0x1(%rdi), %r9
cmpq (%rsi,%rdi,8), %r8
movq %r9, %rdi
je 0x4080e7
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x190d79(%rip), %rdi    # 0x59c584
callq 0x4e7600
movq %rbx, %xmm0
punpckldq 0x190a63(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x190a6b(%rip), %xmm0   # 0x59c290
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
leaq 0x190b59(%rip), %r14    # 0x59c396
movq 0x20aed4(%rip), %rax    # 0x616718
cmpq %rbx, %rax
jae 0x40b885
movsd 0x20aec7(%rip), %xmm1   # 0x616718
unpcklps 0x190a28(%rip), %xmm1   # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x190a30(%rip), %xmm1   # 0x59c290
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x1909ec(%rip), %xmm0   # 0x59c260
divsd (%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4dfea0
jmp 0x40b83d
leaq 0x190b1b(%rip), %rdi    # 0x59c3a7
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4dfea0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x20(%rdi), %r14
leaq 0x38(%rdi), %r15
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movl %esi, 0x18(%rdi)
leaq 0x10(%rsp), %rdi
movl %edx, %esi
callq 0x407f72
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
subl $0x1, %ebp
jb 0x40e4e1
movq %r14, %rdi
movq %r12, %rsi
callq 0x40e630
andl $0x0, 0xc(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x40e9a6
jmp 0x40e4bf
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x40e630
leaq 0x10(%rsp), %rdi
callq 0x40825c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40e510
movq %rax, %r12
jmp 0x40e51d
jmp 0x40e510
movq %rax, %r12
leaq 0x10(%rsp), %rdi
callq 0x40825c
movq %r15, %rdi
callq 0x40e69c
movq %r14, %rdi
callq 0x40e65c
movq %rbx, %rdi
callq 0x40e69c
movq %r12, %rdi
callq 0x4b8e10
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x18(%rdi), %ebp
addl %esi, %ebp
movl %ebx, %eax
imulq $0x18, %rax, %r15
cmpl $0x2, %ebp
jb 0x40e5d7
shrl %ebp
movq (%r14), %rax
movq 0x20(%r14), %rcx
leaq (%rcx,%r15), %rdi
movl %ebp, %r12d
movl (%rax,%r12,4), %eax
imulq $0x18, %rax, %rsi
addq %rcx, %rsi
callq 0x408018
testb %al, %al
jne 0x40e580
movq (%r14), %rax
movq 0x20(%r14), %rcx
leaq (%rcx,%r15), %rdi
movl (%rax,%r12,4), %eax
imulq $0x18, %rax, %rsi
addq %rcx, %rsi
callq 0x4080d4
testb %al, %al
jne 0x40e580
movq (%r14), %rax
movl (%rax,%r12,4), %ecx
movl %ebx, (%rax,%r12,4)
movl %ecx, %ebx
jmp 0x40e57a
movq (%r14), %rax
movl %ebx, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb 0xc(%rsi), %al
movb %al, 0xc(%rdi)
movl 0x10(%rsi), %r15d
movl %r15d, 0x10(%rdi)
leaq (,%r15,8), %rdi
callq 0x414e30
movq %rax, (%r14)
movq (%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x40e89c
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
jmp 0x40e88a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18dc2a(%rip), %rsi    # 0x59c824
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x405d40
leaq 0x18dc1e(%rip), %rsi    # 0x59c82e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x405d40
movslq %ebp, %r12
pushq $0x1
popq %rcx
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rcx, %r13
cmpq %r12, %rcx
jge 0x40ec5b
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x40fd1f
testb %al, %al
jne 0x40ec5b
movq (%rbx,%r13,8), %rdi
movq %r15, %rsi
callq 0x40fd1f
leaq 0x1(%r13), %rcx
testb %al, %al
je 0x40ec2f
cmpq %r12, %r13
setl %bl
leaq 0x8(%rsp), %rdi
callq 0x484210
leaq 0x28(%rsp), %rdi
callq 0x484210
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x484210
movq %rbx, %rdi
callq 0x4b8e10
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq $0x1b6c960, %rdi        # imm = 0x1B6C960
leaq 0x18db8b(%rip), %rsi    # 0x59c835
callq 0x47de40
leaq 0x18db8c(%rip), %rsi    # 0x59c842
movq %rax, %rdi
callq 0x47de40
leaq 0x192d84(%rip), %rsi    # 0x5a1a49
movq %rax, %rdi
callq 0x47de40
leaq 0x18db74(%rip), %rsi    # 0x59c848
movq %rax, %rdi
callq 0x47de40
leaq 0x18dccb(%rip), %rsi    # 0x59c9ae
movq %rax, %rdi
callq 0x47de40
leaq 0x18db61(%rip), %rsi    # 0x59c853
movq %rax, %rdi
callq 0x47de40
leaq 0x18db73(%rip), %rsi    # 0x59c874
movq %rax, %rdi
callq 0x47de40
leaq 0x18db6b(%rip), %rsi    # 0x59c87b
movq %rax, %rdi
callq 0x47de40
leaq 0x18db88(%rip), %rsi    # 0x59c8a7
movq %rax, %rdi
callq 0x47de40
leaq 0x18db83(%rip), %rsi    # 0x59c8b1
movq %rax, %rdi
callq 0x47de40
leaq 0x18db9e(%rip), %rsi    # 0x59c8db
movq %rax, %rdi
callq 0x47de40
leaq 0x18dbba(%rip), %rsi    # 0x59c906
movq %rax, %rdi
callq 0x47de40
leaq 0x18dc07(%rip), %rsi    # 0x59c962
movq %rax, %rdi
callq 0x47de40
leaq 0x18dc47(%rip), %rsi    # 0x59c9b1
movq %rax, %rdi
callq 0x47de40
leaq 0x18dc72(%rip), %rsi    # 0x59c9eb
movq %rax, %rdi
callq 0x47de40
leaq 0x18dc9b(%rip), %rsi    # 0x59ca23
movq %rax, %rdi
callq 0x47de40
leaq 0x18dcc3(%rip), %rsi    # 0x59ca5a
movq %rax, %rdi
callq 0x47de40
leaq 0x18dcef(%rip), %rsi    # 0x59ca95
movq %rax, %rdi
callq 0x47de40
leaq 0x18dd1e(%rip), %rsi    # 0x59cad3
movq %rax, %rdi
callq 0x47de40
leaq 0x18dd58(%rip), %rsi    # 0x59cb1c
movq %rax, %rdi
callq 0x47de40
leaq 0x18ddb2(%rip), %rsi    # 0x59cb85
movq %rax, %rdi
callq 0x47de40
leaq 0x18de00(%rip), %rsi    # 0x59cbe2
movq %rax, %rdi
popq %rax
jmp 0x47de40
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
leaq 0x206ba6(%rip), %rdi    # 0x616920
pushq $0x5
popq %rsi
callq 0x40fdde
leaq 0x207b97(%rip), %rdi    # 0x617920
pushq $0x6
popq %rsi
callq 0x40fdde
leaq 0x20bb88(%rip), %rdi    # 0x61b920
pushq $0x7
popq %rsi
callq 0x40fdde
leaq 0x21bb79(%rip), %rdi    # 0x62b920
pushq $0x8
popq %rsi
callq 0x40fdde
leaq 0x25bb6a(%rip), %rdi    # 0x66b920
pushq $0x9
popq %rsi
callq 0x40fdde
leaq 0x35bb5b(%rip), %rdi    # 0x76b920
pushq $0xa
popq %rsi
callq 0x40fdde
leaq 0x75bb4c(%rip), %rdi    # 0xb6b920
pushq $0xb
popq %rsi
popq %rax
jmp 0x40fdde
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal (%rbx,%rbx), %ecx
pushq $0x1
popq %r12
shll %cl, %r12d
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x40fe40
movl %r15d, %edi
movl %ebx, %esi
callq 0x40fe50
movl %eax, %ebp
movl %r15d, %edi
movl %ebx, %esi
callq 0x40fe72
movl %r15d, %r13d
testb %al, %al
jne 0x40fe20
movl %r12d, %r13d
movl %ebp, %edi
movl %ebx, %esi
callq 0x40fe72
testb %al, %al
jne 0x40fe30
movl %r12d, %ebp
cmpl %ebp, %r13d
cmovbl %r13d, %ebp
movl %ebp, (%r14,%r15,4)
incq %r15
jmp 0x40fdfb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
leal -0x2(,%rsi,2), %ecx
xorl %eax, %eax
subl $0x1, %esi
jb 0x40fe71
movl %edi, %edx
notl %edx
andl $0x3, %edx
shll %cl, %edx
addl %edx, %eax
shrl $0x2, %edi
addl $-0x2, %ecx
jmp 0x40fe59
retq