LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: SplitNodeBrushes(brush_s*, node_s const*)
static void SplitNodeBrushes (brush_t *brushes, const node_t *node)
{
	brush_t *frontlist, *frontfrag;
	brush_t *backlist, *backfrag;
	brush_t *b, *next;
	const dplane_t *splitplane;
	frontlist = NULL;
	backlist = NULL;
	splitplane = &g_dplanes[node->planenum];
	for (b = brushes; b; b = next)
	{
		next = b->next;
		SplitBrush (b, splitplane, &frontfrag, &backfrag);
		if (frontfrag)
		{
			frontfrag->next = frontlist;
			frontlist = frontfrag;
		}
		if (backfrag)
		{
			backfrag->next = backlist;
			backlist = backfrag;
		}
	}
	node->children[0]->detailbrushes = frontlist;
	node->children[1]->detailbrushes = backlist;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rax
movslq 0x80(%rax), %rcx
leaq 0x20c338d(%rip), %rax   # 0x20efa30
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2c731
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x253b0
cmpq $0x0, 0x28(%rsp)
je 0x2c704
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2c723
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2c725
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2c6b8
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x88(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: UpdateStatus()
static void UpdateStatus(void)
{
	if(g_reportProgress)
	{
		++g_numProcessed;
		if((g_numProcessed / 500) > g_numReported)
		{
			g_numReported = (g_numProcessed / 500);
			Log("%d...",g_numProcessed);
		}
	}
}

// Assembly:
pushq %rax
testb $0x1, 0x32c2dcc(%rip)   # 0x32efa74
je 0x2ccf9
movl 0x32c2dc0(%rip), %eax   # 0x32efa70
addl $0x1, %eax
movl %eax, 0x32c2db7(%rip)   # 0x32efa70
movl 0x32c2db1(%rip), %eax   # 0x32efa70
movl $0x1f4, %ecx            # imm = 0x1F4
cltd
idivl %ecx
cmpl 0x32c2dab(%rip), %eax   # 0x32efa78
jle 0x2ccf7
movl 0x32c2d9b(%rip), %eax   # 0x32efa70
movl $0x1f4, %ecx            # imm = 0x1F4
cltd
idivl %ecx
movl %eax, 0x32c2d95(%rip)   # 0x32efa78
movl 0x32c2d87(%rip), %esi   # 0x32efa70
leaq 0xf02b(%rip), %rdi      # 0x3bd1b
movb $0x0, %al
callq 0xb060
jmp 0x2ccf9
popq %rax
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: FreeLeafBrushes(node_s*)
static void FreeLeafBrushes (node_t *leaf)
{
	brush_t *b, *next;
	for (b = leaf->detailbrushes; b; b = next)
	{
		next = b->next;
		FreeBrush (b);
	}
	leaf->detailbrushes = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2e000
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x250e0
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2dfd7
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: FreeLeafSurfs(node_s*)
static void     FreeLeafSurfs(node_t* leaf)
{
    surface_t*      surf;
    surface_t*      snext;
    face_t*         f;
    face_t*         fnext;

    for (surf = leaf->surfaces; surf; surf = snext)
    {
        snext = surf->next;
        for (f = surf->faces; f; f = fnext)
        {
            fnext = f->next;
            FreeFace(f);
        }
        FreeSurface(surf);
    }

    leaf->surfaces = NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2e098
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2e082
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x24f00
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2e059
movq 0x18(%rsp), %rdi
callq 0x24f40
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x2e036
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/surfaces.cpp
// Function: InitHash()
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:
subq $0x38, %rsp
leaq 0x36a75c5(%rip), %rdi   # 0x36d7aa0
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x4180
movl $0x0, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
jge 0x3052f
movslq 0x4(%rsp), %rcx
leaq 0x36af5ce(%rip), %rax   # 0x36dfad0
movsd 0xb84e(%rip), %xmm0     # 0x3bd58
movsd %xmm0, (%rax,%rcx,8)
movslq 0x4(%rsp), %rax
movsd 0xb834(%rip), %xmm0     # 0x3bd50
movsd %xmm0, 0x20(%rsp,%rax,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x304ef
movsd 0x20(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0xb381(%rip), %xmm1     # 0x3b8d0
divsd %xmm1, %xmm0
callq 0x4240
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x4510
cvttsd2si %xmm0, %eax
movl %eax, 0x36af56f(%rip)   # 0x36dfae8
movsd 0x28(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x4510
cvttsd2si %xmm0, %eax
movl %eax, 0x36af558(%rip)   # 0x36dfaec
movl 0x36af54e(%rip), %eax   # 0x36dfae8
imull 0x36af54b(%rip), %eax   # 0x36dfaec
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x305db
movl $0x2, %edi
leaq 0xb808(%rip), %rsi      # 0x3bdbc
movb $0x0, %al
callq 0xbb80
movl 0x36af527(%rip), %eax   # 0x36dfae8
addl $-0x1, %eax
movl %eax, 0x36af51e(%rip)   # 0x36dfae8
movl 0x36af51c(%rip), %eax   # 0x36dfaec
addl $-0x1, %eax
movl %eax, 0x36af513(%rip)   # 0x36dfaec
jmp 0x30594
cvtsi2sdl 0x36af505(%rip), %xmm0 # 0x36dfae8
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x36af4bf(%rip)  # 0x36dfab0
cvtsi2sdl 0x36af4f3(%rip), %xmm0 # 0x36dfaec
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x36af4b1(%rip)  # 0x36dfab8
leaq 0x36af4f2(%rip), %rax   # 0x36dfb00
movq %rax, 0x36af48b(%rip)   # 0x36dfaa0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/tjunc.cpp
// Function: tjunc(node_s*)
void            tjunc(node_t* headnode)
{
    vec3_t          maxs, mins;
    int             i;

    Verbose("---- tjunc ----\n");

    if (g_notjunc)
    {
        return;
    }

    //
    // identify all points on common edges
    //

    // origin points won't allways be inside the map, so extend the hash area 
    for (i = 0; i < 3; i++)
    {
        if (fabs(headnode->maxs[i]) > fabs(headnode->mins[i]))
        {
            maxs[i] = fabs(headnode->maxs[i]);
        }
        else
        {
            maxs[i] = fabs(headnode->mins[i]);
        }
    }
    VectorSubtract(vec3_origin, maxs, mins);

    InitHash(mins, maxs);

    numwedges = numwverts = 0;

    tjunc_find_r(headnode);

    Verbose("%i world edges  %i edge points\n", numwedges, numwverts);

    //
    // add extra vertexes on edges where needed
    //
    tjuncs = tjuncfaces = 0;

    tjunc_fix_r(headnode);

    Verbose("%i edges added by tjunctions\n", tjuncs);
    Verbose("%i faces added by tjunctions\n", tjuncfaces);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
leaq 0xb4f8(%rip), %rdi      # 0x3be08
movb $0x0, %al
callq 0xba90
leaq 0x20bf106(%rip), %rax   # 0x20efa24
testb $0x1, (%rax)
je 0x30928
jmp 0x30aab
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x309d7
movq 0x50(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd 0x68(%rax,%rcx,8), %xmm0
movaps 0x8b1e(%rip), %xmm1     # 0x39470
pand %xmm1, %xmm0
movq 0x50(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd 0x50(%rax,%rcx,8), %xmm1
movaps 0x8b03(%rip), %xmm2     # 0x39470
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3099f
movq 0x50(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd 0x68(%rax,%rcx,8), %xmm0
movaps 0x8ae2(%rip), %xmm1     # 0x39470
pand %xmm1, %xmm0
movslq 0xc(%rsp), %rax
movsd %xmm0, 0x30(%rsp,%rax,8)
jmp 0x309c5
movq 0x50(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd 0x50(%rax,%rcx,8), %xmm0
movaps 0x8aba(%rip), %xmm1     # 0x39470
pand %xmm1, %xmm0
movslq 0xc(%rsp), %rax
movsd %xmm0, 0x30(%rsp,%rax,8)
jmp 0x309c7
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x30930
leaq 0x7472(%rip), %rax      # 0x37e50
movsd (%rax), %xmm0
subsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x745b(%rip), %rax      # 0x37e50
movsd 0x8(%rax), %xmm0
subsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x7443(%rip), %rax      # 0x37e50
movsd 0x10(%rax), %xmm0
subsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x30ab0
movl $0x0, 0x3a37099(%rip)   # 0x3a67ad0
movl $0x0, 0x3a37093(%rip)   # 0x3a67ad4
movq 0x50(%rsp), %rdi
callq 0x30c10
movl 0x3a37083(%rip), %esi   # 0x3a67ad4
movl 0x3a37079(%rip), %edx   # 0x3a67ad0
leaq 0xb3bb(%rip), %rdi      # 0x3be19
movb $0x0, %al
callq 0xba90
movl $0x0, 0x3a37069(%rip)   # 0x3a67ad8
movl $0x0, 0x3a37063(%rip)   # 0x3a67adc
movq 0x50(%rsp), %rdi
callq 0x30c90
movl 0x3a37053(%rip), %esi   # 0x3a67adc
leaq 0xb3a9(%rip), %rdi      # 0x3be39
movb $0x0, %al
callq 0xba90
movl 0x3a3703b(%rip), %esi   # 0x3a67ad8
leaq 0xb3b3(%rip), %rdi      # 0x3be57
movb $0x0, %al
callq 0xba90
addq $0x58, %rsp
retq
// File: FreeSlave[P]vhlt/hlbsp/tjunc.cpp
// Function: InitHash(double const*, double const*)
static void     InitHash(const vec3_t mins, const vec3_t maxs)
{
    vec3_t          size;
    vec_t           volume;
    vec_t           scale;
    int             newsize[2];

#ifdef HLBSP_HASH_FIX
	// Let's ignore the parameters and make things more predictable, so there won't be strange cases such as division by 0 or extreme scaling values.
	VectorFill(hash_min, -8000);
	VectorFill(size, 16000);
#else
    VectorCopy(mins, hash_min);
    VectorSubtract(maxs, mins, size);
#endif
    memset(wedge_hash, 0, sizeof(wedge_hash));

    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
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd 0xb292(%rip), %xmm0     # 0x3bd58
movsd %xmm0, 0x3a37012(%rip)  # 0x3a67ae0
movsd 0xb282(%rip), %xmm0     # 0x3bd58
movsd %xmm0, 0x3a3700a(%rip)  # 0x3a67ae8
movsd 0xb272(%rip), %xmm0     # 0x3bd58
movsd %xmm0, 0x3a37002(%rip)  # 0x3a67af0
movsd 0xb25a(%rip), %xmm0     # 0x3bd50
movsd %xmm0, 0x20(%rsp)
movsd 0xb24c(%rip), %xmm0     # 0x3bd50
movsd %xmm0, 0x28(%rsp)
movsd 0xb23e(%rip), %xmm0     # 0x3bd50
movsd %xmm0, 0x30(%rsp)
leaq 0x3a2efb1(%rip), %rdi   # 0x3a5fad0
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x4180
movsd 0x20(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0xad85(%rip), %xmm1     # 0x3b8d0
divsd %xmm1, %xmm0
callq 0x4240
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x4510
cvttsd2si %xmm0, %eax
movl %eax, 0x3a36f83(%rip)   # 0x3a67af8
movsd 0x28(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x4510
cvttsd2si %xmm0, %eax
movl %eax, 0x3a36f6c(%rip)   # 0x3a67afc
movl 0x3a36f62(%rip), %eax   # 0x3a67af8
imull 0x3a36f5f(%rip), %eax   # 0x3a67afc
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x30bd7
movl $0x2, %edi
leaq 0xb20c(%rip), %rsi      # 0x3bdbc
movb $0x0, %al
callq 0xbb80
movl 0x3a36f3b(%rip), %eax   # 0x3a67af8
addl $-0x1, %eax
movl %eax, 0x3a36f32(%rip)   # 0x3a67af8
movl 0x3a36f30(%rip), %eax   # 0x3a67afc
addl $-0x1, %eax
movl %eax, 0x3a36f27(%rip)   # 0x3a67afc
jmp 0x30b90
cvtsi2sdl 0x3a36f19(%rip), %xmm0 # 0x3a67af8
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x3a36f23(%rip)  # 0x3a67b10
cvtsi2sdl 0x3a36f07(%rip), %xmm0 # 0x3a67afc
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x3a36f15(%rip)  # 0x3a67b18
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x80(%rax)
jne 0x30c29
jmp 0x30c7d
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x30c5b
movq 0x8(%rsp), %rdi
callq 0x30d30
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x30c3a
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x30c10
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x30c10
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/tjunc.cpp
// Function: tjunc_fix_r(node_s*)
static void     tjunc_fix_r(node_t* node)
{
    face_t*         f;
    face_t*         next;

    if (node->planenum == PLANENUM_LEAF)
    {
        return;
    }

    newlist = NULL;

    for (f = node->faces; f; f = next)
    {
        next = f->next;
        FixFaceEdges(f);
    }

    node->faces = newlist;

    tjunc_fix_r(node->children[0]);
    tjunc_fix_r(node->children[1]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x80(%rax)
jne 0x30ca9
jmp 0x30d23
movq $0x0, 0x4a36e7c(%rip) # 0x4a67b30
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x30cee
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x31940
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x30cc5
movq 0x4a36e3b(%rip), %rcx   # 0x4a67b30
movq 0x10(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x30c90
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x30c90
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/tjunc.cpp
// Function: AddFaceEdges(face_s const*)
static void     AddFaceEdges(const face_t* const f)
{
    int             i, j;

    for (i = 0; i < f->numpoints; i++)
    {
        j = (i + 1) % f->numpoints;
        AddEdge(f->pts[i], f->pts[j]);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x30d9f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movq 0x10(%rsp), %rcx
cltd
idivl 0x2c(%rcx)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
movslq 0x8(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x30db0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x30d41
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
subsd 0x18(%rsp), %xmm1
movaps 0x812d(%rip), %xmm0     # 0x39470
pand %xmm0, %xmm1
movsd 0x82b1(%rip), %xmm0     # 0x39600
ucomisd %xmm1, %xmm0
jbe 0x3135a
jmp 0x31418
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x3136d
jmp 0x31383
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x3132d
jmp 0x31383
cmpl $0x40000, 0x3a36743(%rip) # imm = 0x40000
setl %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x14, %esi
callq 0xbe90
movslq 0x3a36729(%rip), %rcx   # 0x3a67ad0
leaq 0x4436782(%rip), %rax   # 0x4467b30
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x3a36710(%rip), %eax   # 0x3a67ad0
addl $0x1, %eax
movl %eax, 0x3a36707(%rip)   # 0x3a67ad0
movsd 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x25d50
testb $0x1, %al
jne 0x32937
movq 0x10(%rsp), %rdi
callq 0x25da0
testb $0x1, %al
jne 0x32937
movq 0x10(%rsp), %rdi
callq 0x25c60
testb $0x1, %al
jne 0x32937
movq 0x10(%rsp), %rdi
callq 0x25df0
testb $0x1, %al
jne 0x32937
movq 0x10(%rsp), %rax
cmpl $-0x1, 0xc(%rax)
je 0x32937
movq 0x10(%rsp), %rax
cmpl $0x0, 0x34(%rax)
je 0x32937
movq 0x10(%rsp), %rdi
callq 0x25d00
testb $0x1, %al
jne 0x32937
jmp 0x3293c
jmp 0x329f5
movq 0x10(%rsp), %rax
movslq 0x2c(%rax), %rdi
shlq $0x2, %rdi
callq 0x43e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x329f5
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movq 0x10(%rsp), %rcx
cltd
idivl 0x2c(%rcx)
movslq %edx, %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movq 0x10(%rsp), %rdx
callq 0x2fe80
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3297f
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
cmpl $-0x1, 0x80(%rax)
jne 0x32a30
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x32b1c
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x32aab
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x14(%rsp), %eax
jle 0x32a82
cmpl $-0x1, 0x10(%rsp)
jne 0x32a66
movb $0x1, %al
testb $0x1, %al
jne 0x32a74
jmp 0x32a80
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x10(%rsp), %eax
jge 0x32a80
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x32a82
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x32a9a
movq 0x8(%rsp), %rdi
callq 0x328d0
jmp 0x32a9c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x32a41
movl $0x0, 0x4(%rsp)
cmpl $0x2, 0x4(%rsp)
jge 0x32b14
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq 0x88(%rax,%rcx,8), %rdi
movl 0x14(%rsp), %esi
callq 0x32a00
movl %eax, (%rsp)
cmpl $-0x1, (%rsp)
jne 0x32ae6
xorl %eax, %eax
testb $0x1, %al
jne 0x32afe
jmp 0x32b05
cmpl $-0x1, 0x10(%rsp)
jne 0x32af5
movb $0x1, %al
testb $0x1, %al
jne 0x32afe
jmp 0x32b05
movl (%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x32b05
movl (%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x32b07
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x32ab3
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/writebsp.cpp
// Function: RemoveCoveredFaces_r(node_s*)
static void RemoveCoveredFaces_r (node_t *node)
{
	if (node->isportalleaf)
	{
		if (node->contents == CONTENTS_SOLID)
		{
			return; // stop here, don't go deeper into children
		}
	}
	if (node->planenum == -1)
	{
		// this is a leaf
		if (node->iscontentsdetail)
		{
			return;
		}
		else
		{
			face_t **fp;
			for (fp = node->markfaces; *fp; fp++)
			{
				for (face_t *f = *fp; f; f = f->original) // for each tjunc subface
				{
					f->referenced++; // mark the face as referenced
				}
			}
		}
		return;
	}
	
	// this is a node
	for (face_t *f = node->faces; f; f = f->next)
	{
		f->referenced = 0; // clear the mark
	}

	RemoveCoveredFaces_r (node->children[0]);
	RemoveCoveredFaces_r (node->children[1]);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x49(%rax)
je 0x32bb9
movq 0x20(%rsp), %rax
cmpl $-0x2, 0xa0(%rax)
jne 0x32bb7
jmp 0x32c92
jmp 0x32bb9
movq 0x20(%rsp), %rax
cmpl $-0x1, 0x80(%rax)
jne 0x32c3c
movq 0x20(%rsp), %rax
testb $0x1, 0x4a(%rax)
je 0x32bd7
jmp 0x32c92
movq 0x20(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x32c38
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x32c26
movq 0x10(%rsp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x32c00
jmp 0x32c28
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x32be8
jmp 0x32c3a
jmp 0x32c92
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x32c70
movq 0x8(%rsp), %rax
movl $0x0, 0x34(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x32c4d
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x32b90
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x32b90
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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 $0x38, %rsp
movl %edi, 0x30(%rsp)
movl 0x30(%rsp), %eax
andl $-0x2, %eax
movl %eax, 0x30(%rsp)
leaq 0x20bb686(%rip), %rax   # 0x20efa20
testb $0x1, (%rax)
je 0x343ac
movl 0x30(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x34492
leaq 0x4a3778d(%rip), %rdi   # 0x4a6bb40
leaq 0x30(%rsp), %rsi
callq 0x35200
movq %rax, 0x28(%rsp)
leaq 0x4a37777(%rip), %rdi   # 0x4a6bb40
callq 0x35250
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x35230
testb $0x1, %al
jne 0x343e8
jmp 0x343fe
leaq 0x28(%rsp), %rdi
callq 0x35280
movl 0x4(%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x34492
cmpl $0x8000, 0x4a3779c(%rip) # imm = 0x8000
setl %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x23, %esi
callq 0xbe90
movslq 0x30(%rsp), %rax
leaq 0x20bb609(%rip), %rsi   # 0x20efa30
shlq $0x6, %rax
addq %rax, %rsi
movslq 0x4a3776f(%rip), %rax   # 0x4a6bba4
leaq 0x4b77754(%rip), %rdi   # 0x4babb90
shlq $0x6, %rax
addq %rax, %rdi
movl $0x40, %edx
callq 0x4260
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x4a37746(%rip), %rdx   # 0x4a6bba4
callq 0x352f0
leaq 0x4a376d6(%rip), %rdi   # 0x4a6bb40
leaq 0x18(%rsp), %rsi
callq 0x352a0
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movl 0x4a37721(%rip), %eax   # 0x4a6bba4
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x4a37716(%rip)   # 0x4a6bba4
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/writebsp.cpp
// Function: WriteTexinfo(int)
static int WriteTexinfo (int texinfo)
{
	if (texinfo < 0 || texinfo >= g_numtexinfo)
	{
		Error ("Bad texinfo number %d.\n", texinfo);
	}

	if (g_noopt)
	{
		return texinfo;
	}

	texinfomap_t::iterator it;
	it = g_texinfomap.find (texinfo);
	if (it != g_texinfomap.end ())
	{
		return it->second;
	}

	int c;
	hlassume (g_nummappedtexinfo < MAX_MAP_TEXINFO, assume_MAX_MAP_TEXINFO);
	c = g_nummappedtexinfo;
	g_mappedtexinfo[g_nummappedtexinfo] = g_texinfo[texinfo];
	g_texinfomap.insert (texinfomap_t::value_type (texinfo, g_nummappedtexinfo));
	g_nummappedtexinfo++;
	return c;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x40(%rsp)
cmpl $0x0, 0x40(%rsp)
jl 0x34d2e
movl 0x40(%rsp), %eax
leaq 0x117a692(%rip), %rcx   # 0x11af3bc
cmpl (%rcx), %eax
jl 0x34d40
movl 0x40(%rsp), %esi
leaq 0x744c(%rip), %rdi      # 0x3c185
movb $0x0, %al
callq 0xb510
leaq 0x20bacd9(%rip), %rax   # 0x20efa20
testb $0x1, (%rax)
je 0x34d59
movl 0x40(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x34e5f
leaq 0x38(%rsp), %rdi
callq 0x35bb0
leaq 0x4a36e06(%rip), %rdi   # 0x4a6bb70
leaq 0x40(%rsp), %rsi
callq 0x35200
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x4a36de6(%rip), %rdi   # 0x4a6bb70
callq 0x35250
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x35230
testb $0x1, %al
jne 0x34da9
jmp 0x34dbf
leaq 0x38(%rsp), %rdi
callq 0x35280
movl 0x4(%rax), %eax
movl %eax, 0x44(%rsp)
jmp 0x34e5f
cmpl $0x7fff, 0x4a36ddf(%rip) # imm = 0x7FFF
setl %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x26, %esi
callq 0xbe90
movl 0x4a36dc6(%rip), %eax   # 0x4a6bba8
movl %eax, 0x24(%rsp)
movslq 0x40(%rsp), %rax
leaq 0x117a5ce(%rip), %rsi   # 0x11af3c0
imulq $0x28, %rax, %rax
addq %rax, %rsi
movslq 0x4a36da8(%rip), %rax   # 0x4a6bba8
leaq 0x4a36da9(%rip), %rdi   # 0x4a6bbb0
imulq $0x28, %rax, %rax
addq %rax, %rdi
movl $0x28, %edx
callq 0x4260
leaq 0x1c(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x4a36d7f(%rip), %rdx   # 0x4a6bba8
callq 0x352f0
leaq 0x4a36d3b(%rip), %rdi   # 0x4a6bb70
leaq 0x1c(%rsp), %rsi
callq 0x352a0
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movl 0x4a36d5a(%rip), %eax   # 0x4a6bba8
addl $0x1, %eax
movl %eax, 0x4a36d51(%rip)   # 0x4a6bba8
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jae 0x6e08
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x1c(%rsp), %edx
movq (%rcx,%rdx,8), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x18(%rsp)
movq 0x8(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6dfb
movq 0x8(%rsp), %rdi
callq 0x36f0
movq 0x8(%rsp), %rdi
callq 0x3220
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6dab
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6e32
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x6e30
movq (%rsp), %rdi
callq 0x32c0
jmp 0x6e32
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: rtackx[P]ComSim/./libs.h
// Function: comp_pair::operator()(std::pair<unsigned int, float> const&, std::pair<unsigned int, float> const&) const
inline bool operator()(const pair<unsigned int, float>& lhs, const pair<unsigned int, float>& rhs) const 
	{
		if(lhs.second > rhs.second)
			return true;
		if(lhs.second < rhs.second)
			return false;

		return true;

		// if(lhs.first < rhs.first)
		//     return true;
		// return false;
	}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movss 0x4(%rax), %xmm0
movq -0x20(%rsp), %rax
ucomiss 0x4(%rax), %xmm0
jbe 0xc8ab
movb $0x1, -0x1(%rsp)
jmp 0xc8d0
movq -0x18(%rsp), %rax
movss 0x4(%rax), %xmm1
movq -0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc8cb
movb $0x0, -0x1(%rsp)
jmp 0xc8d0
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x14(%rsp)
leaq 0x23031(%rip), %rdi     # 0x312a0
callq 0x3380
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jne 0xe29f
leaq 0x2300d(%rip), %rdi     # 0x312a0
callq 0x31b0
xorl %eax, %eax
addq $0x48, %rsp
retq
leaq 0x22ffa(%rip), %rdi     # 0x312a0
callq 0x31b0
leaq 0x22fee(%rip), %rdi     # 0x312a0
callq 0x3380
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0x22fc8(%rip), %rdi     # 0x312a0
callq 0x31b0
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x63(%rip), %rdx        # 0xe350
leaq 0x8(%rsp), %rcx
callq 0x3440
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3200
leaq 0x22f94(%rip), %rdi     # 0x312a0
callq 0x3380
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x2c(%rsp)
leaq 0x22f7c(%rip), %rdi     # 0x312a0
callq 0x31b0
movl 0x2c(%rsp), %eax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jb 0xe2ab
xorl %eax, %eax
movl %eax, %edi
callq 0x3410
nopw (%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x77a0
leaq -0x80(%rbp), %rdi
callq 0x77b0
movq -0xd8(%rbp), %rax
movl 0x8(%rax), %ecx
movq %rsp, %rdx
movq %rdx, -0x88(%rbp)
leaq 0xf(,%rcx,8), %rsi
andq $-0x10, %rsi
movq %rsp, %rdx
subq %rsi, %rdx
movq %rdx, -0xd0(%rbp)
movq %rdx, %rsp
movq %rcx, -0x90(%rbp)
movl $0x0, -0xa8(%rbp)
movq %rax, -0xb0(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl $0x0, -0xb4(%rbp)
movq -0xd8(%rbp), %rcx
movl -0xb4(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0xef1e
movq -0xd0(%rbp), %rdi
movl -0xb4(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xce1(%rip), %rdx      # 0xe220
leaq -0xb0(%rbp), %rcx
callq 0x3440
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0xeed0
movl $0x0, -0xb4(%rbp)
movq -0xd8(%rbp), %rcx
movl -0xb4(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0xef8f
movq -0xd0(%rbp), %rax
movl -0xb4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3200
jmp 0xef56
jmp 0xef58
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0xef28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x79d0
leaq -0x48(%rbp), %rdi
callq 0x79e0
jmp 0xefca
movq -0xd8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x74e0
jmp 0xefa9
movq -0x88(%rbp), %rax
movq %rax, %rsp
leaq -0x80(%rbp), %rdi
callq 0x79d0
leaq -0x48(%rbp), %rdi
callq 0x79e0
movq %rbp, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
leaq 0xa0(%rsp), %rdi
callq 0xefe0
xorps %xmm0, %xmm0
movss %xmm0, 0x9c(%rsp)
movq 0xd8(%rsp), %rax
movq (%rax), %rax
addq $0x30, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0x107e0
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rdi
callq 0x10810
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x10840
testb $0x1, %al
jne 0xf50f
jmp 0xf5dc
leaq 0x88(%rsp), %rdi
callq 0x10860
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x10d10
movq %rax, 0x20(%rsp)
jmp 0xf53a
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x10d50
movq %rax, 0x58(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x10cf0
testb $0x1, %al
jne 0xf56b
jmp 0xf5c8
movq 0xd8(%rsp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq 0x78(%rsp), %rsi
callq 0x7c60
movq %rax, 0x18(%rsp)
jmp 0xf58b
movq 0x18(%rsp), %rax
movss (%rax), %xmm0
addss 0x9c(%rsp), %xmm0
movss %xmm0, 0x9c(%rsp)
jmp 0xf5c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x10ce0
jmp 0xf6f5
jmp 0xf5ca
leaq 0x88(%rsp), %rdi
callq 0x10880
jmp 0xf4f1
movq 0xd0(%rsp), %rax
movq (%rax), %rax
addq $0x30, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x107e0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x10810
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10840
testb $0x1, %al
jne 0xf626
jmp 0xf6cb
leaq 0x48(%rsp), %rdi
callq 0x10860
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x10d10
movq %rax, 0x10(%rsp)
jmp 0xf64e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x10d50
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x10cf0
testb $0x1, %al
jne 0xf67f
jmp 0xf6ba
movq 0xd0(%rsp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq 0x38(%rsp), %rsi
callq 0x7c60
movq %rax, 0x8(%rsp)
jmp 0xf69f
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
addss 0x9c(%rsp), %xmm0
movss %xmm0, 0x9c(%rsp)
jmp 0xf6bc
leaq 0x48(%rsp), %rdi
callq 0x10880
jmp 0xf60e
movss 0x9c(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x10ce0
movss 0x4(%rsp), %xmm0
addq $0xe8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x3400
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq 0x90(%rsp), %rcx
leaq 0x60(%rsp), %rdi
callq 0xefe0
xorps %xmm0, %xmm0
movss %xmm0, 0x5c(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x10cb0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x10d50
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10cf0
testb $0x1, %al
jne 0xfb3a
jmp 0xfc31
leaq 0x48(%rsp), %rdi
callq 0x10d80
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
addq $0x30, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x107e0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x10810
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x10840
testb $0x1, %al
jne 0xfb96
jmp 0xfbc7
leaq 0x28(%rsp), %rdi
callq 0x10860
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movss 0x8(%rax), %xmm0
addss 0x58(%rsp), %xmm0
movss %xmm0, 0x58(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x10880
jmp 0xfb81
movss 0x58(%rsp), %xmm0
callq 0x10da0
movss %xmm0, 0x8(%rsp)
jmp 0xfbda
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x12cc4(%rip), %xmm1    # 0x228b0
divsd %xmm0, %xmm1
movss 0x5c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x5c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x10dc0
jmp 0xfb22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x10ce0
jmp 0xfc55
movss 0x5c(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x10ce0
movss 0x4(%rsp), %xmm0
addq $0xa8, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x3400
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0xefe0
xorps %xmm0, %xmm0
movss %xmm0, 0x4c(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10cb0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10d50
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10cf0
testb $0x1, %al
jne 0xfd2a
jmp 0xfdf4
leaq 0x38(%rsp), %rdi
callq 0x10d80
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x48(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
addq $0x30, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x107e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10810
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10840
testb $0x1, %al
jne 0xfd86
jmp 0xfdb7
leaq 0x18(%rsp), %rdi
callq 0x10860
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
addss 0x48(%rsp), %xmm0
movss %xmm0, 0x48(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x10880
jmp 0xfd71
movss 0x48(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x12ae7(%rip), %xmm1    # 0x228b0
divsd %xmm0, %xmm1
movss 0x4c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x10dc0
jmp 0xfd12
movss 0x4c(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x10ce0
movss 0x4(%rsp), %xmm0
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0xefe0
movss 0x11dcb(%rip), %xmm0    # 0x22004
movss %xmm0, 0x4c(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10cb0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10d50
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10cf0
testb $0x1, %al
jne 0x1027f
jmp 0x1032d
leaq 0x38(%rsp), %rdi
callq 0x10d80
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x48(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
addq $0x30, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x107e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10810
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10840
testb $0x1, %al
jne 0x102db
jmp 0x1030c
leaq 0x18(%rsp), %rdi
callq 0x10860
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
addss 0x48(%rsp), %xmm0
movss %xmm0, 0x48(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x10880
jmp 0x102c6
movss 0x48(%rsp), %xmm0
mulss 0x4c(%rsp), %xmm0
movss %xmm0, 0x4c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x10dc0
jmp 0x10267
movss 0x4c(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x10ce0
movss 0x4(%rsp), %xmm0
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x18c30
leaq 0x68(%rsp), %rdi
callq 0x18c30
leaq 0x30(%rsp), %rdi
callq 0x18c40
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x98(%rsp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jae 0x1734c
movq 0x98(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x2c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x28(%rax)
jne 0x17326
movq 0x98(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x2c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, 0x28(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x18c50
jmp 0x172f0
jmp 0x1733c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x18d20
leaq 0x68(%rsp), %rdi
callq 0x18d30
leaq 0x80(%rsp), %rdi
callq 0x18d30
jmp 0x17402
leaq 0x80(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x18c80
jmp 0x1733a
jmp 0x1733c
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1728d
leaq 0x80(%rsp), %rdi
callq 0x18cf0
cmpq $0x0, %rax
jbe 0x1739b
movq 0x10(%rsp), %rdi
movq 0x98(%rsp), %rsi
leaq 0x80(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x17410
jmp 0x17380
movq 0x10(%rsp), %rdi
movq 0x98(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x18270
jmp 0x17399
jmp 0x1739b
movq 0x10(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x18ad0
jmp 0x173af
leaq 0x30(%rsp), %rdi
callq 0x18d10
movq %rax, (%rsp)
leaq 0x68(%rsp), %rdi
callq 0x18cf0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x18d20
leaq 0x68(%rsp), %rdi
callq 0x18d30
leaq 0x80(%rsp), %rdi
callq 0x18d30
movl 0xc(%rsp), %eax
addq $0xa8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3400
nopl (%rax)