LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::GetLeadZero()
std::tuple<unsigned char, unsigned char> MSR::GetLeadZero(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get leading zero, not connect to device" << std::endl;
#endif
			return std::make_tuple(0x00, 0x00);
		}
		char resp[3];
		this->WriteAutoSize(MSR_CHECK_LEAD_ZERO);
		if(this->ReadBytes(resp, 3) != 3) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get leading zero, expected 3 bytes" << std::endl;
#endif
			return std::make_tuple(0x00, 0x00);
		}
		return std::make_tuple(resp[1], resp[2]);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x42bd
movq %rsi, %r14
movl (%rsi), %edi
leaq 0xe8d(%rip), %rsi       # 0x510f
movl $0x8, %edx
callq 0x30b0
leaq 0xd(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0x30a0
xorl %ecx, %ecx
cmpl $0x3, %eax
movzbl 0x2(%r15), %eax
cmovnel %ecx, %eax
movzbl 0x1(%r15), %edx
cmovnel %ecx, %edx
movb %al, (%rbx)
movb %dl, 0x1(%rbx)
jmp 0x42c2
movw $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/example/example3.cpp
// Function: main
int main() {
    char* file_path = "../dataset/twitter_sample_small_records.json";
    RecordSet* record_set = RecordLoader::loadRecords(file_path);
    if (record_set->size() == 0) {
        cout<<"record loading fails."<<endl;
        return -1;
    }

    QueryProcessor processor("$.entities.urls[*].url");
    int num_recs = record_set->size();
    for (int i = 0; i < num_recs; i++) {
        string output = processor.runQuery((*record_set)[i]);
        cout<<"matches are: "<<output<<endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xef80, %rsp           # imm = 0xEF80
leaq 0x9e3bf(%rip), %rdi     # 0xc41d6
callq 0x25a38
cmpq $0x0, 0x18(%rax)
je 0x25f1f
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9e3df(%rip), %rsi     # 0xc4219
leaq 0x9e3ee(%rip), %rdx     # 0xc422f
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x25ff0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x165ec
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x25e6a
callq 0x26080
movq 0x18(%rbx), %r15
testl %r15d, %r15d
jle 0x25f11
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
leaq 0xd8618(%rip), %r13     # 0xfe4a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25fb6
movq (%rax), %rdx
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x25704
movl $0xd, %edx
movq %r13, %rdi
leaq 0x9e37e(%rip), %rsi     # 0xc4230
callq 0x8eb40
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rdi
callq 0x8eb40
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6fc90
movsbl %al, %esi
movq %r12, %rdi
callq 0x8e640
movq %rax, %rdi
callq 0x8dc10
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25f05
callq 0x26080
incq %r14
cmpq %r14, %r15
jne 0x25e88
leaq 0x40(%rsp), %rdi
callq 0x16864
xorl %eax, %eax
jmp 0x25f66
leaq 0xd857a(%rip), %rbx     # 0xfe4a0
leaq 0x9e2d6(%rip), %rsi     # 0xc4203
movl $0x15, %edx
movq %rbx, %rdi
callq 0x8eb40
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6fc90
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8e640
movq %rax, %rdi
callq 0x8dc10
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x25fae
callq 0x26080
jmp 0x25fae
movq %rax, %rbx
jmp 0x25fa4
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25fa4
callq 0x26080
leaq 0x40(%rsp), %rdi
callq 0x16864
movq %rbx, %rdi
callq 0x13730
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/example/../src/lib/Records.h
// Function: RecordSet::operator[](long)
Record*& operator[] (long idx) {
        if (idx >= 0 && idx < num_recs)
            return recs[idx];
        cout << "Array index in RecordSet out of bound."<<endl; 
        exit(0); 
    }

// Assembly:
testq %rsi, %rsi
js 0x25fcc
cmpq %rsi, 0x18(%rdi)
jle 0x25fcc
shlq $0x3, %rsi
addq (%rdi), %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0xd84cc(%rip), %rdi     # 0xfe4a0
leaq 0x9e263(%rip), %rsi     # 0xc423e
callq 0x8f070
movq %rax, %rdi
callq 0x8e950
xorl %edi, %edi
callq 0x131b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: testBGL(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>, unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>&)
std::vector<int> testBGL (graph_t g, vertex_descriptor s, std::vector<vertex_descriptor> &p)
{
	
	// Keeps track of the predecessor of each vertex
	//std::vector<vertex_descriptor> p(num_vertices(g));
	// Keeps track of the distance to each vertex
	std::vector<int> d(num_vertices(g));



	boost::dijkstra_shortest_paths(g, s,
		predecessor_map(
	     make_iterator_property_map(p.begin(), get(vertex_index, g))).
	   distance_map(
	     make_iterator_property_map(d.begin(), get(vertex_index, g)))
	   );
	
	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
subq 0x18(%r15), %rsi
sarq $0x5, %rsi
leaq 0xd(%rsp), %rdx
callq 0x86ce
movq (%r14), %r13
movq (%rbx), %rbp
movl $0x4, %edi
callq 0x3240
movq %rax, %r14
xorl %eax, %eax
movl %eax, (%r14)
leaq 0x18(%rsp), %rdx
movq %r12, -0x8(%rdx)
leaq 0xe(%rsp), %r10
movb $0x0, (%r10)
subq $0x8, %rsp
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movq %r13, %rcx
movq %rbp, %r8
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x7fffffff             # imm = 0x7FFFFFFF
callq 0x9083
addq $0x20, %rsp
movl $0x4, %esi
movq %r14, %rdi
callq 0x3250
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x4, %esi
movq %r14, %rdi
callq 0x3250
jmp 0x3e0a
movq %rax, %r15
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e1e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3250
movq %r15, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: timed_dijkstra(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>, unsigned long)
float timed_dijkstra(graph_t g, vertex_descriptor s)
{
	predecessor_map_t p;
	auto startTime = chrono::high_resolution_clock::now();
	auto distances = dijkstra_algorithm(g, s, p);
	auto endTime = chrono::high_resolution_clock::now();

	float t = chrono::duration_cast<std::chrono::microseconds>( endTime - startTime ).count();
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
leaq 0x18(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
callq 0x3060
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq *0x102a2(%rip)          # 0x18238
callq 0x3060
subq %rbx, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
cvtsi2ss %rdx, %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8ca2
leaq 0x10(%rsp), %rdi
callq 0x8ce4
movss 0x4(%rsp), %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8ce4
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: test_DOTA(bool)
bool test_DOTA(bool TEST_DEBUG){
	//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
	if (TEST_DEBUG) std::cout<<"loading graph from BBO"<<std::endl;
	graph_t g = graph_from_file("DotaLeague/DotaLeague_Edge_Basic",true);


	//number of nodes in g
	int num_nodes = num_vertices(g);

	std::vector<vertex_descriptor> p(num_nodes);

	//get a source node...
	vertex_descriptor s = vertex(1, g);

	std::vector<int> BGL_results = testBGL ( g,  s, p);


	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
testl %edi, %edi
je 0x804f
movq 0xffbc(%rip), %rbx      # 0x17fd0
leaq 0x9187(%rip), %rsi      # 0x111a2
movl $0x16, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31a0
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x915a(%rip), %rsi      # 0x111b9
leaq 0x9173(%rip), %rdx      # 0x111d9
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x8dc4
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xf820
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x809c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3250
movq 0x70(%rsp), %rax
subq 0x68(%rsp), %rax
shrq $0x5, %rax
movslq %eax, %rsi
movq %rsp, %rdi
leaq 0x38(%rsp), %rdx
callq 0x879c
leaq 0x88(%rsp), %rdi
leaq 0x50(%rsp), %rbx
movq %rbx, %rsi
callq 0x8826
leaq 0x38(%rsp), %rdi
leaq 0x88(%rsp), %r14
movq %rsp, %rcx
movl $0x1, %edx
movq %r14, %rsi
callq 0x3d56
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x8103
movl $0x1, %esi
callq 0x3250
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
callq 0x8a42
movq -0x18(%r15), %rdi
cmpq %r14, %rdi
je 0x8131
movq (%rdi), %r15
movl $0x28, %esi
callq 0x3250
movq %r15, %rdi
cmpq %r14, %r15
jne 0x811c
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8148
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x3250
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x815e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3250
leaq 0x68(%rsp), %r14
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x8176
movl $0x1, %esi
callq 0x3250
movq %r14, %rdi
callq 0x8a42
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x819d
movq (%rdi), %r14
movl $0x28, %esi
callq 0x3250
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x8188
movb $0x1, %al
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x88c0
jmp 0x81c1
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x81dc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3250
jmp 0x81dc
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x88c0
movq %rbx, %rdi
callq 0x3400
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x81e6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3250
jmp 0x81e6
// File: /workspace/github_cpp_makefile_star2_O1/flastest[P]HeterogeneousParallelDijkstra/BGL_Dijkstra.cc
// Function: print_thread_debug(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::ostream&)
void print_thread_debug(int thread_id, std::string debug_message, ostream& output_stream)
{
	//first lock the mutex
	std::lock_guard<std::mutex> guard(print_mutex);
	//then print
	output_stream<< "thread: " << thread_id << ": " << debug_message <<std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xd4d1(%rip), %rdi      # 0x18280
callq 0x3330
testl %eax, %eax
jne 0xae36
leaq 0x7734(%rip), %rsi      # 0x124f3
movl $0x8, %edx
movq %r14, %rdi
callq 0x32a0
movq %r14, %rdi
movl %ebp, %esi
callq 0x33e0
movq %rax, %r14
leaq 0x7719(%rip), %rsi      # 0x124f9
movl $0x2, %edx
movq %rax, %rdi
callq 0x32a0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x32a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31a0
leaq 0xd453(%rip), %rdi      # 0x18280
popq %rbx
popq %r14
popq %rbp
jmp 0x31e0
movl %eax, %edi
callq 0x3180
movq %rax, %rbx
leaq 0xd439(%rip), %rdi      # 0x18280
callq 0x31e0
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x20(%rsi), %r15
subq 0x18(%rsi), %r15
shrq $0x5, %r15
testl %r15d, %r15d
jle 0xaeb7
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq %rsp, %r14
movq %r12, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8668
movl $0x7f800000, (%rax)     # imm = 0x7F800000
incq %r12
cmpq %r12, %r15
jne 0xae9a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8ca2
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x20(%rsi), %r12
subq 0x18(%rsi), %r12
shrq $0x5, %r12
testl %r12d, %r12d
jle 0xbbcd
movq %rdx, %r15
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
movq %r13, 0x10(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xdbd2
movl $0x7f800000, (%rax)     # imm = 0x7F800000
movl $0x28, %edi
callq 0x3240
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xee32
movq %r15, %rdi
movq %rbp, %rsi
callq 0xde02
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x8(%rax), %rdi
movups %xmm0, (%rax)
testq %rdi, %rdi
je 0xbb4f
callq 0xe1c2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xbb5e
callq 0xe1c2
movl $0x28, %edi
callq 0x3240
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xee32
movq %r14, %rdi
movq %rbp, %rsi
callq 0xde02
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x8(%rax), %rdi
movups %xmm0, (%rax)
testq %rdi, %rdi
je 0xbbb2
callq 0xe1c2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xbbc1
callq 0xe1c2
incq %r13
cmpq %r13, %r12
jne 0xbae5
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbbf9
jmp 0xbbe3
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xbbfc
callq 0xe1c2
jmp 0xbbfc
jmp 0xbbf9
movq %rax, %r14
movq %rbx, %rdi
callq 0x8ca2
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2dd3(%rip), %rbx      # 0x3fd8
leaq 0xdf8(%rip), %r14       # 0x2004
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
cmpq $0x0, (%rdi)
je 0x2c0d
movq %rdi, %rbx
movq 0x3403(%rip), %r14      # 0x5fd8
leaq 0x14f6(%rip), %rsi      # 0x40d2
movl $0x7, %edx
movq %r14, %rdi
callq 0x2110
movq (%rbx), %r15
testq %r15, %r15
je 0x2c55
movq %r15, %rdi
callq 0x2080
movq 0x33d8(%rip), %rdi      # 0x5fd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x2110
jmp 0x2c6d
movq 0x33c4(%rip), %rbx      # 0x5fd8
leaq 0x14bf(%rip), %rsi      # 0x40da
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2110
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq 0x3392(%rip), %rdi      # 0x5fd8
callq 0x2040
movq %rax, %rdi
callq 0x20b0
jmp 0x2cc5
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2170
movq 0x3364(%rip), %r14      # 0x5fd8
leaq 0x1454(%rip), %rsi      # 0x40cf
movl $0x2, %edx
movq %r14, %rdi
callq 0x2110
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq 0x3332(%rip), %rdi      # 0x5fd8
callq 0x2040
movq %rax, %rdi
callq 0x20b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2cc5
popq %rbx
popq %r14
popq %r15
jmp 0x2120
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x2ec3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xd, %ebp
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)
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movl %ebp, 0x4(%r14)
movl $0x7fffffff, (%r15)     # imm = 0x7FFFFFFF
movl %ebp, 0x4(%r15)
addq $0x10, %r14
xorl %eax, %eax
movq %r15, (%r14,%rax)
movl $0x7fffffff, -0x8(%r14,%rax) # imm = 0x7FFFFFFF
addq $0x10, %rax
cmpq $0x40, %rax
jne 0x12c3
incq %r12
addq $0x40, %r14
cmpq $0xd, %r12
jne 0x12c1
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x14(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
testq %r14, %r14
je 0x1324
cmpq 0x8(%rbx), %r14
je 0x1324
movq %r14, %rdi
movq 0x10(%r14), %r14
movl $0x348, %esi            # imm = 0x348
callq 0x10e0
jmp 0x1306
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1336
movl $0x348, %esi            # imm = 0x348
callq 0x10e0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1350
movl $0x348, %esi            # imm = 0x348
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq (%rdi), %r10
movl 0x4(%r10), %ecx
movl 0x2c(%rdi), %edx
movl 0x28(%rdi), %r8d
leal -0x1(%rcx), %r9d
testl %ecx, %ecx
jle 0x1411
decq %rcx
movl %ecx, %r11d
shlq $0x6, %r11
cmpl %esi, 0x38(%r10,%r11)
jge 0x13b8
movq 0x40(%r10,%r11), %rbx
movq %rbx, %r10
movq 0x40(%rbx,%r11), %rbx
cmpl $0x1, %edx
jne 0x13b1
incl %r8d
movl %r8d, 0x28(%rdi)
cmpl %esi, 0x38(%r10,%r11)
jl 0x139d
leaq 0x8(%r10), %r14
movl %r9d, %r15d
shlq $0x6, %r15
addq %r14, %r15
xorl %r12d, %r12d
movl (%r15), %ebx
decq %r12
addq $0x10, %r15
cmpl %esi, %ebx
jl 0x13c9
jne 0x13dd
movl %ecx, %eax
jmp 0x1404
cmpq $-0x1, %r12
je 0x1404
movl $0xfffffffe, %r10d      # imm = 0xFFFFFFFE
subl %r12d, %r10d
addq %r11, %r14
shlq $0x4, %r10
movq 0x8(%r10,%r14), %r10
cmpl $0x1, %edx
jne 0x1404
incl %r8d
movl %r8d, 0x28(%rdi)
decl %r9d
cmpl %esi, %ebx
jne 0x137f
jmp 0x1416
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movl %edi, %r14d
movl $0x30, %edi
callq 0x10d0
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
callq 0x1246
testl %r14d, %r14d
jle 0x1b43
xorl %r15d, %r15d
callq 0x1050
cltd
idivl %ebp
movq %rbx, %rdi
movl %edx, %esi
callq 0x194c
addl %eax, %r15d
cmpl %r14d, %r15d
jl 0x1b29
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x10e0
movq %r14, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
movq %rdi, (%rsp)
cmpq 0x8(%rdi), %r14
je 0x1ff9
leaq 0x10c2(%rip), %r12      # 0x3025
leaq 0x10b1(%rip), %r13      # 0x301b
movl (%r14), %esi
leaq 0x10a4(%rip), %rdi      # 0x3018
xorl %eax, %eax
callq 0x1040
cmpl $0x0, 0x4(%r14)
jle 0x1fdb
leaq 0x10(%r14), %rbp
xorl %ebx, %ebx
leaq 0x1092(%rip), %rdi      # 0x3021
xorl %eax, %eax
callq 0x1040
xorl %r15d, %r15d
cmpl $0x7fffffff, -0x8(%rbp,%r15) # imm = 0x7FFFFFFF
jne 0x1fb0
movq %r12, %rdi
xorl %eax, %eax
callq 0x1040
jmp 0x1fc1
movq (%rbp,%r15), %rax
movl (%rax), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x1040
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x1f99
incq %rbx
movslq 0x4(%r14), %rax
addq $0x40, %rbp
cmpq %rax, %rbx
jl 0x1f88
leaq 0x14cf(%rip), %rdi      # 0x34b1
callq 0x1100
movq 0x10(%r14), %r14
movq (%rsp), %rax
cmpq 0x8(%rax), %r14
jne 0x1f6a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
testl %esi, %esi
jle 0x227f
movl %esi, %r14d
leaq 0xe3b(%rip), %r15       # 0x3088
xorl %ebp, %ebp
callq 0x1050
cltd
idivl %r14d
movl %edx, %r12d
movq %rbx, %rdi
movl %edx, %esi
callq 0x194c
testl %eax, %eax
je 0x2278
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1040
incl %ebp
cmpl %r14d, %ebp
jl 0x224f
jmp 0x2281
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2008
leaq 0xdfc(%rip), %rdi       # 0x308c
movl %ebp, %esi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %esi, %esi
jle 0x22c2
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x194c
addl %eax, %ebx
cmpl %ebp, %ebx
jl 0x22b0
jmp 0x22c4
xorl %ebx, %ebx
leaq 0xddd(%rip), %rdi       # 0x30a8
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %esi, %esi
jle 0x22fd
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
movl %ebx, %esi
notl %esi
addl %ebp, %esi
movq %r14, %rdi
callq 0x194c
addl %eax, %ebx
cmpl %ebp, %ebx
jl 0x22e7
jmp 0x22ff
xorl %ebx, %ebx
leaq 0xdbd(%rip), %rdi       # 0x30c3
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/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
cvtsi2sd %edi, %xmm0
callq 0x1080
divsd 0xcd8(%rip), %xmm0      # 0x3008
callq 0x1120
addsd 0xcd3(%rip), %xmm0      # 0x3010
cvttsd2si %xmm0, %r15d
movl $0x30, %edi
callq 0x10d0
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1246
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
movl $0x30, %esi
movq %r14, %rdi
callq 0x10e0
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x93e(%rip), %rdi       # 0x338d
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1040
cvtsi2sd %ebx, %xmm0
callq 0x1080
divsd 0x59f(%rip), %xmm0      # 0x3008
callq 0x1120
addsd 0x59a(%rip), %xmm0      # 0x3010
cvttsd2si %xmm0, %esi
movl %ebx, %edi
callq 0x1b69
movq %rax, %r14
testl %ebx, %ebx
jle 0x2a9c
movq %r14, %rdi
movl %ebp, %esi
callq 0x1366
testl %eax, %eax
js 0x2aee
incl %ebp
cmpl %ebp, %ebx
jne 0x2a88
movq %r14, %rdi
movl $0x63, %esi
callq 0x1366
testl %eax, %eax
jns 0x2acf
leaq 0xa1c(%rip), %rdi       # 0x34d0
callq 0x1100
leaq 0x91a(%rip), %rdi       # 0x33da
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x2387
leaq 0x609(%rip), %rdi       # 0x30df
leaq 0x616(%rip), %rsi       # 0x30f3
leaq 0x8e0(%rip), %rcx       # 0x33c4
movl $0x223, %edx            # imm = 0x223
callq 0x1070
leaq 0x8bd(%rip), %rdi       # 0x33b2
leaq 0x5f7(%rip), %rsi       # 0x30f3
leaq 0x8c1(%rip), %rcx       # 0x33c4
movl $0x221, %edx            # imm = 0x221
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19b5d6(%rip), %rsi    # 0x5a3121
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x48daf0
cmpq $-0x1, %rax
je 0x407baa
leaq 0x1a6035(%rip), %r12    # 0x5adb9c
leaq 0x19b5b3(%rip), %r13    # 0x5a3121
movl $0x1, %edx
movl $0x1, %r8d
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rcx
callq 0x48d070
movq %rbx, %rdi
movq %rax, %rsi
callq 0x48bcb0
movl $0x1, %ecx
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x48daf0
cmpq $-0x1, %rax
jne 0x407b6e
leaq 0x19b570(%rip), %rsi    # 0x5a3121
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x48daf0
cmpq $-0x1, %rax
je 0x407c10
leaq 0x1a5fcf(%rip), %r12    # 0x5adb9c
leaq 0x19b54d(%rip), %r13    # 0x5a3121
movl $0x1, %edx
movl $0x1, %r8d
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rcx
callq 0x48d070
movq %r15, %rdi
movq %rax, %rsi
callq 0x48bcb0
movl $0x1, %ecx
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x48daf0
cmpq $-0x1, %rax
jne 0x407bd4
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
cmpb $0x2f, -0x1(%rax,%rsi)
je 0x407c33
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movl $0x2f, %r8d
callq 0x48c9c0
movq 0x8(%rbx), %rsi
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x48d070
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x407c67
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x407c6d
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15d
movl %esi, %r14d
movl %edi, %ebp
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
incb %bpl
cmpb $0x5, %bpl
je 0x40a072
leal (,%r15,4), %r12d
imulq %rcx, %r12
shrq $0x23, %r12
movl %r14d, %r13d
subl %r12d, %r13d
jae 0x409fe9
movq %rbx, %rdi
leaq 0x1afe56(%rip), %rsi    # 0x5b9e2d
callq 0x48d830
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
incb %bpl
movl %r12d, %r15d
jmp 0x409fab
leal (,%r15,8), %eax
subl %r15d, %eax
imulq %rcx, %rax
shrq $0x23, %rax
movl %r14d, %edx
subl %eax, %edx
jae 0x40a028
movq %rbx, %rdi
leaq 0x1afe81(%rip), %rsi    # 0x5b9e8e
callq 0x48d830
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
leal (%r15,%r15,2), %r15d
imulq %rcx, %r15
shrq $0x23, %r15
movl %r13d, %r14d
jmp 0x409fa8
leal (%r15,%r15,8), %eax
imulq %rcx, %rax
shrq $0x23, %rax
subl %eax, %r14d
movl $0xcccccccd, %r12d      # imm = 0xCCCCCCCD
movq %rbx, %rdi
jae 0x40a056
leaq 0x1ae4a1(%rip), %rsi    # 0x5b84ea
movl %edx, %r14d
callq 0x48d830
addl %r15d, %r15d
jmp 0x40a065
leaq 0x1afdd8(%rip), %rsi    # 0x5b9e35
callq 0x48d830
movl %r15d, %r15d
imulq %r12, %r15
shrq $0x23, %r15
jmp 0x409fa3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a126
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 0x1991c0(%rip), %rcx    # 0x5a3268
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1afd75(%rip), %rsi    # 0x5b9e2d
jmp 0x40a0d3
leaq 0x1ae429(%rip), %rsi    # 0x5b84ea
jmp 0x40a0d3
leaq 0x1afd6b(%rip), %rsi    # 0x5b9e35
jmp 0x40a0d3
leaq 0x1afdbb(%rip), %rsi    # 0x5b9e8e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40b0e6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x48c0d0
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x40a108
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41b3a0
incb %r14b
shrl $0x2, %ebp
movzbl %r14b, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x40a081
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19858f(%rip), %rdi    # 0x5a33c9
callq 0x4eea20
movq 0x21189a(%rip), %rax    # 0x61c6e0
cmpq %rbx, %rax
jae 0x40aec8
movq %rbx, %xmm0
punpckldq 0x198428(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x198430(%rip), %xmm0   # 0x5a3290
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
leaq 0x19852e(%rip), %r14    # 0x5a33a6
cmpw $0x0, 0x21185a(%rip)    # 0x61c6da
jne 0x40aec8
movsd 0x211856(%rip), %xmm1   # 0x61c6e0
unpcklps 0x1983ef(%rip), %xmm1   # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1983f7(%rip), %xmm1   # 0x5a3290
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x1983b3(%rip), %xmm0   # 0x5a3260
divsd (%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4e72c0
movq 0x21181d(%rip), %rax    # 0x61c6e0
cmpq %rbx, %rax
jb 0x40ae78
cmpw $0x0, 0x21180a(%rip)    # 0x61c6da
je 0x40aeda
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1984d6(%rip), %rdi    # 0x5a33b7
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4e72c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x193572(%rip), %rdi    # 0x5a3580
callq 0x4eea20
movq 0x20c6fe(%rip), %rax    # 0x61c718
cmpq %rbx, %rax
jae 0x410092
movq %rbx, %xmm0
punpckldq 0x193254(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x19325c(%rip), %xmm0   # 0x5a3290
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
leaq 0x19335a(%rip), %r14    # 0x5a33a6
movsd 0x20c6c4(%rip), %xmm1   # 0x61c718
unpcklps 0x193225(%rip), %xmm1   # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x19322d(%rip), %xmm1   # 0x5a3290
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x1931e9(%rip), %xmm0   # 0x5a3260
divsd (%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4e72c0
movq 0x20c68b(%rip), %rax    # 0x61c718
cmpq %rbx, %rax
jb 0x41004c
leaq 0x19331e(%rip), %rdi    # 0x5a33b7
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4e72c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %edx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%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)
testl %edx, %edx
je 0x41417e
movl %r12d, %eax
andl $0x3, %eax
movb $0x4, %cl
subb %al, %cl
testl %eax, %eax
movzbl %cl, %ecx
cmovel %eax, %ecx
movb %cl, 0x1c(%rsp)
movzbl %cl, %r13d
addl %r12d, %r13d
movl %r13d, %eax
andl $0x1f, %eax
shrl $0x5, %r13d
cmpl $0x1, %eax
sbbl $-0x1, %r13d
movl %r13d, 0x20(%rsp)
shll $0x3, %r13d
movq %r13, %rdi
callq 0x41c2a0
movq %rax, 0x10(%rsp)
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x401098
jmp 0x414194
movq $0x0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movb $0x0, 0x1c(%rsp)
movl %r12d, 0x18(%rsp)
testl %ebp, %ebp
je 0x4141e3
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x41444e
movl $0x0, 0xc(%rsp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x4141d4
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x4141df
movq %r15, %rdi
movq %r13, %rdx
callq 0x4147ce
decl %ebp
jne 0x4141a7
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x41444e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4141ff
callq 0x41b3b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x414229
jmp 0x414217
jmp 0x414217
movq %rax, %r12
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x414229
callq 0x41b3b0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x41423d
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x41b3a0
movq %r14, %rdi
callq 0x414478
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x414259
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x41b3a0
movq %r12, %rdi
callq 0x4c0230
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movl 0x18(%rdi), %eax
addl %esi, %eax
cmpl $0x2, %eax
movq %rdi, -0x8(%rsp)
jb 0x4143cc
movq (%rdi), %r13
movq 0x20(%rdi), %rdi
movq %r13, -0x10(%rsp)
movq %rdi, -0x18(%rsp)
movl %eax, %r8d
shrl %eax
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,8), %r10
movl (%r13,%rax,4), %r9d
leaq (%r9,%r9,2), %rcx
leaq (%rdi,%rcx,8), %r11
movl 0x8(%r11), %ebx
movl 0x8(%r10), %ebp
cmpl %ebp, %ebx
jne 0x414323
movl 0x10(%r10), %r14d
testq %r14, %r14
setne %r15b
je 0x41436e
movq (%r11), %r13
movq (%r10), %rcx
movq (%r13), %rdx
movq (%rcx), %rdi
movb $0x1, %r15b
cmpq %rdi, %rdx
jbe 0x414329
movb $0x1, %r12b
jmp 0x414364
seta %r15b
jmp 0x414371
jae 0x414330
xorl %r12d, %r12d
jmp 0x414364
movl $0x1, %r12d
movq %r12, %r15
cmpq %r15, %r14
je 0x41435d
movq (%r13,%r15,8), %rdi
movq (%rcx,%r15,8), %rdx
cmpq %rdx, %rdi
ja 0x41435a
leaq 0x1(%r15), %r12
cmpq %rdx, %rdi
jae 0x414336
xorl %r12d, %r12d
jmp 0x41435d
movb $0x1, %r12b
cmpq %r14, %r15
setb %r15b
movq -0x10(%rsp), %r13
movq -0x18(%rsp), %rdi
andb %r12b, %r15b
testb %r15b, %r15b
jne 0x4143c2
cmpl %ebp, %ebx
jne 0x4143ba
movl 0x10(%r10), %ebx
testq %rbx, %rbx
sete %cl
je 0x4143b6
movq (%r11), %rcx
movq (%r10), %r10
movq (%rcx), %rdx
cmpq (%r10), %rdx
jne 0x4143ba
movl $0x1, %r14d
movq %r14, %r11
cmpq %r14, %rbx
je 0x4143b0
movq (%rcx,%r11,8), %rdx
leaq 0x1(%r11), %r14
cmpq (%r10,%r11,8), %rdx
je 0x41439a
cmpq %rbx, %r11
setae %cl
testb %cl, %cl
jne 0x4143c2
movl %esi, (%r13,%rax,4)
movl %r9d, %esi
cmpl $0x3, %r8d
ja 0x4142d4
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl %esi, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movl %edi, %ebp
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18ee09(%rip), %rsi    # 0x5a3814
leaq 0x18ee0b(%rip), %rdx    # 0x5a381d
leaq 0x8(%rsp), %rdi
callq 0x4080ee
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x18edf2(%rip), %rsi    # 0x5a381e
leaq 0x18edf1(%rip), %rdx    # 0x5a3824
leaq 0x28(%rsp), %rdi
callq 0x4080ee
cmpl $0x2, %ebp
setge %bl
jl 0x414a95
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x48e290
testl %eax, %eax
je 0x414a95
movl %ebp, %ebp
movl $0x2, %r13d
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq -0x8(%r14,%r13,8), %rsi
movq %r15, %rdi
callq 0x48e290
testl %eax, %eax
je 0x414a95
cmpq %rbp, %r13
setb %bl
je 0x414a95
movq (%r14,%r13,8), %rsi
movq %r12, %rdi
callq 0x48e290
incq %r13
testl %eax, %eax
jne 0x414a69
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x414ab1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x41b3a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x414acd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41b3a0
andb $0x1, %bl
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x414afb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41b3a0
movq %rbx, %rdi
callq 0x4c0230
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20668c(%rip), %rdi    # 0x61c920
movl $0x5, %esi
callq 0x416306
leaq 0x20767b(%rip), %rdi    # 0x61d920
movl $0x6, %esi
callq 0x416306
leaq 0x20b66a(%rip), %rdi    # 0x621920
movl $0x7, %esi
callq 0x416306
leaq 0x21b659(%rip), %rdi    # 0x631920
movl $0x8, %esi
callq 0x416306
leaq 0x25b648(%rip), %rdi    # 0x671920
movl $0x9, %esi
callq 0x416306
leaq 0x35b637(%rip), %rdi    # 0x771920
movl $0xa, %esi
callq 0x416306
leaq 0x75b626(%rip), %rdi    # 0xb71920
movl $0xb, %esi
popq %rax
jmp 0x416306
nop