LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/surfaces.cpp
// Function: GetEdge(double const*, double const*, face_s*)
int             GetEdge(const vec3_t p1, const vec3_t p2, face_t* f)
{
    int             v1;
    int             v2;
    dedge_t*        edge;
    int             i;

    hlassert(f->contents);

    v1 = GetVertex(p1, f->planenum);
    v2 = GetVertex(p2, f->planenum);
    for (i = firstmodeledge; i < g_numedges; i++)
    {
        edge = &g_dedges[i];
        if (v1 == edge->v[1] && v2 == edge->v[0] && !edgefaces[i][1] && edgefaces[i][0]->contents == f->contents
#ifdef HLBSP_EDGESHARE_SAMESIDE
			&& edgefaces[i][0]->planenum != (f->planenum ^ 1)
			&& edgefaces[i][0]->contents == f->contents
#endif
			)
        {
            edgefaces[i][1] = f;
            return -i;
        }
    }

    // emit an edge
    hlassume(g_numedges < MAX_MAP_EDGES, assume_MAX_MAP_EDGES);
    edge = &g_dedges[g_numedges];
    g_numedges++;
    edge->v[0] = v1;
    edge->v[1] = v2;
    edgefaces[i][0] = f;

    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0x8(%rdx), %esi
callq 0x17f88
movl %eax, %ebp
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x17f88
movl %eax, %r15d
movslq 0x12559(%rip), %r14     # 0x2a410
leaq 0x1cfa50e(%rip), %rax   # 0x1d123cc
movslq (%rax), %rax
movq %r14, %r12
shlq $0x20, %r12
movq %r14, %rcx
shlq $0x4, %rcx
leaq 0x32babaa(%rip), %rdx   # 0x32d2a80
addq %rdx, %rcx
addq $0x8, %rcx
leaq 0x1cfa4ec(%rip), %r13   # 0x1d123d0
movabsq $0x100000000, %rdx      # imm = 0x100000000
cmpq %rax, %r14
jge 0x17f31
movzwl 0x2(%r13,%r14,4), %esi
cmpl %esi, %ebp
jne 0x17f25
movzwl (%r13,%r14,4), %esi
cmpl %esi, %r15d
jne 0x17f25
cmpq $0x0, (%rcx)
jne 0x17f25
movq -0x8(%rcx), %rsi
movl 0x10(%rsi), %edi
cmpl 0x10(%rbx), %edi
jne 0x17f25
movl 0x8(%rbx), %edi
xorl 0x8(%rsi), %edi
cmpl $0x1, %edi
jne 0x17f80
incq %r14
addq %rdx, %r12
addq $0x10, %rcx
jmp 0x17eee
xorl %edi, %edi
cmpl $0x3e800, %eax          # imm = 0x3E800
setl %dil
pushq $0x2d
popq %rsi
callq 0x92bb
leaq 0x1cfa481(%rip), %rdx   # 0x1d123cc
movslq (%rdx), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%rdx)
movw %bp, (%r13,%rax,4)
movw %r15w, 0x2(%r13,%rax,4)
sarq $0x1c, %r12
leaq 0x32bab16(%rip), %rax   # 0x32d2a80
movq %rbx, (%r12,%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, (%rcx)
negl %r14d
jmp 0x17f6e
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/surfaces.cpp
// Function: MakeFaceEdges()
static void     InitHash()
{
    vec3_t          size;
    vec_t           volume;
    vec_t           scale;
    int             newsize[2];
    int             i;

    memset(hashverts, 0, sizeof(hashverts));

    for (i = 0; i < 3; i++)
    {
        hash_min[i] = -8000;
        size[i] = 16000;
    }

    volume = size[0] * size[1];

    scale = sqrt(volume / NUM_HASH);

#ifdef HLBSP_HASH_FIX
	hash_numslots[0] = (int)floor (size[0] / scale);
	hash_numslots[1] = (int)floor (size[1] / scale);
	while (hash_numslots[0] * hash_numslots[1] > NUM_HASH)
	{
		Developer (DEVELOPER_LEVEL_WARNING, "hash_numslots[0] * hash_numslots[1] > NUM_HASH");
		hash_numslots[0]--;
		hash_numslots[1]--;
	}

	hash_scale[0] = hash_numslots[0] / size[0];
	hash_scale[1] = hash_numslots[1] / size[1];
#else
    newsize[0] = size[0] / scale;
    newsize[1] = size[1] / scale;

    hash_scale[0] = newsize[0] / size[0];
    hash_scale[1] = newsize[1] / size[1];
    hash_scale[2] = newsize[1];
#endif

    hvert_p = hvertex;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
leaq 0x36a26fc(%rip), %rdi   # 0x36baa80
xorl %ebx, %ebx
movl $0x8000, %edx           # imm = 0x8000
xorl %esi, %esi
callq 0x4180
leaq 0x36aa717(%rip), %rax   # 0x36c2ab0
movabsq $-0x3f40c00000000000, %rcx # imm = 0xC0BF400000000000
movabsq $0x40cf400000000000, %rdx # imm = 0x40CF400000000000
cmpq $0x18, %rbx
je 0x183c2
movq %rcx, (%rbx,%rax)
movq %rdx, 0x30(%rsp,%rbx)
addq $0x8, %rbx
jmp 0x183ad
movapd 0x30(%rsp), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
movapd %xmm1, (%rsp)
mulsd %xmm1, %xmm0
mulsd 0x878f(%rip), %xmm0     # 0x20b70
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x183f1
sqrtsd %xmm0, %xmm0
jmp 0x183f6
callq 0x4240
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd (%rsp), %xmm1
divpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x4540
movapd %xmm0, 0x20(%rsp)
movapd 0x10(%rsp), %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
callq 0x4540
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
cvttpd2dq %xmm1, %xmm0
movd %xmm0, %eax
leaq 0x87ac(%rip), %rbx      # 0x20bec
pushq $0x2
popq %rbp
movl %eax, 0x36aa67f(%rip)   # 0x36c2ac8
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %eax
movd %xmm1, 0x36aa672(%rip)  # 0x36c2acc
movd %xmm0, %ecx
imull %eax, %ecx
cmpl $0x1001, %ecx           # imm = 0x1001
jl 0x1848b
movl %ebp, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x9035
movq 0x36aa64b(%rip), %xmm0  # 0x36c2ac8
paddd 0x86fb(%rip), %xmm0     # 0x20b80
movd %xmm0, %eax
jmp 0x18443
cvtdq2pd %xmm0, %xmm0
divpd (%rsp), %xmm0
movapd %xmm0, 0x36aa5f4(%rip)  # 0x36c2a90
leaq 0x36aa63d(%rip), %rax   # 0x36c2ae0
movq %rax, 0x36aa5d6(%rip)   # 0x36c2a80
leaq 0x1cf9f1b(%rip), %rax   # 0x1d123cc
movl (%rax), %eax
movl %eax, 0x11f57(%rip)     # 0x2a410
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/tjunc.cpp
// Function: tjunc_find_r(node_s*)
static void     tjunc_find_r(node_t* node)
{
    face_t*         f;

    if (node->planenum == PLANENUM_LEAF)
    {
        return;
    }

    for (f = node->faces; f; f = f->next)
    {
        AddFaceEdges(f);
    }

    tjunc_find_r(node->children[0]);
    tjunc_find_r(node->children[1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
cmpl $-0x1, 0x80(%rbx)
je 0x1864a
movq %rbx, (%rsp)
addq $0x98, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1862e
leaq 0x38(%rbx), %r14
movq %r14, %r12
xorl %r13d, %r13d
movslq 0x2c(%rbx), %rcx
cmpq %rcx, %r13
jge 0x185ce
incq %r13
movl %r13d, %eax
cltd
idivl %ecx
imulq $0x18, %rdx, %rsi
addq %r14, %rsi
movq %r12, %rdi
leaq 0x10(%rsp), %rdx
movq %r15, %rcx
callq 0x18c41
movq %rax, %rbp
movsd 0x10(%rsp), %xmm0
movq %rax, %rdi
callq 0x19179
movsd 0x8(%rsp), %xmm0
movq %rbp, %rdi
callq 0x19179
addq $0x18, %r12
jmp 0x185e0
movq (%rsp), %rbx
movq 0x88(%rbx), %rdi
callq 0x185a0
movq 0x90(%rbx), %rbx
jmp 0x185b6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/tjunc.cpp
// Function: AddVert(wedge_s const*, double)
static void     AddVert(const wedge_t* const w, const vec_t t)
{
    wvert_t*        v;
    wvert_t*        newv;

    v = w->head.next;
    do
    {
        if (fabs(v->t - t) < T_EPSILON)
        {
            return;
        }
        if (v->t > t)
        {
            break;
        }
        v = v->next;
    }
    while (1);

    // insert a new wvert before v
    hlassume(numwverts < MAX_WVERTS, assume_MAX_WVERTS);

    newv = &wverts[numwverts];
    numwverts++;

    newv->t = t;
    newv->next = v;
    newv->prev = v->prev;
    v->prev->next = newv;
    v->prev = newv;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x48, %rbx
movapd 0x5083(%rip), %xmm4     # 0x1e210
movsd 0x524b(%rip), %xmm1     # 0x1e3e0
movq (%rbx), %rbx
movsd (%rbx), %xmm2
movapd %xmm2, %xmm3
subsd %xmm0, %xmm3
andpd %xmm4, %xmm3
ucomisd %xmm3, %xmm1
ja 0x19217
ucomisd %xmm0, %xmm2
ja 0x191ba
addq $0x10, %rbx
jmp 0x19195
xorl %edi, %edi
cmpl $0x40000, 0x3a318ea(%rip) # imm = 0x40000
setl %dil
pushq $0x14
popq %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x92bb
movslq 0x3a318d1(%rip), %rax   # 0x3a4aab0
imulq $0x18, %rax, %rcx
leaq 0x4431926(%rip), %rdx   # 0x444ab10
leaq (%rdx,%rcx), %rsi
incl %eax
movl %eax, 0x3a318ba(%rip)   # 0x3a4aab0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rcx,%rdx)
movq %rbx, 0x10(%rcx,%rdx)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rcx,%rdx)
movq %rsi, 0x10(%rax)
movq %rsi, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/writebsp.cpp
// Function: OutputEdges_face(face_s*)
void OutputEdges_face (face_t *f)
{
	if (CheckFaceForHint(f)
		|| CheckFaceForSkip(f)
#ifdef ZHLT_NULLTEX
        || CheckFaceForNull(f)  // AJM
#endif
#ifdef HLCSG_HLBSP_SOLIDHINT
		|| CheckFaceForDiscardable (f)
#endif
#ifdef HLCSG_HLBSP_VOIDTEXINFO
		|| f->texturenum == -1
#endif
#ifdef HLBSP_REMOVECOVEREDFACES
		|| f->referenced == 0
#endif
		|| CheckFaceForEnv_Sky(f)//Cpt_Andrew - Env_Sky Check
		)
	{
		return;
	}
	f->outputedges = (int *)malloc (f->numpoints * sizeof (int));
	hlassume (f->outputedges != NULL, assume_NoMemory);
	int i;
	for (i = 0; i < f->numpoints; i++)
	{
		int e = GetEdge (f->pts[i], f->pts[(i + 1) % f->numpoints], f);
		f->outputedges[i] = e;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x13634
testb %al, %al
jne 0x1945a
movq %rbx, %rdi
callq 0x13656
testb %al, %al
jne 0x1945a
movq %rbx, %rdi
callq 0x135b8
testb %al, %al
jne 0x1945a
movq %rbx, %rdi
callq 0x13678
testb %al, %al
jne 0x1945a
cmpl $-0x1, 0xc(%rbx)
je 0x1945a
cmpl $0x0, 0x34(%rbx)
je 0x1945a
movq %rbx, %rdi
callq 0x13612
testb %al, %al
je 0x19464
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movslq 0x2c(%rbx), %rdi
shlq $0x2, %rdi
callq 0x4410
movq %rax, 0x18(%rbx)
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
leaq 0x38(%rbx), %r12
xorl %r13d, %r13d
movq %r12, %r14
movslq 0x2c(%rbx), %rcx
cmpq %rcx, %r13
jge 0x1945a
leaq 0x1(%r13), %r15
movl %r15d, %eax
cltd
idivl %ecx
imulq $0x18, %rdx, %rsi
addq %r12, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x17e87
movq 0x18(%rbx), %rcx
movl %eax, (%rcx,%r13,4)
addq $0x18, %r14
movq %r15, %r13
jmp 0x19490
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1953f
movl %esi, %ebp
movq %rdi, %r14
leaq 0x98(%rdi), %r15
pushq $-0x1
popq %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x1950f
movl 0x14(%r15), %eax
cmpl %ebx, %eax
movl %ebx, %ecx
cmovll %eax, %ecx
cmpl $-0x1, %ebx
cmovel %eax, %ecx
cmpl %ebp, %eax
cmovgl %ecx, %ebx
jne 0x194e5
movq %r15, %rdi
callq 0x19409
jmp 0x194e5
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0x19542
movq 0x88(%r14,%r15,8), %rdi
movl %ebp, %esi
callq 0x194c6
cmpl %ebx, %eax
movl %ebx, %ecx
cmovll %eax, %ecx
cmpl $-0x1, %ebx
cmovel %eax, %ecx
cmpl $-0x1, %eax
cmovnel %ecx, %ebx
incq %r15
jmp 0x19512
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x18, %rsp
movl %edi, %eax
andl $-0x2, %eax
movl %eax, 0xc(%rsp)
leaq 0x20b84c4(%rip), %rcx   # 0x20d2a10
cmpb $0x0, (%rcx)
jne 0x1a5ff
leaq 0x4a345c4(%rip), %rdi   # 0x4a4eb20
leaq 0xc(%rsp), %rsi
callq 0x1a662
leaq 0x4a345bb(%rip), %rcx   # 0x4a4eb28
cmpq %rcx, %rax
je 0x1a57a
movl 0x24(%rax), %eax
jmp 0x1a5ff
xorl %edi, %edi
cmpl $0x8000, 0x4a345fe(%rip) # imm = 0x8000
setl %dil
pushq $0x23
popq %rsi
callq 0x92bb
movslq 0xc(%rsp), %rax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
shlq $0x6, %rax
leaq 0x20b8477(%rip), %rcx   # 0x20d2a20
movslq 0x4a345d4(%rip), %rdx   # 0x4a4eb84
movl %edx, 0x4(%rsi)
shlq $0x6, %rdx
leaq 0x4b745b2(%rip), %rdi   # 0x4b8eb70
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 0x4a34535(%rip), %rdi   # 0x4a4eb20
callq 0x1a6b4
movl 0x4a3458e(%rip), %eax   # 0x4a4eb84
leal 0x1(%rax), %ecx
movl %ecx, 0x4a34585(%rip)   # 0x4a4eb84
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ea0(%rip), %rsi      # 0xa7ca
callq 0x3074
testb %al, %al
je 0x294e
pushq $0x20
popq %rdi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5548
jmp 0x2a2e
leaq 0x7e78(%rip), %rsi      # 0xa7cd
movq %r14, %rdi
callq 0x3074
testb %al, %al
je 0x297c
pushq $0x20
popq %rdi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x565e
jmp 0x2a2e
leaq 0x7e4d(%rip), %rsi      # 0xa7d0
movq %r14, %rdi
callq 0x3074
testb %al, %al
je 0x29aa
pushq $0x20
popq %rdi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x57d6
jmp 0x2a2e
leaq 0x7e22(%rip), %rsi      # 0xa7d3
movq %r14, %rdi
callq 0x3074
testb %al, %al
je 0x29d5
pushq $0x20
popq %rdi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5886
jmp 0x2a2e
leaq 0x7dfa(%rip), %rsi      # 0xa7d6
movq %r14, %rdi
callq 0x3074
testb %al, %al
je 0x2a00
pushq $0x20
popq %rdi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x592a
jmp 0x2a2e
leaq 0x7dd3(%rip), %rsi      # 0xa7da
movq %r14, %rdi
callq 0x3074
testb %al, %al
je 0x2a2b
pushq $0x20
popq %rdi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5ab2
jmp 0x2a2e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2a43
jmp 0x2a43
jmp 0x2a43
jmp 0x2a43
jmp 0x2a43
movq %rax, %rbx
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r15d, %r15d
movl (%rbx), %eax
movq 0x8(%rbx), %rdi
cmpq %rax, %r15
jae 0x351c
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x350f
movq %r14, %rdi
callq 0x25f8
movq %r14, %rdi
callq 0x2220
incq %r15
jmp 0x34f3
testq %rdi, %rdi
je 0x352b
popq %rbx
popq %r14
popq %r15
jmp 0x22a0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x10(%rdx), %rcx
movl 0x4(%rdi), %edx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x38ee
addl 0x38(%rcx), %edx
movl %edx, 0x4(%rbx)
jmp 0x38de
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2030
movq %rbx, 0x8(%rsp)
movq %rax, 0x8(%rbx)
leaq 0x10(%r14), %rbx
xorl %r15d, %r15d
movq %rbp, 0x10(%rsp)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x39bb
leaq 0x8(%rbx), %r13
movq 0x10(%rbx), %r12
movq %rbp, %rdi
movq %r13, %rsi
callq 0x495e
movl 0x28(%rax), %eax
movl %eax, 0x28(%r12)
movl %r15d, (%r12)
cmpl $-0x1, 0x4(%r12)
jne 0x3946
movl %r15d, 0x4(%r12)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl %r15d, %ecx
movq %r12, (%rax,%rcx,8)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x495e
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
addq $0x30, %r12
cmpq %r13, %rbp
je 0x39ae
leaq 0x20(%rbp), %rsi
movss 0x24(%rbp), %xmm0
movss %xmm0, 0x4(%rsp)
movq %r14, %rdi
callq 0x3dd2
movq %r12, %rdi
movq %rax, %rsi
callq 0x4a44
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbp, %rdi
callq 0x2270
movq %rax, %rbp
jmp 0x3970
incl %r15d
movq 0x10(%rsp), %rbp
jmp 0x390e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc435(%rip), %r14      # 0x11268
movq %r14, %rdi
callq 0x2320
movl 0x8(%rbx), %ebp
movq (%rbx), %rax
movq 0x10(%rax), %rax
movl (%rax), %r15d
movq %r14, %rdi
callq 0x21b0
cmpl %r15d, %ebp
jne 0x4e66
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc3fb(%rip), %r14      # 0x11268
leaq 0x64(%rip), %r15        # 0x4ed8
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %r14, %rdi
callq 0x2320
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 0x23d0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2200
movq %r14, %rdi
callq 0x2320
movl 0x8(%rbx), %ebp
movq %r14, %rdi
callq 0x21b0
movq (%rbx), %rax
movq 0x10(%rax), %rax
cmpl (%rax), %ebp
jb 0x4e7c
xorl %edi, %edi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x70(%rbp), %rax
movq %rax, -0x30(%rax)
pushq $0x1
popq %rcx
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 -0x38(%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
leaq -0xc0(%rbp), %rcx
andl $0x0, 0x8(%rcx)
movq %rdi, (%rcx)
leaq -0xa0(%rbp), %rax
movq %rax, 0x10(%rcx)
leaq -0x68(%rbp), %rax
movq %rax, 0x18(%rcx)
movl %esi, 0xc(%rcx)
xorl %r14d, %r14d
leaq -0x509(%rip), %r15      # 0x4e03
movq %r13, %r12
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jae 0x5334
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
leaq -0xc0(%rbp), %rcx
callq 0x23d0
incq %r14
addq $0x8, %r12
jmp 0x530f
xorl %r14d, %r14d
movl %eax, %eax
cmpq %rax, %r14
jae 0x5352
movq (%r13,%r14,8), %rdi
xorl %esi, %esi
callq 0x2200
incq %r14
movl 0x8(%rbx), %eax
jmp 0x5337
movq 0x18(%rbx), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x38ba
movq -0x30(%rbp), %rsp
leaq -0x68(%rbp), %rdi
callq 0x3a98
leaq -0xa0(%rbp), %rdi
callq 0x3b88
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5390
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3a98
leaq -0xa0(%rbp), %rdi
callq 0x3b88
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/rtackx[P]ComSim/projection.cpp
// Function: Projection::get_intersection(Node*&, Node*&) const
set<Node*> Projection::get_intersection(Node*& node1, Node*& node2) const
{
	vector<Node*> set_node1, set_node2;
	vector<Node*> neighbors_node1, neighbors_node2;

	neighbors_node1.reserve(node1->nb_neighbors);
	neighbors_node2.reserve(node2->nb_neighbors);
	for(auto k : node1->neighbor_weights)
		neighbors_node1.push_back(k.first);
	for(auto k : node2->neighbor_weights)
		neighbors_node2.push_back(k.first);

	set<Node*> intersection;

	sort(neighbors_node1.begin(), neighbors_node1.end());
	sort(neighbors_node2.begin(), neighbors_node2.end());

	set_intersection(neighbors_node1.begin(), neighbors_node1.end(),
					 neighbors_node2.begin(), neighbors_node2.end(),
					 inserter(intersection, intersection.begin()));

	return intersection;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
andq $0x0, 0x60(%rsp)
leaq 0x20(%rsp), %rdi
andq $0x0, 0x10(%rdi)
movaps %xmm0, 0x50(%rsp)
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%rdi)
movaps %xmm0, (%rsp)
movq (%rdx), %rax
movl 0x28(%rax), %esi
callq 0x5b8a
movq (%r14), %rax
movl 0x28(%rax), %esi
movq %rsp, %rdi
callq 0x5b8a
movq (%r15), %r13
addq $0x40, %r13
leaq 0x20(%rsp), %r15
leaq 0x40(%rsp), %r12
movq (%r13), %r13
testq %r13, %r13
je 0x5446
movups 0x8(%r13), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5b46
jmp 0x5426
movq (%r14), %r12
addq $0x40, %r12
movq %rsp, %r14
leaq 0x40(%rsp), %r15
movq (%r12), %r12
testq %r12, %r12
je 0x5476
movups 0x8(%r12), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5b46
jmp 0x5455
leaq 0x8(%rbx), %rax
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6484
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6484
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x18(%rbx), %r9
movq %rbx, %r8
callq 0x6a05
movq %rsp, %rdi
callq 0x5c76
leaq 0x20(%rsp), %rdi
callq 0x5c76
leaq 0x50(%rsp), %rdi
callq 0x5c76
leaq 0x70(%rsp), %rdi
callq 0x5c76
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5517
movq %rax, %r14
movq %rbx, %rdi
callq 0x5c2e
jmp 0x551a
jmp 0x5517
movq %rax, %r14
movq %rsp, %rdi
callq 0x5c76
leaq 0x20(%rsp), %rdi
callq 0x5c76
leaq 0x50(%rsp), %rdi
callq 0x5c76
leaq 0x70(%rsp), %rdi
callq 0x5c76
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rsi, %rdx
movq %rbx, %rcx
callq 0x53b0
movq (%r14), %rbp
addq $0x40, %rbp
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x10(%rsp), %r13
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x55d8
leaq 0x8(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6cc8
cmpq %r13, %rax
je 0x559a
movq (%r14), %rdi
addq $0x30, %rdi
movq %r12, %rsi
callq 0x4a44
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x559a
movq (%rbx), %r12
addq $0x40, %r12
leaq 0x8(%rsp), %r14
movq (%r12), %r12
testq %r12, %r12
je 0x5623
leaq 0x8(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6cc8
cmpq %r13, %rax
je 0x55e4
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x4a44
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x55e4
leaq 0x8(%rsp), %rdi
callq 0x5c2e
movss 0x4(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5648
jmp 0x5648
jmp 0x5648
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5c2e
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rsi, %rdx
movq %rbx, %rcx
callq 0x53b0
movq (%r14), %rbp
addq $0x40, %rbp
xorps %xmm1, %xmm1
leaq 0x20(%rsp), %r13
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x5719
movss %xmm1, 0x14(%rsp)
leaq 0x8(%rbp), %r12
movq (%r14), %rdi
addq $0x30, %rdi
movq %r12, %rsi
callq 0x4a44
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x6cc8
cmpq %r13, %rax
movss 0x14(%rsp), %xmm1
je 0x570d
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x5713
movss 0x10(%rsp), %xmm2
addss %xmm2, %xmm1
jmp 0x56b3
movq (%rbx), %r12
addq $0x40, %r12
leaq 0x18(%rsp), %r14
movq (%r12), %r12
testq %r12, %r12
je 0x578c
movss %xmm1, 0x14(%rsp)
leaq 0x8(%r12), %r15
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x4a44
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6cc8
cmpq %r13, %rax
movss 0x14(%rsp), %xmm1
je 0x5780
movss 0xc(%rsp), %xmm0
movss 0x10(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x5786
movss 0x10(%rsp), %xmm2
addss %xmm2, %xmm1
jmp 0x5725
movss 0xc(%rsp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5c2e
movss 0xc(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57c1
jmp 0x57c1
jmp 0x57c1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5c2e
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53b0
movq 0x18(%rbx), %rbx
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x10(%rsp), %r14
cmpq %r14, %rbx
je 0x586d
movq 0x20(%rbx), %rax
addq $0x40, %rax
xorps %xmm0, %xmm0
movq (%rax), %rax
testq %rax, %rax
je 0x5837
addss 0x10(%rax), %xmm0
jmp 0x5828
callq 0x22b0
cvtss2sd %xmm0, %xmm0
movsd 0x5070(%rip), %xmm1     # 0xa8b8
divsd %xmm0, %xmm1
cvtss2sd 0x4(%rsp), %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
callq 0x2270
movq %rax, %rbx
jmp 0x5818
leaq 0x8(%rsp), %rdi
callq 0x5c2e
movss 0x4(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53b0
movq 0x18(%rbx), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x18(%rsp), %rbx
cmpq %rbx, %rax
je 0x5913
movq 0x20(%rax), %rcx
addq $0x40, %rcx
xorps %xmm0, %xmm0
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x58e5
addss 0x10(%rcx), %xmm0
jmp 0x58d6
cvtss2sd %xmm0, %xmm0
movsd 0x4fc7(%rip), %xmm1     # 0xa8b8
divsd %xmm0, %xmm1
cvtss2sd 0xc(%rsp), %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rax, %rdi
callq 0x2270
jmp 0x58c6
leaq 0x10(%rsp), %rdi
callq 0x5c2e
movss 0xc(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rsi, %rdx
movq %rbx, %rcx
callq 0x53b0
movq (%r14), %rbp
addq $0x40, %rbp
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %r13
movss %xmm0, 0x8(%rsp)
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x59e8
leaq 0x8(%rbp), %r12
movq (%r14), %rdi
addq $0x30, %rdi
movq %r12, %rsi
callq 0x4a44
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x6cc8
cmpq %r13, %rax
je 0x59d0
movss 0x8(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x59d6
movss 0xc(%rsp), %xmm1
movss 0x10(%rsp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
jmp 0x5982
movq (%rbx), %r12
addq $0x40, %r12
xorps %xmm1, %xmm1
leaq 0x18(%rsp), %r14
movq (%r12), %r12
testq %r12, %r12
je 0x5a5e
movss %xmm1, 0xc(%rsp)
leaq 0x8(%r12), %r15
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x4a44
movss (%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6cc8
cmpq %r13, %rax
movss 0xc(%rsp), %xmm1
je 0x5a52
movss 0x8(%rsp), %xmm0
movss 0x14(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x5a58
movss 0x14(%rsp), %xmm2
addss %xmm2, %xmm1
jmp 0x59f7
movss 0x10(%rsp), %xmm0
mulss %xmm1, %xmm0
movss 0x8(%rsp), %xmm1
divss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5c2e
movss 0x8(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a9d
jmp 0x5a9d
jmp 0x5a9d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5c2e
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53b0
movq 0x18(%rbx), %rax
movss 0x4da8(%rip), %xmm0     # 0xa894
movss %xmm0, 0xc(%rsp)
leaq 0x18(%rsp), %rbx
cmpq %rbx, %rax
je 0x5b30
movq 0x20(%rax), %rcx
addq $0x40, %rcx
xorps %xmm0, %xmm0
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x5b16
addss 0x10(%rcx), %xmm0
jmp 0x5b07
movss 0xc(%rsp), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movq %rax, %rdi
callq 0x2270
jmp 0x5af7
leaq 0x10(%rsp), %rdi
callq 0x5c2e
movss 0xc(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
leaq 0x30(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq 0x80(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
xorl %eax, %eax
leaq 0xc(%rsp), %r13
leaq 0x8(%rsp), %rbp
movl %eax, 0x8(%rsp)
movq (%rbx), %rcx
cmpl (%rcx), %eax
jae 0x6e2b
movq 0x8(%rcx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
cmpl $0x0, 0x28(%rax)
je 0x6e11
movq %r15, %rdi
movq %rbp, %rsi
callq 0x774a
jmp 0x6e23
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7a92
movl 0x8(%rsp), %eax
incl %eax
jmp 0x6de9
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x6e5c
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6eda
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x734c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x76d4
leaq 0x30(%rsp), %rbx
movq 0x8(%rbx), %r14
subq (%rbx), %r14
shrq $0x2, %r14
leaq 0x50(%rsp), %rdi
addl 0x18(%rdi), %r14d
callq 0x78f2
movq %rbx, %rdi
callq 0x7a84
leaq 0x10(%rsp), %rdi
callq 0x7a84
movl %r14d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6eb0
jmp 0x6eb0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x78f2
leaq 0x30(%rsp), %rdi
callq 0x7a84
leaq 0x10(%rsp), %rdi
callq 0x7a84
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa8eb
testb $0x2, %al
jne 0xa91a
orl $0x2, %eax
jmp 0xa8f4
testb $0x2, %al
je 0xa91a
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 0xda66
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa930
testb $0x1, %dl
jne 0xa935
orl $0x1, %edx
jmp 0xa93d
testb $0x1, %dl
jne 0xa937
popq %rbp
retq
andl $0xfe, %edx
movl %edx, (%rdi)
movq 0x30(%rdi), %rax
movl 0xc(%rdi), %esi
movq %rax, %rdi
popq %rbp
jmp 0x10df2
nop
// File: /workspace/github_cpp_makefile_star2_O2/lega911[P]ijson/src/connect.cpp
// Function: Connect::on_send()
void Connect::on_send() {
    if(send_buffer.size()) {
        int sent = this->raw_send(send_buffer.ptr(), send_buffer.size());
        if(sent < 0) THROW("Not implemented: sent < 0");
        send_buffer.remove_left(sent);
    } else if(!direct_message.empty()) {
        if(server->log & 32) this->start_time = get_time();
        auto *dm = direct_message.front();
        direct_message.pop_front();
        GC gc(dm, GC::DirectMessage);

        int sent = this->raw_send(dm->data.ptr(), dm->data.size());
        if(sent < 0) THROW("Not implemented: sent < 0");

        if(sent != dm->data.size()) send_buffer.add(&dm->data.ptr()[sent], dm->data.size() - sent);
    }

    if(send_buffer.size() == 0) {
        if(this->keep_alive) {
            this->write_mode(false);
        } else {
            this->close();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movl 0x28(%rdi), %edx
testl %edx, %edx
je 0xa9c4
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
callq 0xa950
testl %eax, %eax
js 0xaa71
movq %r14, %rdi
movl %eax, %esi
callq 0xd1ca
jmp 0xaa49
movq 0x1a0(%rbx), %rax
cmpq %rax, 0x1c0(%rbx)
je 0xaa49
leaq 0x190(%rbx), %r12
movq 0x48(%rbx), %rcx
testb $0x20, 0x20(%rcx)
je 0xa9f8
callq 0x16a40
movq %rax, 0x1e0(%rbx)
movq 0x1a0(%rbx), %rax
movq (%rax), %r15
movq %r12, %rdi
callq 0xd1f4
leaq -0x38(%rbp), %rdi
pushq $0x2
popq %rdx
movq %r15, %rsi
callq 0xd21a
movq 0x28(%r15), %rsi
movl 0x30(%r15), %edx
movq %rbx, %rdi
callq 0xa950
testl %eax, %eax
js 0xaab2
movl 0x30(%r15), %edx
subl %eax, %edx
je 0xaa40
movl %eax, %esi
addq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0xd24c
leaq -0x38(%rbp), %rdi
callq 0xd2dc
cmpl $0x0, 0x28(%rbx)
jne 0xaa64
cmpb $0x1, 0x10(%rbx)
jne 0xaa61
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa8dc
jmp 0xaa64
orl $-0x1, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0xa170
movq %rax, %r14
leaq 0xd5f5(%rip), %rsi      # 0x18078
leaq 0xd5c7(%rip), %rdx      # 0x18051
leaq 0xd601(%rip), %r8       # 0x18092
pushq $0x2e
popq %rcx
movq %rax, %rdi
callq 0xe15c
leaq 0x15275(%rip), %rsi     # 0x1fd18
leaq 0x3a6c(%rip), %rdx      # 0xe516
movq %r14, %rdi
callq 0xa450
pushq $0x30
popq %rdi
callq 0xa170
movq %rax, %r14
leaq 0xd5b4(%rip), %rsi      # 0x18078
leaq 0xd586(%rip), %rdx      # 0x18051
leaq 0xd5c0(%rip), %r8       # 0x18092
pushq $0x37
popq %rcx
movq %rax, %rdi
callq 0xe15c
leaq 0x15234(%rip), %rsi     # 0x1fd18
leaq 0x3a2b(%rip), %rdx      # 0xe516
movq %r14, %rdi
callq 0xa450
movq %rax, %rbx
movq %r14, %rdi
callq 0xa200
jmp 0xab10
movq %rax, %rbx
movq %r14, %rdi
callq 0xa200
jmp 0xab19
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xd2dc
movq %rbx, %rdi
callq 0xa470
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd7a2
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xcdd8(%rip), %rsi      # 0x18742
callq 0xd5ee
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xd5ee
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0xcd92(%rip), %rsi      # 0x1871e
callq 0xd5ee
movq (%rbx), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0xb9aa
addq $0x20, %rdi
leaq 0xcda7(%rip), %rsi      # 0x1874c
callq 0xd5ee
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbf60
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x1, %esi
je 0xba49
cmpl $0xffff80a6, %esi       # imm = 0xFFFF80A6
je 0xba3a
cmpl $0xffff80a7, %esi       # imm = 0xFFFF80A7
je 0xba04
cmpl $0xffff80a8, %esi       # imm = 0xFFFF80A8
je 0xba22
cmpl $-0x1, %esi
je 0xba13
cmpl $0xffff8044, %esi       # imm = 0xFFFF8044
jne 0xba31
leaq 0xcdc1(%rip), %rax      # 0x187bd
movq %rax, -0x10(%rbp)
pushq $0x53
jmp 0xba56
leaq 0xce5e(%rip), %rax      # 0x18869
movq %rax, -0x10(%rbp)
pushq $0x58
jmp 0xba56
leaq 0xceff(%rip), %rax      # 0x18919
movq %rax, -0x10(%rbp)
pushq $0x5c
jmp 0xba56
leaq 0xcde8(%rip), %rax      # 0x18811
movq %rax, -0x10(%rbp)
pushq $0x57
jmp 0xba56
leaq 0xcf6d(%rip), %rax      # 0x189a5
jmp 0xba41
leaq 0xce81(%rip), %rax      # 0x188c2
movq %rax, -0x10(%rbp)
pushq $0x56
jmp 0xba56
leaq 0xcf26(%rip), %rax      # 0x18976
movq %rax, -0x10(%rbp)
pushq $0x2e
popq %rax
leaq -0x10(%rbp), %rsi
movl %eax, 0x8(%rsi)
callq 0xbe84
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x98, %rdi
andl $0x0, 0xa0(%rbx)
movl 0x8(%rsi), %eax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
movb $0x1, %r8b
xorl %ecx, %ecx
cmpq %rdx, %rsi
je 0xbae6
cmpb $0x20, (%r15,%rdx)
je 0xbab0
incq %rdx
jmp 0xba9f
testb $0x1, %r8b
je 0xbac0
incq %rdx
xorl %r8d, %r8d
movl %edx, %ecx
jmp 0xba9f
leal 0x1(%rcx), %eax
cmpl %edx, %eax
jge 0xbad4
movslq %ecx, %rsi
cmpb $0x2f, (%r15,%rsi)
cmovnel %ecx, %eax
movl %eax, %ecx
movslq %ecx, %rax
leaq (%r15,%rax), %rsi
subl %eax, %edx
callq 0xd3e4
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