LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/graph.cpp
// Function: Graph::create_graph(std::unordered_map<unsigned int, Node*, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, Node*>>>&, std::unordered_map<unsigned int, std::set<std::pair<unsigned int, float>, comp_pair, std::allocator<std::pair<unsigned int, float>>>, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, std::set<std::pair<unsigned int, float>, comp_pair, std::allocator<std::pair<unsigned int, float>>>>>>&)
void Graph::create_graph(unordered_map<unsigned int, Node*>& map_node, unordered_map<unsigned int, set<pair<unsigned int, float>, comp_pair>>& map_neighbor)
{
	Node* node;
	unsigned int index;

	n = map_node.size();
	for(auto& e : map_neighbor)
		m += e.second.size();

	list_nodes = new Node*[n];
	
	index = 0;
	for(auto& e : map_node)
	{
		node = e.second;
		node->nb_neighbors = map_neighbor[e.first].size();
		
		node->index = index;
		if(node->main_index == -1)
			node->main_index = index;
		
		list_nodes[index] = node;
		index++;
		
		for(auto& d : map_neighbor[e.first])
			node->neighbor_weights[map_node[d.first]] = d.second;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movl %eax, (%rdi)
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x428d
movl 0x4(%rbx), %edx
addl 0x38(%rcx), %edx
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x427f
movl %edx, 0x4(%rbx)
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2030
movq %rbx, 0x10(%rsp)
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x435e
xorl %ebx, %ebx
movq %rbp, 0x8(%rsp)
leaq 0x8(%r15), %r13
movq 0x10(%r15), %r12
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4ffa
movl 0x28(%rax), %eax
movl %eax, 0x28(%r12)
movl %ebx, (%r12)
cmpl $-0x1, 0x4(%r12)
jne 0x42e1
movl %ebx, 0x4(%r12)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl %ebx, %ecx
movq %r12, (%rax,%rcx,8)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4ffa
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0x434b
addq $0x30, %r12
leaq 0x20(%rbp), %rsi
movss 0x24(%rbp), %xmm0
movss %xmm0, 0x4(%rsp)
movq %r14, %rdi
callq 0x4654
movq %r12, %rdi
movq %rax, %rsi
callq 0x50cc
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbp, %rdi
callq 0x2290
movq %rax, %rbp
cmpq %r13, %rax
jne 0x430f
incl %ebx
movq (%r15), %r15
testq %r15, %r15
movq 0x8(%rsp), %rbp
jne 0x42b5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: projection_main_thread(void*)
void* projection_main_thread(void* main_struct_args)
{
	projection_thread_args* main_args = static_cast<projection_thread_args*>(main_struct_args);

	pthread_t thread;
	unsigned int index;

	projection_thread_args args;
	args.p = main_args->p;
	args.map_node = main_args->map_node;
	args.map_neighbor = main_args->map_neighbor;
	args.distance = main_args->distance;

	pthread_mutex_lock(&projection_main_mutex);
	if(main_args->index == main_args->p->in_graph->n)
	{
		pthread_mutex_unlock(&projection_main_mutex);
		return NULL;
	}
	pthread_mutex_unlock(&projection_main_mutex);

	do
	{
		pthread_mutex_lock(&projection_main_mutex);
		args.index = main_args->index;
		main_args->index++;
		pthread_mutex_unlock(&projection_main_mutex);

		pthread_create(&thread, NULL, &compute_projection_thread, &args);
		pthread_join(thread, NULL);

		pthread_mutex_lock(&projection_main_mutex);
		index = main_args->index;
		pthread_mutex_unlock(&projection_main_mutex);

	} while(index < main_args->p->in_graph->n);

	pthread_exit(NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x18(%rsp)
movl 0xc(%rdi), %eax
movl %eax, 0x14(%rsp)
leaq 0x9e7b(%rip), %r14      # 0xf280
movq %r14, %rdi
callq 0x2340
movl 0x8(%rbx), %ebp
movq (%rbx), %rax
movq 0x10(%rax), %rax
movl (%rax), %r15d
movq %r14, %rdi
callq 0x21b0
cmpl %r15d, %ebp
jne 0x5438
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9e41(%rip), %r14      # 0xf280
leaq 0x64(%rip), %r15        # 0x54aa
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %r14, %rdi
callq 0x2340
movl 0x8(%rbx), %eax
movl %eax, 0x10(%rsp)
incl %eax
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x21b0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r13, %rcx
callq 0x2410
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2200
movq %r14, %rdi
callq 0x2340
movl 0x8(%rbx), %ebp
movq %r14, %rdi
callq 0x21b0
movq (%rbx), %rax
movq 0x10(%rax), %rax
cmpl (%rax), %ebp
jb 0x544e
xorl %edi, %edi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: Projection::project(unsigned int)
void Projection::project(unsigned int distance)
{
	unordered_map<unsigned int, Node*> map_node;
	unordered_map<unsigned int, set<pair<unsigned int, float>, comp_pair>> map_neighbor;

	pthread_t threads[nb_threads];
	projection_thread_args main_args;
	main_args.index = 0;
	main_args.p = this;
	main_args.map_node = &map_node;
	main_args.map_neighbor = &map_neighbor;
	main_args.distance = distance;

	unsigned int i;
	for(i=0; i<nb_threads; i++)
		pthread_create(&threads[i], NULL, &projection_main_thread, &main_args);

	for(i=0; i<nb_threads; i++)
		pthread_join(threads[i], NULL);

	graph_projection->create_graph(map_node, map_neighbor);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq %rsp, %r15
leaq -0x98(%rbp), %rax
movq %rax, -0x30(%rax)
movl $0x1, %ecx
movq %rcx, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %edx       # imm = 0x3F800000
movl %edx, -0x10(%rax)
movups %xmm0, -0x8(%rax)
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rax)
movq %rcx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl %edx, -0x10(%rax)
movups %xmm0, -0x8(%rax)
movl 0x8(%rdi), %eax
movq %rsp, %r12
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movl $0x0, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
leaq -0xc8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movl %esi, -0x4c(%rbp)
cmpl $0x0, 0x8(%rdi)
je 0x5a64
movq %r15, -0x38(%rbp)
xorl %r13d, %r13d
leaq -0x643(%rip), %r14      # 0x53d5
leaq -0x58(%rbp), %r15
movq %r12, -0x30(%rbp)
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2410
incq %r13
movl 0x8(%rbx), %eax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x5a20
testl %eax, %eax
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %r12
je 0x5a64
xorl %r14d, %r14d
movq (%r12,%r14,8), %rdi
xorl %esi, %esi
callq 0x2200
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x5a4e
movq 0x18(%rbx), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4256
movq %r15, %rsp
leaq -0x90(%rbp), %rdi
callq 0x436e
leaq -0xc8(%rbp), %rdi
callq 0x4444
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5aa7
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x436e
leaq -0xc8(%rbp), %rdi
callq 0x4444
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: CommonNeighbors::similarity_projection(Node*&, Node*&)
float CommonNeighbors::similarity_projection(Node*& node1, Node*& node2)
{
	set<Node*> intersection = get_intersection(node1, node2);

	float projection_weight = 0.0;

	for(auto& neighbor : node1->neighbor_weights)
	{
		if(intersection.find(neighbor.first) != intersection.end())
		{
			projection_weight += node1->neighbor_weights[neighbor.first];
		}
	}
	for(auto& neighbor : node2->neighbor_weights)
	{
		if(intersection.find(neighbor.first) != intersection.end())
		{
			projection_weight += node2->neighbor_weights[neighbor.first];
		}
	}

	return projection_weight;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rdi
movq %rsi, %rdx
movq %rbx, %rcx
callq 0x5aca
movq (%r14), %rax
movq 0x40(%rax), %r15
xorps %xmm0, %xmm0
testq %r15, %r15
je 0x5d8c
leaq 0x10(%rsp), %r12
movq 0x18(%rsp), %r8
testq %r8, %r8
je 0x5d84
leaq 0x8(%r15), %rsi
movq (%rsi), %rax
movq %r12, %r9
movq %r9, %rcx
movq %r8, %rdx
movq 0x20(%r8), %rdi
xorl %r8d, %r8d
cmpq %rax, %rdi
setb %r8b
movq %rdx, %r9
cmovbq %rcx, %r9
movq 0x10(%rdx,%r8,8), %r8
testq %r8, %r8
jne 0x5d31
cmpq %r12, %r9
je 0x5d84
cmpq %rax, %rdi
cmovbq %rcx, %rdx
cmpq 0x20(%rdx), %rax
jb 0x5d84
movss %xmm0, 0x4(%rsp)
movq (%r14), %rdi
addq $0x30, %rdi
callq 0x50cc
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movq (%r15), %r15
testq %r15, %r15
jne 0x5d1d
movss %xmm0, 0x4(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %r14
testq %r14, %r14
je 0x5e12
leaq 0x10(%rsp), %r15
movq 0x18(%rsp), %r8
testq %r8, %r8
je 0x5e0a
leaq 0x8(%r14), %rsi
movq (%rsi), %rax
movq %r15, %r9
movq %r9, %rcx
movq %r8, %rdx
movq 0x20(%r8), %rdi
xorl %r8d, %r8d
cmpq %rax, %rdi
setb %r8b
movq %rdx, %r9
cmovbq %rcx, %r9
movq 0x10(%rdx,%r8,8), %r8
testq %r8, %r8
jne 0x5db7
cmpq %r15, %r9
je 0x5e0a
cmpq %rax, %rdi
cmovbq %rcx, %rdx
cmpq 0x20(%rdx), %rax
jb 0x5e0a
movq (%rbx), %rdi
addq $0x30, %rdi
callq 0x50cc
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r14), %r14
testq %r14, %r14
jne 0x5da3
leaq 0x8(%rsp), %rdi
callq 0x64ee
movss 0x4(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5e30
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x64ee
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: JaccardIndex::similarity_projection(Node*&, Node*&)
float JaccardIndex::similarity_projection(Node*& node1, Node*& node2)
{
	set<Node*> intersection = get_intersection(node1, node2);

	float projection_weight, sum_weight, wtemp;
	projection_weight = sum_weight = 0.0;

	for(auto& neighbor : node1->neighbor_weights)
	{
		wtemp = node1->neighbor_weights[neighbor.first];
		if(intersection.find(neighbor.first) != intersection.end())
		{
			projection_weight += wtemp;
		}

		sum_weight += wtemp;
	}
	for(auto& neighbor : node2->neighbor_weights)
	{
		wtemp = node2->neighbor_weights[neighbor.first];
		if(intersection.find(neighbor.first) != intersection.end())
		{
			projection_weight += wtemp;
		}

		sum_weight += wtemp;
	}

	return 1.0 * projection_weight / sum_weight;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %rdi
movq %rsi, %rdx
movq %rbx, %rcx
callq 0x5aca
movq (%r14), %rax
movq 0x40(%rax), %r12
testq %r12, %r12
je 0x5f3e
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %r13
xorps %xmm1, %xmm1
movss %xmm1, 0xc(%rsp)
leaq 0x8(%r12), %r15
movq (%r14), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x50cc
movq 0x20(%rsp), %r9
movq %r13, %r10
testq %r9, %r9
je 0x5f0c
movq (%r15), %rcx
movq %r13, %rdi
movq %rdi, %rdx
movq %r9, %rsi
movq 0x20(%r9), %r8
xorl %r9d, %r9d
cmpq %rcx, %r8
setb %r9b
movq %rsi, %rdi
cmovbq %rdx, %rdi
movq 0x10(%rsi,%r9,8), %r9
testq %r9, %r9
jne 0x5ecd
movq %r13, %r10
cmpq %r13, %rdi
je 0x5f0c
cmpq %rcx, %r8
cmovbq %rdx, %rsi
cmpq 0x20(%rsi), %rcx
cmovbq %r13, %rdi
movq %rdi, %r10
movss (%rax), %xmm0
cmpq %r13, %r10
je 0x5f25
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movq (%r12), %r12
testq %r12, %r12
jne 0x5ea0
jmp 0x5f4a
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %r15
testq %r15, %r15
je 0x5ff9
leaq 0x18(%rsp), %r12
movss %xmm1, 0xc(%rsp)
leaq 0x8(%r15), %r14
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r14, %rsi
callq 0x50cc
movq 0x20(%rsp), %r9
movq %r12, %r10
testq %r9, %r9
je 0x5fca
movq (%r14), %rcx
movq %r12, %rdi
movq %rdi, %rdx
movq %r9, %rsi
movq 0x20(%r9), %r8
xorl %r9d, %r9d
cmpq %rcx, %r8
setb %r9b
movq %rsi, %rdi
cmovbq %rdx, %rdi
movq 0x10(%rsi,%r9,8), %r9
testq %r9, %r9
jne 0x5f8b
movq %r12, %r10
cmpq %r12, %rdi
je 0x5fca
cmpq %rcx, %r8
cmovbq %rdx, %rsi
cmpq 0x20(%rsi), %rcx
cmovbq %r12, %rdi
movq %rdi, %r10
movss (%rax), %xmm0
cmpq %r12, %r10
je 0x5fe3
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movq (%r15), %r15
testq %r15, %r15
jne 0x5f5f
movss 0x8(%rsp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x64ee
movss 0x8(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6029
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x64ee
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: AdamicAdar::similarity_projection(Node*&, Node*&)
float AdamicAdar::similarity_projection(Node*& node1, Node*& node2)
{
	set<Node*> intersection = get_intersection(node1, node2);

	float projection_weight, sum_weight;
	projection_weight = 0.0;

	for(auto& neighbor : intersection)
	{
		sum_weight = 0.0;
		for(auto& w : neighbor->neighbor_weights)
			sum_weight += w.second;
		projection_weight += 1.0 / log2(sum_weight);
	}

	return projection_weight;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5aca
movq 0x18(%rbx), %rbx
leaq 0x10(%rsp), %r14
xorps %xmm0, %xmm0
cmpq %r14, %rbx
je 0x60dd
movss %xmm0, 0x4(%rsp)
movq 0x20(%rbx), %rax
movq 0x40(%rax), %rax
xorps %xmm0, %xmm0
testq %rax, %rax
je 0x609f
addss 0x10(%rax), %xmm0
movq (%rax), %rax
jmp 0x6090
callq 0x22d0
cvtss2sd %xmm0, %xmm0
movsd 0x4830(%rip), %xmm1     # 0xa8e0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
callq 0x2290
movq %rax, %rbx
cmpq %r14, %rax
jne 0x6085
jmp 0x60e3
movss %xmm0, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x64ee
movss 0x4(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: ResourceAllocator::similarity_projection(Node*&, Node*&)
float ResourceAllocator::similarity_projection(Node*& node1, Node*& node2)
{
	set<Node*> intersection = get_intersection(node1, node2);

	float projection_weight, sum_weight;
	projection_weight = 0.0;

	for(auto& neighbor : intersection)
	{
		sum_weight = 0.0;
		for(auto& w : neighbor->neighbor_weights)
			sum_weight += w.second;
		projection_weight += 1.0 / sum_weight;
	}

	return projection_weight;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5aca
movq 0x18(%rbx), %rax
leaq 0x18(%rsp), %rbx
xorps %xmm0, %xmm0
cmpq %rbx, %rax
je 0x6199
movss %xmm0, 0xc(%rsp)
movq 0x20(%rax), %rcx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
je 0x6164
xorps %xmm0, %xmm0
addss 0x10(%rcx), %xmm0
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x6151
cvtss2sd %xmm0, %xmm0
jmp 0x6167
xorps %xmm0, %xmm0
movsd 0x4771(%rip), %xmm1     # 0xa8e0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rax, %rdi
callq 0x2290
cmpq %rbx, %rax
jne 0x6141
jmp 0x619f
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x64ee
movss 0xc(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: LHN1::similarity_projection(Node*&, Node*&)
float LHN1::similarity_projection(Node*& node1, Node*& node2)
{
	set<Node*> intersection = get_intersection(node1, node2);

	float projection_weight, sum_weight1, sum_weight2, wtemp;
	projection_weight = sum_weight1 = sum_weight2 = 0.0;

	for(auto& neighbor : node1->neighbor_weights)
	{
		wtemp = node1->neighbor_weights[neighbor.first];
		if(intersection.find(neighbor.first) != intersection.end())
		{
			projection_weight += wtemp;
		}

		sum_weight1 += wtemp;
	}
	for(auto& neighbor : node2->neighbor_weights)
	{
		wtemp = node2->neighbor_weights[neighbor.first];
		if(intersection.find(neighbor.first) != intersection.end())
		{
			projection_weight += wtemp;
		}

		sum_weight2 += wtemp;
	}

	return 1.0 * projection_weight / (sum_weight1 * sum_weight2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %rdi
movq %rsi, %rdx
movq %rbx, %rcx
callq 0x5aca
movq (%r14), %rax
movq 0x40(%rax), %r12
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
testq %r12, %r12
je 0x62b2
movss %xmm0, 0x4(%rsp)
leaq 0x18(%rsp), %r13
movss %xmm1, 0x8(%rsp)
leaq 0x8(%r12), %r15
movq (%r14), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x50cc
movq 0x20(%rsp), %r9
movq %r13, %r10
testq %r9, %r9
je 0x6282
movq (%r15), %rcx
movq %r13, %rdi
movq %rdi, %rdx
movq %r9, %rsi
movq 0x20(%r9), %r8
xorl %r9d, %r9d
cmpq %rcx, %r8
setb %r9b
movq %rsi, %rdi
cmovbq %rdx, %rdi
movq 0x10(%rsi,%r9,8), %r9
testq %r9, %r9
jne 0x6243
movq %r13, %r10
cmpq %r13, %rdi
je 0x6282
cmpq %rcx, %r8
cmovbq %rdx, %rsi
cmpq 0x20(%rsi), %rcx
cmovbq %r13, %rdi
movq %rdi, %r10
movss (%rax), %xmm0
cmpq %r13, %r10
je 0x629b
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movq (%r12), %r12
testq %r12, %r12
jne 0x6216
movss %xmm1, 0x8(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %r15
xorps %xmm0, %xmm0
testq %r15, %r15
je 0x636d
leaq 0x18(%rsp), %r12
movss %xmm0, 0xc(%rsp)
leaq 0x8(%r15), %r14
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r14, %rsi
callq 0x50cc
movq 0x20(%rsp), %r9
movq %r12, %r10
testq %r9, %r9
je 0x633b
movq (%r14), %rcx
movq %r12, %rdi
movq %rdi, %rdx
movq %r9, %rsi
movq 0x20(%r9), %r8
xorl %r9d, %r9d
cmpq %rcx, %r8
setb %r9b
movq %rsi, %rdi
cmovbq %rdx, %rdi
movq 0x10(%rsi,%r9,8), %r9
testq %r9, %r9
jne 0x62fc
movq %r12, %r10
cmpq %r12, %rdi
je 0x633b
cmpq %rcx, %r8
cmovbq %rdx, %rsi
cmpq 0x20(%rsi), %rcx
cmovbq %r12, %rdi
movq %rdi, %r10
movss (%rax), %xmm0
cmpq %r12, %r10
je 0x6354
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
movq (%r15), %r15
testq %r15, %r15
jne 0x62d0
movss 0x8(%rsp), %xmm1
mulss %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x64ee
movss 0x4(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x63a7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x64ee
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/projection.cpp
// Function: PA_Neighbor::similarity_projection(Node*&, Node*&)
float PA_Neighbor::similarity_projection(Node*& node1, Node*& node2)
{
	set<Node*> intersection = get_intersection(node1, node2);

	float projection_weight, sum_weight;
	projection_weight = 1.0;

	for(auto& neighbor : intersection)
	{
		sum_weight = 0.0;
		for(auto& w : neighbor->neighbor_weights)
			sum_weight += w.second;
		projection_weight *= sum_weight;
	}

	return projection_weight;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5aca
movq 0x18(%rbx), %rax
leaq 0x18(%rsp), %rbx
movss 0x44c5(%rip), %xmm0     # 0xa8c0
cmpq %rbx, %rax
je 0x643f
movss %xmm0, 0xc(%rsp)
movq 0x20(%rax), %rcx
movq 0x40(%rcx), %rcx
xorps %xmm0, %xmm0
testq %rcx, %rcx
je 0x6420
addss 0x10(%rcx), %xmm0
movq (%rcx), %rcx
jmp 0x6411
movss 0xc(%rsp), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movq %rax, %rdi
callq 0x2290
cmpq %rbx, %rax
jne 0x6406
jmp 0x6445
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x64ee
movss 0xc(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rtackx[P]ComSim/community.cpp
// Function: Community::detect(Graph*&)
unsigned int Community::detect(Graph*& graph_projection)
{	
	vector<unsigned int> list_index_nodes, list_ending_nodes;
	unordered_set<unsigned int> list_remaining_nodes;
	unsigned int index = 0;
	
	while(index < graph_projection->n)
	{
		if(graph_projection->list_nodes[index]->nb_neighbors == 0)
			list_ending_nodes.push_back(graph_projection->list_nodes[index]->main_index);
		else
			list_index_nodes.push_back(index);

		index++;
	}
	
	if(list_index_nodes.size() > 0)
	{
 		cycles(graph_projection, list_index_nodes, list_remaining_nodes);
		aggregate(graph_projection, list_remaining_nodes);
	}
	
	save_communities(graph_projection);

	return list_remaining_nodes.size() + list_ending_nodes.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0x80(%rsp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
movl $0x0, 0x8(%rsp)
movq (%rsi), %rcx
cmpl $0x0, (%rcx)
je 0x74c4
leaq 0x30(%rsp), %r15
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq 0x8(%rcx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rcx
cmpl $0x0, 0x28(%rcx)
je 0x744a
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x746a
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x7482
movl 0x4(%rcx), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rsi
cmpq 0x40(%rsp), %rsi
je 0x7477
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rsp)
jmp 0x7482
movq %r13, %rdi
movq %rbp, %rdx
callq 0x8310
jmp 0x7482
movq %r15, %rdi
movq %r12, %rdx
callq 0x81dc
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
movq (%rbx), %rcx
cmpl (%rcx), %eax
jb 0x7421
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x74c4
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x755a
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7ac4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7f00
leaq 0x50(%rsp), %rdi
movq 0x18(%rdi), %rbx
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %r14
callq 0x80b6
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x74f6
callq 0x2220
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7505
callq 0x2220
subq %r15, %r14
shrq $0x2, %r14
addl %r14d, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7527
jmp 0x7527
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x80b6
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x7543
callq 0x2220
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7552
callq 0x2220
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: HttpSender::status(char const*)
HttpSender *HttpSender::status(const char *status) {
    conn->send_buffer.resize(256);
    conn->send_buffer.add("HTTP/1.1 ");
    conn->send_buffer.add(status);
    conn->send_buffer.add("\r\n");
    if(conn->keep_alive) {
        conn->send_buffer.add("Connection: keep-alive\r\n");
    }
    return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x20, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xc596
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xd84d(%rip), %rsi      # 0x1773f
callq 0xc44c
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xc44c
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xd807(%rip), %rsi      # 0x1771b
callq 0xc44c
movq (%rbx), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0x9f32
addq $0x20, %rdi
leaq 0xd81c(%rip), %rsi      # 0x17749
callq 0xc44c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: HttpSender::done(int)
void HttpSender::done(int error) {
    if(!conn->server->jsonrpc2) done();
    else {
        Slice msg;
        if(error == -32700) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32700, \"message\": \"Parse error\"}, \"id\": null}");
        else if(error == -32600) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32600, \"message\": \"Invalid Request\"}, \"id\": null}");
        else if(error == -32601) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32601, \"message\": \"Method not found\"}, \"id\": null}");
        else if(error == -32602) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32602, \"message\": \"Invalid params\"}, \"id\": null}");
        else if(error == -1) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32001, \"message\": \"Error, see http code\"}, \"id\": null}");
        else if(error == 1) msg.set("{\"jsonrpc\": \"2.0\", \"result\": true, \"id\": null}");
        else msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32603, \"message\": \"Internal error\"}, \"id\": null}");
        done(msg);
    }
}

// Assembly:
movq (%rdi), %rax
movq 0x48(%rax), %rax
cmpb $0x0, 0x2c(%rax)
je 0xa864
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0xffff80a7, %esi       # imm = 0xFFFF80A7
jg 0x9f85
cmpl $0xffff8044, %esi       # imm = 0xFFFF8044
je 0x9fa9
cmpl $0xffff80a6, %esi       # imm = 0xFFFF80A6
je 0x9fd6
cmpl $0xffff80a7, %esi       # imm = 0xFFFF80A7
jne 0x9fcd
leaq 0xd8ec(%rip), %rax      # 0x17866
movq %rax, -0x10(%rbp)
movl $0x58, %eax
jmp 0x9ff8
cmpl $0xffff80a8, %esi       # imm = 0xFFFF80A8
je 0x9fbb
cmpl $-0x1, %esi
je 0x9fe8
cmpl $0x1, %esi
jne 0x9fcd
leaq 0xd9d5(%rip), %rax      # 0x17973
movq %rax, -0x10(%rbp)
movl $0x2e, %eax
jmp 0x9ff8
leaq 0xd80a(%rip), %rax      # 0x177ba
movq %rax, -0x10(%rbp)
movl $0x53, %eax
jmp 0x9ff8
leaq 0xd84c(%rip), %rax      # 0x1780e
movq %rax, -0x10(%rbp)
movl $0x57, %eax
jmp 0x9ff8
leaq 0xd9ce(%rip), %rax      # 0x179a2
jmp 0x9fdd
leaq 0xd8e2(%rip), %rax      # 0x178bf
movq %rax, -0x10(%rbp)
movl $0x56, %eax
jmp 0x9ff8
leaq 0xd927(%rip), %rax      # 0x17916
movq %rax, -0x10(%rbp)
movl $0x5c, %eax
leaq -0x10(%rbp), %rsi
movl %eax, 0x8(%rsi)
callq 0xa766
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: Connect::read_method(Slice&)
int Connect::read_method(Slice &line) {
    int start = 0;
    char *buf = line.ptr();
    int part = 0;
    int i = 0;
    path.clear();
    for(;i<line.size();i++) {
        if(buf[i] != ' ') continue;

        if(part == 1) {
            if(i>start+1 && buf[start] == '/') start++;
            path.set(&buf[start], i - start);
            break;
        }
        start = i + 1;
        part++;
    }
    if(buf[line.size() - 1] == '1') http_version = 11;
    else http_version = 10;

    if(path.empty()) return -1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r15
movl $0x0, 0xa0(%rdi)
movslq 0x8(%rsi), %rax
testq %rax, %rax
jle 0xa085
movq %rsi, %r14
leaq 0x98(%rbx), %rdi
xorl %edx, %edx
xorl %esi, %esi
xorl %ecx, %ecx
cmpb $0x20, (%r15,%rdx)
jne 0xa055
cmpl $0x1, %esi
je 0xa05f
incq %rdx
movl $0x1, %esi
movl %edx, %ecx
jmp 0xa058
incq %rdx
cmpq %rax, %rdx
jne 0xa03d
jmp 0xa085
leal 0x1(%rcx), %eax
cmpl %edx, %eax
jge 0xa073
movslq %ecx, %rsi
cmpb $0x2f, (%r15,%rsi)
cmovnel %ecx, %eax
movl %eax, %ecx
movslq %ecx, %rax
leaq (%r15,%rax), %rsi
subl %eax, %edx
callq 0xc102
movl 0x8(%r14), %eax
cltq
xorl %ecx, %ecx
cmpb $0x31, -0x1(%r15,%rax)
sete %cl
orl $0xa, %ecx
movl %ecx, 0x80(%rbx)
xorl %eax, %eax
cmpl $0x1, 0xa0(%rbx)
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: Connect::_set_type(ISlice&)
void Connect::_set_type(ISlice &name) {
    if(name == "get") {
        type = RequestType::get;
    } else if (name == "get+") {
        type = RequestType::get_plus;
    } else if (name == "worker") {
        type = RequestType::worker;
    } else if (name == "async") {
        type = RequestType::async;
    } else if (name == "pub") {
        type = RequestType::pub;
    } else if (name == "result") {
        type = RequestType::result;
    } else if (name == "create") {
        type = RequestType::create;
    } else if (name == "delete") {
        type = RequestType::del;
    } else throw error::InvalidData();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x8(%rsi), %eax
movq (%rsi), %rcx
xorl %esi, %esi
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movb $0x67, %r9b
leaq 0xcc0f(%rip), %r8       # 0x171ac
cmpq %rsi, %rdx
je 0xa5c4
cmpb (%rcx,%rsi), %r9b
jne 0xa5c4
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x3, %rsi
jne 0xa59d
movl $0x1, %esi
cmpl $0x3, %eax
je 0xa71d
movb $0x67, %r9b
xorl %esi, %esi
leaq 0xcbe0(%rip), %r8       # 0x171b0
cmpq %rsi, %rdx
je 0xa5f7
cmpb (%rcx,%rsi), %r9b
jne 0xa5f7
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x4, %rsi
jne 0xa5d0
movl $0x2, %esi
cmpl $0x4, %eax
je 0xa71d
movb $0x77, %r9b
xorl %esi, %esi
leaq 0xe0a3(%rip), %r8       # 0x186a6
cmpq %rsi, %rdx
je 0xa62a
cmpb (%rcx,%rsi), %r9b
jne 0xa62a
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x6, %rsi
jne 0xa603
movl $0x3, %esi
cmpl $0x6, %eax
je 0xa71d
movb $0x61, %r9b
xorl %esi, %esi
leaq 0xcb7f(%rip), %r8       # 0x171b5
cmpq %rsi, %rdx
je 0xa65d
cmpb (%rcx,%rsi), %r9b
jne 0xa65d
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x5, %rsi
jne 0xa636
movl $0x4, %esi
cmpl $0x5, %eax
je 0xa71d
movb $0x70, %r9b
xorl %esi, %esi
leaq 0xcb52(%rip), %r8       # 0x171bb
cmpq %rsi, %rdx
je 0xa690
cmpb (%rcx,%rsi), %r9b
jne 0xa690
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x3, %rsi
jne 0xa669
movl $0x5, %esi
cmpl $0x3, %eax
je 0xa71d
movb $0x72, %r9b
xorl %esi, %esi
leaq 0xcbd2(%rip), %r8       # 0x1726e
cmpq %rsi, %rdx
je 0xa6bf
cmpb (%rcx,%rsi), %r9b
jne 0xa6bf
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x6, %rsi
jne 0xa69c
movl $0x6, %esi
cmpl $0x6, %eax
je 0xa71d
movb $0x63, %r9b
xorl %esi, %esi
leaq 0xcaf4(%rip), %r8       # 0x171bf
cmpq %rsi, %rdx
je 0xa6ee
cmpb (%rcx,%rsi), %r9b
jne 0xa6ee
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x6, %rsi
jne 0xa6cb
movl $0x7, %esi
cmpl $0x6, %eax
je 0xa71d
movb $0x64, %r9b
xorl %esi, %esi
leaq 0xcacc(%rip), %r8       # 0x171c6
cmpq %rsi, %rdx
je 0xa728
cmpb (%rcx,%rsi), %r9b
jne 0xa728
movb 0x1(%rsi,%r8), %r9b
incq %rsi
cmpq $0x6, %rsi
jne 0xa6fa
movl $0x8, %esi
cmpl $0x6, %eax
jne 0xa728
movl %esi, 0xc8(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc254
leaq 0x1352c(%rip), %rsi     # 0x1dc70
leaq 0x2bc5(%rip), %rdx      # 0xd310
movq %rbx, %rdi
callq 0x8480
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: HttpSender::done(ISlice&)
void HttpSender::done(ISlice &body) {
    if(conn->is_closed()) THROW("Trying to send to closed socket");

    int body_size = body.size();
    if(body_size == 0) {
        conn->send_buffer.add("Content-Length: 0\r\n\r\n");
    } else {
        conn->send_buffer.add("Content-Length: ");
        conn->send_buffer.add_number(body_size);
        conn->send_buffer.add("\r\n\r\n");
        conn->send_buffer.add(body);
    }
    conn->write_mode(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $-0x1, (%rdi)
je 0xa80c
movq %rsi, %r14
movslq 0x8(%rsi), %r15
addq $0x20, %rdi
testq %r15, %r15
je 0xa7d2
leaq 0xcf88(%rip), %rsi      # 0x1771e
callq 0xc44c
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r15, %rsi
callq 0xc35e
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xcf61(%rip), %rsi      # 0x17719
callq 0xc44c
movq (%rbx), %rdi
addq $0x20, %rdi
movq (%r14), %rsi
movl 0x8(%r14), %edx
callq 0xc102
jmp 0xa7de
leaq 0xcf2f(%rip), %rsi      # 0x17708
callq 0xc44c
movq (%rbx), %rax
movl (%rax), %ecx
testb $0x2, %cl
jne 0xa801
orl $0x2, %ecx
movl %ecx, (%rax)
movq 0x30(%rax), %rdi
addq $0x60, %rdi
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
callq 0xc7ba
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
leaq 0xcf42(%rip), %rsi      # 0x17762
leaq 0xc82a(%rip), %rdx      # 0x17051
leaq 0xcf54(%rip), %r8       # 0x17782
movq %rax, %rdi
movl $0x2eb, %ecx            # imm = 0x2EB
callq 0xcd04
leaq 0x134d6(%rip), %rsi     # 0x1dd18
leaq 0x2ac7(%rip), %rdx      # 0xd310
movq %rbx, %rdi
callq 0x8480
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: Connect::create_queue(Slice)
void Connect::create_queue(Slice name) {
    if(name.empty()) {
        this->send.status("400 Wrong queue")->done(-32600);
        return;
    }
    if(name.ptr()[0] == '/') name.remove(1);
    server->get_queue(name, true);
    this->send.status("200 OK")->done(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %edx, %edx
je 0xb29b
cmpb $0x2f, (%rsi)
jne 0xb27e
testl %edx, %edx
movl $0x1, %eax
cmovlel %edx, %eax
cltq
addq %rax, %rsi
subl %eax, %edx
movq 0x48(%rbx), %rdi
movl $0x1, %r14d
movl $0x1, %ecx
callq 0xf926
leaq 0xbfa0(%rip), %rsi      # 0x17239
jmp 0xb2a8
movl $0xffff80a8, %r14d      # imm = 0xFFFF80A8
leaq 0xc487(%rip), %rsi      # 0x1772f
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x9ec6
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x9f3a
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: Connect::delete_queue(Slice)
void Connect::delete_queue(Slice name) {
    if(name.empty()) {
        this->send.status("400 Wrong queue")->done(-32600);
        return;
    }
    if(name.ptr()[0] == '/') name.remove(1);
    server->delete_queue(name);
    this->send.status("200 OK")->done(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %edx, %edx
je 0xb300
cmpb $0x2f, (%rsi)
jne 0xb2e8
testl %edx, %edx
movl $0x1, %eax
cmovlel %edx, %eax
cltq
addq %rax, %rsi
subl %eax, %edx
movq 0x48(%rbx), %rdi
callq 0xfad6
movl $0x1, %r14d
leaq 0xbf3b(%rip), %rsi      # 0x17239
jmp 0xb30d
movl $0xffff80a8, %r14d      # imm = 0xFFFF80A8
leaq 0xc422(%rip), %rsi      # 0x1772f
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x9ec6
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x9f3a
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/connect.cpp
// Function: HttpSender::header(char const*, ISlice const&)
HttpSender *HttpSender::header(const char *key, const ISlice &value) {
    conn->send_buffer.add(key);
    conn->send_buffer.add(": ");
    conn->send_buffer.add(value);
    conn->send_buffer.add("\r\n");
    return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x20, %rdi
callq 0xc44c
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xc7a2(%rip), %rsi      # 0x18413
callq 0xc44c
movq (%rbx), %rdi
addq $0x20, %rdi
movq (%r14), %rsi
movl 0x8(%r14), %edx
callq 0xc102
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xba84(%rip), %rsi      # 0x1771b
callq 0xc44c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: Buffer::add(char const*, int)
void add(const char *buf, int size) {
        if(buf == NULL) throw error::NoData("Buffer.add buf == NULL");
        resize(_size + size);
        memmove(&_ptr[_size], buf, size);
        _size += size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc148
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %esi
addl %edx, %esi
callq 0xc596
movslq 0x8(%rbx), %rdi
addq (%rbx), %rdi
movslq %r15d, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x8440
addl %r15d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
leaq 0xb89d(%rip), %rsi      # 0x179f9
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc6a2
leaq 0x11b16(%rip), %rsi     # 0x1dc88
leaq 0x1197(%rip), %rdx      # 0xd310
movq %rbx, %rdi
callq 0x8480
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: Slice::pop_line()
Slice pop_line() {
        for(int i=0;i<size();i++) {
            if(_ptr[i] != '\n') continue;
            return pop(i + 1);
        }
        return Slice(NULL, 0);
    }

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0xc217
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
negq %rax
movl $0x1, %r14d
cmpb $0xa, -0x1(%rcx,%r14)
je 0xc21c
leaq (%rax,%r14), %rdx
incq %rdx
incq %r14
cmpq $0x1, %rdx
jne 0xc1f9
xorl %edx, %edx
xorl %eax, %eax
jmp 0xc22e
xorl %edx, %edx
xorl %eax, %eax
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc6fc
addq %r14, (%rbx)
subl %r14d, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: ISlice::atoi() const
i64 atoi() const {
        if(!size()) throw error::NoData();
        char *p = ptr();
        char *end = p + size();
        bool negative = false;
        if(*p == '-') {
            negative = true;
            if(size() < 2) throw error::InvalidData();
            p++;
        }
        i64 value = 0;
        for(;p < end; p++) {
            char a = *p - '0';
            if(a < 0 || a > 9) throw error::InvalidData();
            value = value * 10 + a;
        }
        return negative?-value:value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movslq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0xc311
movq (%rdi), %rax
movb (%rax), %cl
movq %rax, %rdx
cmpb $0x2d, %cl
jne 0xc2ac
cmpl $0x1, %esi
jle 0xc32f
leaq 0x1(%rax), %rdx
addq %rsi, %rax
xorl %esi, %esi
cmpq %rax, %rdx
jae 0xc2d4
movb (%rdx), %dil
addb $-0x30, %dil
cmpb $0xa, %dil
jae 0xc2e6
leaq (%rsi,%rsi,4), %rsi
movzbl %dil, %edi
leaq (%rdi,%rsi,2), %rsi
incq %rdx
jmp 0xc2b1
movq %rsi, %rax
negq %rax
cmpb $0x2d, %cl
cmovneq %rsi, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc254
leaq 0x1196e(%rip), %rsi     # 0x1dc70
leaq 0x1007(%rip), %rdx      # 0xd310
movq %rbx, %rdi
callq 0x8480
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc78c
leaq 0x1195b(%rip), %rsi     # 0x1dc88
jmp 0xc302
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc254
jmp 0xc2fb
jmp 0xc34a
jmp 0xc34a
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: Buffer::add_number(long)
void add_number(i64 n) {
        resize(_size + 20);

        char s[20];
        int d;
        int i=19;
        bool negative = false;
        if(n == 0) s[i--] = '0';
        else if(n < 0) {
            n = -n;
            negative = true;
        }
        while(n) {
            d = n % 10;
            s[i--] = d + '0';
            n = n / 10;
        }
        if(negative) s[i--] = '-';
        add(&s[i + 1], 19 - i);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %esi
addl $0x14, %esi
callq 0xc596
testq %r14, %r14
je 0xc3ee
movq %r14, %rcx
negq %rcx
cmovsq %r14, %rcx
movl $0x13, %r8d
movabsq $0x1300000000, %rdi     # imm = 0x1300000000
movl $0x12, %esi
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $-0x100000000, %r10     # imm = 0xFFFFFFFF00000000
addq %r10, %rdi
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r11d
subl %eax, %r11d
orb $0x30, %r11b
movb %r11b, -0x30(%rbp,%r8)
decq %r8
decl %esi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0xc3b4
testq %r14, %r14
js 0xc3f9
movl %r8d, %esi
jmp 0xc402
movb $0x30, -0x1d(%rbp)
movl $0x12, %esi
jmp 0xc402
sarq $0x20, %rdi
movb $0x2d, -0x30(%rbp,%rdi)
movslq %esi, %rax
leaq -0x30(%rbp), %rcx
leaq (%rax,%rcx), %r14
incq %r14
movl $0x13, %r15d
subl %eax, %r15d
movl 0x8(%rbx), %esi
addl %r15d, %esi
movq %rbx, %rdi
callq 0xc596
movslq 0x8(%rbx), %rdi
addq (%rbx), %rdi
movslq %r15d, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x8270
addl %r15d, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: Buffer::add(char const*)
void add(const char *i) {
        while(*i != 0) {
            if(_size >= _cap) resize(_size + 1);
            _ptr[_size++] = *i;
            i++;
        }
    }

// Assembly:
movb (%rsi), %al
testb %al, %al
je 0xc49a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
incq %rbx
movl 0x8(%r14), %esi
cmpl 0xc(%r14), %esi
jl 0xc47d
incl %esi
movq %r14, %rdi
callq 0xc596
movb -0x1(%rbx), %al
movl 0x8(%r14), %esi
movq (%r14), %rcx
leal 0x1(%rsi), %edx
movl %edx, 0x8(%r14)
movslq %esi, %rdx
movb %al, (%rcx,%rdx)
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0xc462
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: ISlice::as_string[abi:cxx11](int) const
std::string as_string(int _default=-1) const {
        std::string s;
        if(valid()) {
            s.append(ptr(), size());
        } else {
            if(_default == 1) s.append("<empty>");
            else if(_default != 0) throw error::NoData();
        }
        return s;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
testq %rax, %rax
je 0xc4d6
movslq 0x8(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8070
jmp 0xc4ee
testl %edx, %edx
je 0xc4ee
cmpl $0x1, %edx
jne 0xc4fa
leaq 0xb56b(%rip), %rsi      # 0x17a51
movq %rbx, %rdi
callq 0x84e0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %r15
leaq 0xb53b(%rip), %rsi      # 0x17a49
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xcd04
leaq 0x1178c(%rip), %rax     # 0x1dcb0
movq %rax, (%r15)
leaq 0x1175a(%rip), %rsi     # 0x1dc88
leaq 0xddb(%rip), %rdx       # 0xd310
movq %r15, %rdi
callq 0x8480
movq %rax, %r14
movq %r15, %rdi
callq 0x8220
jmp 0xc54d
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xc561
movq (%r12), %rsi
incq %rsi
callq 0x8320
movq %r14, %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: Buffer::resize(int)
void resize(int capacity) {
        if(_ptr == NULL) {
            _cap = _get_cap(capacity);
            _ptr = (char*)_malloc(_cap);
            if(_ptr == NULL) THROW("No memory");
        } else if(capacity > _cap) {
            _cap = _get_cap(capacity);
            char *p = (char*)_realloc(_ptr, _cap);
            if(!p) THROW("Realloc error");
            _ptr = p;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc5e2
cmpl %esi, 0xc(%rbx)
jge 0xc611
movl $0x10, %eax
cmpl $0x11, %esi
jl 0xc5cd
movl $0x10, %edx
addl %edx, %eax
cmpl $0x1000, %edx           # imm = 0x1000
setl %cl
shll %cl, %edx
cmpl %esi, %eax
jl 0xc5bc
movl %eax, 0xc(%rbx)
movslq %eax, %rsi
callq 0x8460
testq %rax, %rax
je 0xc647
movq %rax, (%rbx)
jmp 0xc611
movl $0x10, %edi
cmpl $0x11, %esi
jl 0xc601
movl $0x10, %eax
addl %eax, %edi
cmpl $0x1000, %eax           # imm = 0x1000
setl %cl
shll %cl, %eax
cmpl %esi, %edi
jl 0xc5f1
movl %edi, 0xc(%rbx)
callq 0xed28
movq %rax, (%rbx)
testq %rax, %rax
je 0xc616
popq %rbx
popq %r14
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
leaq 0xb436(%rip), %rsi      # 0x17a60
leaq 0xb3f5(%rip), %rdx      # 0x17a26
leaq 0xb432(%rip), %r8       # 0x17a6a
movq %rax, %rdi
movl $0xe8, %ecx
callq 0xcd04
jmp 0xc676
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
leaq 0xb428(%rip), %rsi      # 0x17a83
leaq 0xb3c4(%rip), %rdx      # 0x17a26
leaq 0xb401(%rip), %r8       # 0x17a6a
movq %rax, %rdi
movl $0xec, %ecx
callq 0xcd04
leaq 0x1169b(%rip), %rsi     # 0x1dd18
leaq 0xc8c(%rip), %rdx       # 0xd310
movq %rbx, %rdi
callq 0x8480
jmp 0xc68e
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: ISlice::compare(ISlice const&) const
int compare(const ISlice &s) const {
        int i = 0;
        int d;
        for(; i<size(); i++) {
            if(i >= s.size()) return 1;
            d = ptr()[i] - s.ptr()[i];
            if(d) return d;
        }
        if(i < s.size()) return -1;
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x8(%rdi), %rcx
movl 0x8(%rsi), %edx
testq %rcx, %rcx
jle 0xcabf
movq (%rdi), %rdi
movq (%rsi), %rsi
xorl %r8d, %r8d
testl %edx, %edx
movl $0x0, %r9d
cmovgl %edx, %r9d
cmpq %r8, %r9
je 0xcacc
movsbl (%rdi,%r8), %eax
movsbl (%rsi,%r8), %r10d
subl %r10d, %eax
jne 0xcad1
incq %r8
cmpq %r8, %rcx
jne 0xcaa1
jmp 0xcac1
xorl %ecx, %ecx
xorl %eax, %eax
cmpl %edx, %ecx
setl %al
negl %eax
jmp 0xcad1
movl $0x1, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/buffer.h
// Function: Slice::split_left(char)
Slice split_left(char a) {
        for(int i=0;i<size();++i) {
            if(_ptr[i] != a) continue;
            Slice result = Slice(_ptr, i);
            _size -= i + 1;
            _ptr += i + 1;
            return result;
        }
        return pop(_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x8(%rdi), %r14
testq %r14, %r14
jle 0xd374
movq (%rbx), %rax
xorl %edx, %edx
cmpb %sil, (%rax,%rdx)
je 0xd388
incq %rdx
cmpq %rdx, %r14
jne 0xd366
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc6fc
addq %r14, (%rbx)
subl %r14d, 0x8(%rbx)
jmp 0xd39c
movl %edx, %ecx
notl %ecx
addl %r14d, %ecx
movl %ecx, 0x8(%rbx)
leaq (%rax,%rdx), %rcx
incq %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/json.cpp
// Function: json::escape(Buffer&, int)
void json::escape(Buffer &s, int start) {
    int col = 0;
    for(int i = start;i<s.size();i++) {
        if(s.ptr()[i] == '"') col++;
    }
    if(!col) return;

    s.resize(0, s.size() + col);
    char *ptr = s.ptr();
    for(int i=s.size() -1;i>=start;i--) {
        char a = ptr[i - col];
        ptr[i] = a;
        if(a == '"') {
            i--;
            ptr[i] = '\\';
            col--;
            if(!col) break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x8(%rdi), %r15
cmpl %esi, %r15d
jle 0xd5cf
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movslq %esi, %rcx
xorl %r13d, %r13d
xorl %edx, %edx
cmpb $0x22, (%rax,%rcx)
sete %dl
addl %edx, %r13d
incq %rcx
cmpq %rcx, %r15
jne 0xd55b
testl %r13d, %r13d
je 0xd5cf
addl %r13d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
callq 0xc596
movl %r15d, 0x8(%r14)
movq (%r14), %rax
movslq %ebx, %rcx
movl %r13d, %edx
leaq -0x1(%rax), %rsi
movq %rsi, %rdi
subq %rdx, %rdi
movslq %r15d, %r9
leal -0x1(%r9), %r15d
leaq (%rdi,%r12), %r8
cmpq %rcx, %r9
jle 0xd5cf
movb (%r8,%r9), %r10b
movb %r10b, (%rsi,%r9)
decq %r9
decl %r15d
cmpb $0x22, %r10b
jne 0xd5a6
movslq %r15d, %r8
movb $0x5c, (%rax,%r8)
incq %r12
decq %rdx
jne 0xd59b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lega911[P]ijson/src/json.cpp
// Function: Json::strip()
void Json::strip() {
    while(index < _data.size()) {
        char a = _data.ptr()[index];
        if(a == ' ' || a == '\n' || a == '\r' || a == '\t') {
            index++;
            continue;
        }
        return;
    }
    throw error::InvalidData();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x30(%rdi), %eax
movslq 0x38(%rdi), %rdx
cmpl %eax, %edx
jge 0xd859
movq %rdx, %rcx
addq 0x28(%rdi), %rcx
negl %eax
leal 0x1(%rdx), %esi
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rcx), %r8d
cmpq $0x20, %r8
ja 0xd884
btq %r8, %rdx
jae 0xd884
movl %esi, 0x38(%rdi)
incq %rcx
leal (%rax,%rsi), %r8d
incl %r8d
incl %esi
cmpl $0x1, %r8d
jne 0xd834
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc254
leaq 0x103fb(%rip), %rsi     # 0x1dc70
leaq -0x56c(%rip), %rdx      # 0xd310
movq %rbx, %rdi
callq 0x8480
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0