LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlbsp/writebsp.cpp
// Function: OutputEdges_r(node_s*, int)
int OutputEdges_r (node_t *node, int detaillevel)
{
	int next = -1;
	if (node->planenum == -1)
	{
		return next;
	}
	face_t *f;
	for (f = node->faces; f; f = f->next)
	{
		if (f->detaillevel > detaillevel)
		{
			if (next == -1? true: f->detaillevel < next)
			{
				next = f->detaillevel;
			}
		}
		if (f->detaillevel == detaillevel)
		{
			OutputEdges_face (f);
		}
	}
	int i;
	for (i = 0; i < 2; i++)
	{
		int r = OutputEdges_r (node->children[i], detaillevel);
		if (r == -1? false: next == -1? true: r < next)
		{
			next = r;
		}
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $-0x1, 0x80(%rdi)
je 0x1bf2f
movl %esi, %ebx
movq %rdi, %r14
movq 0x98(%rdi), %r15
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r15, %r15
je 0x1beff
movl %ebp, %eax
movl 0x14(%r15), %ecx
cmpl %ebp, %ecx
cmovll %ecx, %ebp
cmpl $-0x1, %eax
cmovel %ecx, %ebp
cmpl %ebx, %ecx
cmovlel %eax, %ebp
jne 0x1befa
movq %r15, %rdi
callq 0x1bddf
movq (%r15), %r15
jmp 0x1bed5
xorl %r15d, %r15d
movq 0x88(%r14,%r15,8), %rdi
movl %ebx, %esi
callq 0x1beb4
cmpl %ebp, %eax
movl %ebp, %ecx
cmovll %eax, %ecx
cmpl $-0x1, %ebp
cmovel %eax, %ecx
cmpl $-0x1, %eax
cmovnel %ecx, %ebp
incq %r15
cmpq $0x1, %r15
je 0x1bf02
jmp 0x1bf34
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlbsp/writebsp.cpp
// Function: WritePlane(int)
static int WritePlane(int planenum)
{
	planenum = planenum & (~1);

	if(g_noopt)
	{
		return planenum;
	}

	PlaneMap::iterator item = gPlaneMap.find(planenum);
	if(item != gPlaneMap.end())
	{
		return item->second;
	}
	//add plane to BSP
	hlassume(gNumMappedPlanes < MAX_MAP_PLANES, assume_MAX_MAP_PLANES);
	gMappedPlanes[gNumMappedPlanes] = g_dplanes[planenum];
	gPlaneMap.insert(PlaneMap::value_type(planenum,gNumMappedPlanes));

	return gNumMappedPlanes++;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
andl $-0x2, %ebx
leaq 0x20b7ab4(%rip), %rax   # 0x20d4a10
cmpb $0x0, (%rax)
jne 0x1d041
movq 0x4a33bc4(%rip), %rdx   # 0x4a50b30
leaq 0x4a33bb5(%rip), %rax   # 0x4a50b28
movq %rax, %rcx
testq %rdx, %rdx
je 0x1cf99
leaq 0x4a33ba6(%rip), %rcx   # 0x4a50b28
xorl %esi, %esi
cmpl %ebx, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x1cf82
movq %rax, %rdx
cmpq %rax, %rcx
je 0x1cfaf
cmpl 0x20(%rcx), %ebx
leaq 0x4a33b7d(%rip), %rdx   # 0x4a50b28
cmovgeq %rcx, %rdx
cmpq %rax, %rdx
je 0x1cfbc
movl 0x24(%rdx), %ebx
jmp 0x1d041
xorl %edi, %edi
cmpl $0x8000, 0x4a33bbc(%rip) # imm = 0x8000
setl %dil
movl $0x23, %esi
callq 0xa731
movslq %ebx, %rax
shlq $0x6, %rax
leaq 0x20b7a3c(%rip), %rcx   # 0x20d4a20
movslq 0x4a33b99(%rip), %rdx   # 0x4a50b84
leaq 0x8(%rsp), %rsi
movl %ebx, (%rsi)
movl %edx, 0x4(%rsi)
shlq $0x6, %rdx
leaq 0x4b73b70(%rip), %rdi   # 0x4b90b70
movaps (%rcx,%rax), %xmm0
movaps 0x10(%rcx,%rax), %xmm1
movaps 0x20(%rcx,%rax), %xmm2
movaps 0x30(%rcx,%rax), %xmm3
movaps %xmm0, (%rdx,%rdi)
movaps %xmm1, 0x10(%rdx,%rdi)
movaps %xmm2, 0x20(%rdx,%rdi)
movaps %xmm3, 0x30(%rdx,%rdi)
leaq 0x4a33af3(%rip), %rdi   # 0x4a50b20
callq 0x1d0a0
movl 0x4a33b4c(%rip), %ebx   # 0x4a50b84
leal 0x1(%rbx), %eax
movl %eax, 0x4a33b43(%rip)   # 0x4a50b84
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rtackx[P]ComSim/main.cpp
// Function: select_similarity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Graph*&)
Projection* select_similarity(string similarity_index, Graph*& in_graph)
{
	if(similarity_index == "cn")
		return new CommonNeighbors(in_graph);
	else if(similarity_index == "ji")
		return new JaccardIndex(in_graph);
	else if(similarity_index == "aa")
		return new AdamicAdar(in_graph);
	else if(similarity_index == "ra")
		return new ResourceAllocator(in_graph);
	else if(similarity_index == "lhn")
		return new LHN1(in_graph);
	else if(similarity_index == "pan")
		return new PA_Neighbor(in_graph);

  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x79fa(%rip), %rsi      # 0xa7ca
callq 0x20c0
testl %eax, %eax
je 0x2e54
leaq 0x79ed(%rip), %rsi      # 0xa7cd
movq %r14, %rdi
callq 0x20c0
testl %eax, %eax
je 0x2e71
leaq 0x79d9(%rip), %rsi      # 0xa7d0
movq %r14, %rdi
callq 0x20c0
testl %eax, %eax
je 0x2e8b
leaq 0x79c5(%rip), %rsi      # 0xa7d3
movq %r14, %rdi
callq 0x20c0
testl %eax, %eax
je 0x2ea5
leaq 0x79b1(%rip), %rsi      # 0xa7d6
movq %r14, %rdi
callq 0x20c0
testl %eax, %eax
je 0x2ebf
leaq 0x799e(%rip), %rsi      # 0xa7da
movq %r14, %rdi
callq 0x20c0
testl %eax, %eax
je 0x2ed9
xorl %r14d, %r14d
jmp 0x2ef1
movl $0x20, %edi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5d46
jmp 0x2ef1
movl $0x20, %edi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5ec0
jmp 0x2ef1
movl $0x20, %edi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6096
jmp 0x2ef1
movl $0x20, %edi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6154
jmp 0x2ef1
movl $0x20, %edi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x620e
jmp 0x2ef1
movl $0x20, %edi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x63f2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2f06
jmp 0x2f06
jmp 0x2f06
jmp 0x2f06
jmp 0x2f06
movq %rax, %rbx
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O1/rtackx[P]ComSim/graph.cpp
// Function: Graph::~Graph()
Graph::~Graph()
{
	unsigned int index, nb;

	index = 0;
	while(index < n)
	{
		nb = list_nodes[index]->nb_neighbors;
		delete list_nodes[index];
		index++;		
	}

	if(list_nodes)
		delete[] list_nodes;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x3e23
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x3e19
movq %r14, %rdi
callq 0x26a2
movq %r14, %rdi
callq 0x2220
incq %r15
movl (%rbx), %eax
cmpq %rax, %r15
jb 0x3dfc
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3e36
popq %rbx
popq %r14
popq %r15
jmp 0x22c0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42a7
movl 0x4(%rbx), %edx
addl 0x38(%rcx), %edx
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x4299
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 0x4378
xorl %ebx, %ebx
movq %rbp, 0x8(%rsp)
leaq 0x8(%r15), %r13
movq 0x10(%r15), %r12
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5090
movl 0x28(%rax), %eax
movl %eax, 0x28(%r12)
movl %ebx, (%r12)
cmpl $-0x1, 0x4(%r12)
jne 0x42fb
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 0x5090
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0x4365
addq $0x30, %r12
leaq 0x20(%rbp), %rsi
movss 0x24(%rbp), %xmm0
movss %xmm0, 0x4(%rsp)
movq %r14, %rdi
callq 0x466e
movq %r12, %rdi
movq %rax, %rsi
callq 0x5150
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbp, %rdi
callq 0x2290
movq %rax, %rbp
cmpq %r13, %rax
jne 0x4329
incl %ebx
movq (%r15), %r15
testq %r15, %r15
movq 0x8(%rsp), %rbp
jne 0x42cf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9dc3(%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 0x54f0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9d89(%rip), %r14      # 0xf280
leaq 0x64(%rip), %r15        # 0x5562
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 0x5506
xorl %edi, %edi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x98, %rsp
movq %rdi, %rbx
movq %rsp, -0x30(%rbp)
leaq -0x90(%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 -0x58(%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, %r13
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movl $0x0, -0x48(%rbp)
movq %rdi, -0x50(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movl %esi, -0x44(%rbp)
cmpl $0x0, 0x8(%rdi)
je 0x5abc
xorl %r14d, %r14d
leaq -0x50(%rbp), %r15
movq %r13, %r12
movq %r12, %rdi
xorl %esi, %esi
leaq -0x618(%rip), %rdx      # 0x548d
movq %r15, %rcx
callq 0x2410
incq %r14
movl 0x8(%rbx), %eax
addq $0x8, %r12
cmpq %rax, %r14
jb 0x5a99
cmpl $0x0, 0x8(%rbx)
je 0x5adc
xorl %r14d, %r14d
movq (%r13,%r14,8), %rdi
xorl %esi, %esi
callq 0x2200
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x5ac5
movq 0x18(%rbx), %rdi
leaq -0xc0(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x4270
movq -0x30(%rbp), %rsp
leaq -0x88(%rbp), %rdi
callq 0x4388
leaq -0xc0(%rbp), %rdi
callq 0x445e
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b20
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4388
leaq -0xc0(%rbp), %rdi
callq 0x445e
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b44
movq (%r14), %rax
movq 0x40(%rax), %r15
xorps %xmm0, %xmm0
testq %r15, %r15
je 0x5e07
movss %xmm0, 0x4(%rsp)
leaq 0x10(%rsp), %r12
leaq 0x8(%r15), %rsi
movq 0x18(%rsp), %rcx
movq %r12, %rax
testq %rcx, %rcx
je 0x5dc6
movq (%rsi), %rdx
movq %r12, %rax
xorl %edi, %edi
cmpq %rdx, 0x20(%rcx)
setb %dil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x5dae
movq %r12, %rcx
cmpq %r12, %rax
je 0x5ddc
movq (%rsi), %rcx
cmpq 0x20(%rax), %rcx
cmovbq %r12, %rax
movq %rax, %rcx
cmpq %r12, %rcx
je 0x5dfd
movq (%r14), %rdi
addq $0x30, %rdi
callq 0x5150
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r15), %r15
testq %r15, %r15
jne 0x5d97
jmp 0x5e0d
movss %xmm0, 0x4(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %r14
testq %r14, %r14
je 0x5e8c
leaq 0x10(%rsp), %r15
leaq 0x8(%r14), %rsi
movq 0x18(%rsp), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x5e4d
movq (%rsi), %rdx
movq %r15, %rax
xorl %edi, %edi
cmpq %rdx, 0x20(%rcx)
setb %dil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x5e35
movq %r15, %rcx
cmpq %r15, %rax
je 0x5e63
movq (%rsi), %rcx
cmpq 0x20(%rax), %rcx
cmovbq %r15, %rax
movq %rax, %rcx
cmpq %r15, %rcx
je 0x5e84
movq (%rbx), %rdi
addq $0x30, %rdi
callq 0x5150
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r14), %r14
testq %r14, %r14
jne 0x5e1e
leaq 0x8(%rsp), %rdi
callq 0x6520
movss 0x4(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5eaa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6520
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b44
movq (%r14), %rax
movq 0x40(%rax), %r12
testq %r12, %r12
je 0x5fa7
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 0x5150
movq 0x20(%rsp), %rdx
movq %r13, %rcx
testq %rdx, %rdx
je 0x5f5f
movq (%r15), %rsi
movq %r13, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x5f47
movq %r13, %rdx
cmpq %r13, %rcx
je 0x5f75
movq (%r15), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %r13, %rcx
movq %rcx, %rdx
movss (%rax), %xmm0
cmpq %r13, %rdx
je 0x5f8e
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 0x5f1a
jmp 0x5fb3
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %r15
testq %r15, %r15
je 0x6051
leaq 0x18(%rsp), %r12
movss %xmm1, 0xc(%rsp)
leaq 0x8(%r15), %r14
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r14, %rsi
callq 0x5150
movq 0x20(%rsp), %rdx
movq %r12, %rcx
testq %rdx, %rdx
je 0x600c
movq (%r14), %rsi
movq %r12, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x5ff4
movq %r12, %rdx
cmpq %r12, %rcx
je 0x6022
movq (%r14), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %r12, %rcx
movq %rcx, %rdx
movss (%rax), %xmm0
cmpq %r12, %rdx
je 0x603b
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 0x5fc8
movss 0x8(%rsp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6520
movss 0x8(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6081
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6520
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b44
movq 0x18(%rbx), %rbx
leaq 0x10(%rsp), %r14
xorps %xmm0, %xmm0
cmpq %r14, %rbx
je 0x6135
movss %xmm0, 0x4(%rsp)
movq 0x20(%rbx), %rax
movq 0x40(%rax), %rax
xorps %xmm0, %xmm0
testq %rax, %rax
je 0x60f7
addss 0x10(%rax), %xmm0
movq (%rax), %rax
jmp 0x60e8
callq 0x22d0
cvtss2sd %xmm0, %xmm0
movsd 0x47d8(%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 0x60dd
jmp 0x613b
movss %xmm0, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x6520
movss 0x4(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b44
movq 0x18(%rbx), %rax
leaq 0x18(%rsp), %rbx
xorps %xmm0, %xmm0
cmpq %rbx, %rax
je 0x61f1
movss %xmm0, 0xc(%rsp)
movq 0x20(%rax), %rcx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
je 0x61bc
xorps %xmm0, %xmm0
addss 0x10(%rcx), %xmm0
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x61a9
cvtss2sd %xmm0, %xmm0
jmp 0x61bf
xorps %xmm0, %xmm0
movsd 0x4719(%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 0x6199
jmp 0x61f7
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6520
movss 0xc(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b44
movq (%r14), %rax
movq 0x40(%rax), %r12
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
testq %r12, %r12
je 0x62f9
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 0x5150
movq 0x20(%rsp), %rdx
movq %r13, %rcx
testq %rdx, %rdx
je 0x62b3
movq (%r15), %rsi
movq %r13, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x629b
movq %r13, %rdx
cmpq %r13, %rcx
je 0x62c9
movq (%r15), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %r13, %rcx
movq %rcx, %rdx
movss (%rax), %xmm0
cmpq %r13, %rdx
je 0x62e2
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 0x626e
movss %xmm1, 0x8(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %r15
xorps %xmm0, %xmm0
testq %r15, %r15
je 0x63a3
leaq 0x18(%rsp), %r12
movss %xmm0, 0xc(%rsp)
leaq 0x8(%r15), %r14
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r14, %rsi
callq 0x5150
movq 0x20(%rsp), %rdx
movq %r12, %rcx
testq %rdx, %rdx
je 0x635b
movq (%r14), %rsi
movq %r12, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x6343
movq %r12, %rdx
cmpq %r12, %rcx
je 0x6371
movq (%r14), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %r12, %rcx
movq %rcx, %rdx
movss (%rax), %xmm0
cmpq %r12, %rdx
je 0x638a
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 0x6317
movss 0x8(%rsp), %xmm1
mulss %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6520
movss 0x4(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x63dd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6520
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b44
movq 0x18(%rbx), %rax
leaq 0x18(%rsp), %rbx
movss 0x448f(%rip), %xmm0     # 0xa8c0
cmpq %rbx, %rax
je 0x6475
movss %xmm0, 0xc(%rsp)
movq 0x20(%rax), %rcx
movq 0x40(%rcx), %rcx
xorps %xmm0, %xmm0
testq %rcx, %rcx
je 0x6456
addss 0x10(%rcx), %xmm0
movq (%rcx), %rcx
jmp 0x6447
movss 0xc(%rsp), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movq %rax, %rdi
callq 0x2290
cmpq %rbx, %rax
jne 0x643c
jmp 0x647b
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6520
movss 0xc(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x759f
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 0x7556
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x7576
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x758e
movl 0x4(%rcx), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rsi
cmpq 0x40(%rsp), %rsi
je 0x7583
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rsp)
jmp 0x758e
movq %r13, %rdi
movq %rbp, %rdx
callq 0x8498
jmp 0x758e
movq %r15, %rdi
movq %r12, %rdx
callq 0x8364
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
movq (%rbx), %rcx
cmpl (%rcx), %eax
jb 0x752d
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x75d0
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7666
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7bd4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8088
leaq 0x50(%rsp), %rdi
movq 0x18(%rdi), %rbx
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %r14
callq 0x823e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x7602
callq 0x2220
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7611
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 0x7633
jmp 0x7633
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x823e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x764f
callq 0x2220
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x765e
callq 0x2220
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/connect.cpp
// Function: Connect::write_mode(bool)
void Connect::write_mode(bool active) {
    if(active) {
        if(_socket_status & 2) return;
        _socket_status |= 2;
    } else {
        if(!(_socket_status & 2)) return;
        _socket_status = _socket_status & 0xfd;
    }
    loop->_queue_to_send.push_back(this);
}

// Assembly:
movl (%rdi), %eax
testl %esi, %esi
je 0x8a2f
testb $0x2, %al
jne 0x8a5e
orl $0x2, %eax
jmp 0x8a38
testb $0x2, %al
je 0x8a5e
andl $0xfd, %eax
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %eax, (%rdi)
movq 0x30(%rdi), %rax
addq $0x60, %rax
leaq -0x8(%rbp), %rsi
movq %rdi, (%rsi)
movq %rax, %rdi
callq 0xc7c6
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/connect.cpp
// Function: Connect::read_mode(bool)
void Connect::read_mode(bool active) {
    if(active) {
        if(_socket_status & 1) return;
        _socket_status |= 1;
    } else {
        if(!(_socket_status & 1)) return;
        _socket_status = _socket_status & 0xfe;
    }
    loop->set_poll_mode(fd, _socket_status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %edx
testl %esi, %esi
je 0x8a74
testb $0x1, %dl
jne 0x8a79
orl $0x1, %edx
jmp 0x8a81
testb $0x1, %dl
jne 0x8a7b
popq %rbp
retq
andl $0xfe, %edx
movl %edx, (%rdi)
movq 0x30(%rdi), %rax
movl 0xc(%rdi), %esi
movq %rax, %rdi
popq %rbp
jmp 0x10460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc5a2
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xd833(%rip), %rsi      # 0x1773f
callq 0xc41e
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xc41e
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xd7ed(%rip), %rsi      # 0x1771b
callq 0xc41e
movq (%rbx), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0x9f4c
addq $0x20, %rdi
leaq 0xd802(%rip), %rsi      # 0x17749
callq 0xc41e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa802
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xffff80a7, %esi       # imm = 0xFFFF80A7
jg 0x9fae
cmpl $0xffff8044, %esi       # imm = 0xFFFF8044
je 0x9fd2
cmpl $0xffff80a6, %esi       # imm = 0xFFFF80A6
je 0x9fff
cmpl $0xffff80a7, %esi       # imm = 0xFFFF80A7
jne 0x9ff6
leaq 0xd8c3(%rip), %rax      # 0x17866
movq %rax, -0x10(%rbp)
movl $0x58, %eax
jmp 0xa021
cmpl $0xffff80a8, %esi       # imm = 0xFFFF80A8
je 0x9fe4
cmpl $-0x1, %esi
je 0xa011
cmpl $0x1, %esi
jne 0x9ff6
leaq 0xd9ac(%rip), %rax      # 0x17973
movq %rax, -0x10(%rbp)
movl $0x2e, %eax
jmp 0xa021
leaq 0xd7e1(%rip), %rax      # 0x177ba
movq %rax, -0x10(%rbp)
movl $0x53, %eax
jmp 0xa021
leaq 0xd823(%rip), %rax      # 0x1780e
movq %rax, -0x10(%rbp)
movl $0x57, %eax
jmp 0xa021
leaq 0xd9a5(%rip), %rax      # 0x179a2
jmp 0xa006
leaq 0xd8b9(%rip), %rax      # 0x178bf
movq %rax, -0x10(%rbp)
movl $0x56, %eax
jmp 0xa021
leaq 0xd8fe(%rip), %rax      # 0x17916
movq %rax, -0x10(%rbp)
movl $0x5c, %eax
leaq -0x10(%rbp), %rsi
movl %eax, 0x8(%rsi)
callq 0xa704
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movl $0x0, 0xa0(%rdi)
movslq 0x8(%rsi), %rcx
testq %rcx, %rcx
jle 0xa0b0
leaq 0x98(%rbx), %rdi
xorl %edx, %edx
xorl %esi, %esi
xorl %eax, %eax
cmpb $0x20, (%r15,%rdx)
jne 0xa07b
cmpl $0x1, %esi
je 0xa085
leal 0x1(%rdx), %eax
movl $0x1, %esi
incq %rdx
cmpq %rdx, %rcx
jne 0xa067
jmp 0xa0b0
leal 0x1(%rax), %ecx
cmpl %edx, %ecx
jge 0xa099
movslq %eax, %rsi
cmpb $0x2f, (%r15,%rsi)
cmovnel %eax, %ecx
movl %ecx, %eax
cltq
leaq (%r15,%rax), %rsi
subl %eax, %edx
movl $0x0, 0xa0(%rbx)
callq 0xc0a8
movslq 0x8(%r14), %rax
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
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movq (%rsi), %rcx
xorl %esi, %esi
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movb $0x67, %r8b
leaq 0xcc3f(%rip), %rdi      # 0x171ac
cmpq %rsi, %rdx
je 0xa594
cmpb (%rcx,%rsi), %r8b
jne 0xa594
movb 0x1(%rsi,%rdi), %r8b
incq %rsi
cmpq $0x3, %rsi
jne 0xa56d
movl $0x1, %esi
cmpl $0x3, %eax
je 0xa6bb
movb $0x67, %r8b
xorl %esi, %esi
leaq 0xcc10(%rip), %rdi      # 0x171b0
cmpq %rsi, %rdx
je 0xa5c7
cmpb (%rcx,%rsi), %r8b
jne 0xa5c7
movb 0x1(%rsi,%rdi), %r8b
incq %rsi
cmpq $0x4, %rsi
jne 0xa5a0
movl $0x2, %esi
cmpl $0x4, %eax
je 0xa6bb
movb $0x77, %r8b
xorl %esi, %esi
leaq 0xe0d3(%rip), %rdi      # 0x186a6
cmpq %rsi, %rdx
je 0xa5fa
cmpb (%rcx,%rsi), %r8b
jne 0xa5fa
movb 0x1(%rsi,%rdi), %r8b
incq %rsi
cmpq $0x6, %rsi
jne 0xa5d3
movl $0x3, %esi
cmpl $0x6, %eax
je 0xa6bb
movb $0x61, %r8b
xorl %esi, %esi
leaq 0xcbaf(%rip), %rdi      # 0x171b5
cmpq %rsi, %rdx
je 0xa62d
cmpb (%rcx,%rsi), %r8b
jne 0xa62d
movb 0x1(%rsi,%rdi), %r8b
incq %rsi
cmpq $0x5, %rsi
jne 0xa606
movl $0x4, %esi
cmpl $0x5, %eax
je 0xa6bb
movb $0x70, %r8b
xorl %esi, %esi
leaq 0xcb82(%rip), %rdi      # 0x171bb
cmpq %rsi, %rdx
je 0xa65c
cmpb (%rcx,%rsi), %r8b
jne 0xa65c
movb 0x1(%rsi,%rdi), %r8b
incq %rsi
cmpq $0x3, %rsi
jne 0xa639
movl $0x5, %esi
cmpl $0x3, %eax
je 0xa6bb
movb $0x72, %r8b
xorl %esi, %esi
leaq 0xcc06(%rip), %rdi      # 0x1726e
cmpq %rsi, %rdx
je 0xa68b
cmpb (%rcx,%rsi), %r8b
jne 0xa68b
movb 0x1(%rsi,%rdi), %r8b
incq %rsi
cmpq $0x6, %rsi
jne 0xa668
movl $0x6, %esi
cmpl $0x6, %eax
je 0xa6bb
leaq 0xcb2d(%rip), %rsi      # 0x171bf
movq %r14, %rdi
callq 0xc1fa
movl $0x7, %esi
testb %al, %al
jne 0xa6bb
leaq 0xcb1c(%rip), %rsi      # 0x171c6
movq %r14, %rdi
callq 0xc1fa
movl $0x8, %esi
testb %al, %al
je 0xa6c6
movl %esi, 0xc8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc238
leaq 0x1358e(%rip), %rsi     # 0x1dc70
leaq 0x2c27(%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_O1/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 0xa7aa
movq %rsi, %r14
movslq 0x8(%rsi), %r15
addq $0x20, %rdi
testq %r15, %r15
je 0xa770
leaq 0xcfea(%rip), %rsi      # 0x1771e
callq 0xc41e
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r15, %rsi
callq 0xc342
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xcfc3(%rip), %rsi      # 0x17719
callq 0xc41e
movq (%rbx), %rdi
addq $0x20, %rdi
movq (%r14), %rsi
movl 0x8(%r14), %edx
callq 0xc0a8
jmp 0xa77c
leaq 0xcf91(%rip), %rsi      # 0x17708
callq 0xc41e
movq (%rbx), %rax
movl (%rax), %ecx
testb $0x2, %cl
jne 0xa79f
orl $0x2, %ecx
movl %ecx, (%rax)
movq 0x30(%rax), %rdi
addq $0x60, %rdi
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
callq 0xc7c6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
leaq 0xcfa4(%rip), %rsi      # 0x17762
leaq 0xc88c(%rip), %rdx      # 0x17051
leaq 0xcfb6(%rip), %r8       # 0x17782
movq %rax, %rdi
movl $0x2eb, %ecx            # imm = 0x2EB
callq 0xcd04
leaq 0x13538(%rip), %rsi     # 0x1dd18
leaq 0x2b29(%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_O1/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 0xb231
cmpb $0x2f, (%rsi)
jne 0xb214
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 0xfa1c
leaq 0xc00a(%rip), %rsi      # 0x17239
jmp 0xb23e
movl $0xffff80a8, %r14d      # imm = 0xFFFF80A8
leaq 0xc4f1(%rip), %rsi      # 0x1772f
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x9ee0
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x9f54
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb296
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
callq 0xfbc8
movl $0x1, %r14d
leaq 0xbfa5(%rip), %rsi      # 0x17239
jmp 0xb2a3
movl $0xffff80a8, %r14d      # imm = 0xFFFF80A8
leaq 0xc48c(%rip), %rsi      # 0x1772f
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x9ee0
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x9f54
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc41e
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xc816(%rip), %rsi      # 0x18413
callq 0xc41e
movq (%rbx), %rdi
addq $0x20, %rdi
movq (%r14), %rsi
movl 0x8(%r14), %edx
callq 0xc0a8
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xbaf8(%rip), %rsi      # 0x1771b
callq 0xc41e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc0ee
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %esi
addl %edx, %esi
callq 0xc5a2
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 0xb8f7(%rip), %rsi      # 0x179f9
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc6ae
leaq 0x11b70(%rip), %rsi     # 0x1dc88
leaq 0x11f1(%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_O1/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 0xc1bd
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 0xc1c2
leaq (%rax,%r14), %rdx
incq %rdx
incq %r14
cmpq $0x1, %rdx
jne 0xc19f
xorl %eax, %eax
xorl %edx, %edx
jmp 0xc1d4
xorl %eax, %eax
xorl %edx, %edx
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc708
addq %r14, (%rbx)
subl %r14d, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc2f5
movq (%rdi), %rax
movb (%rax), %cl
movq %rax, %rdx
cmpb $0x2d, %cl
jne 0xc290
cmpl $0x1, %esi
jle 0xc313
leaq 0x1(%rax), %rdx
addq %rsi, %rax
xorl %esi, %esi
cmpq %rax, %rdx
jae 0xc2b8
movb (%rdx), %dil
addb $-0x30, %dil
cmpb $0xa, %dil
jae 0xc2ca
leaq (%rsi,%rsi,4), %rsi
movzbl %dil, %edi
leaq (%rdi,%rsi,2), %rsi
incq %rdx
jmp 0xc295
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 0xc238
leaq 0x1198a(%rip), %rsi     # 0x1dc70
leaq 0x1023(%rip), %rdx      # 0xd310
movq %rbx, %rdi
callq 0x8480
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc798
leaq 0x11977(%rip), %rsi     # 0x1dc88
jmp 0xc2e6
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
movq %rax, %rdi
callq 0xc238
jmp 0xc2df
jmp 0xc32e
jmp 0xc32e
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc5a2
testq %r14, %r14
je 0xc37d
movq %r14, %rdi
shrq $0x3f, %rdi
movq %r14, %rcx
negq %rcx
cmovsq %r14, %rcx
movl $0x13, %esi
jmp 0xc38a
movb $0x30, -0x1d(%rbp)
movl $0x12, %esi
xorl %ecx, %ecx
xorl %edi, %edi
testq %rcx, %rcx
je 0xc3c6
movl %esi, %esi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, -0x30(%rbp,%rsi)
decq %rsi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0xc39b
testb %dil, %dil
je 0xc3d5
movslq %esi, %rax
decl %esi
movb $0x2d, -0x30(%rbp,%rax)
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 0xc5a2
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
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, (%rsi)
je 0xc467
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
incq %r14
movl 0x8(%rbx), %esi
cmpl 0xc(%rbx), %esi
jl 0xc445
incl %esi
movq %rbx, %rdi
callq 0xc5a2
movb -0x1(%r14), %al
movq (%rbx), %rcx
movslq 0x8(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x8(%rbx)
movb %al, (%rcx,%rdx)
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0xc433
popq %rbx
popq %r14
popq %rbp
retq