LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FreeSlave[P]vhlt/hlrad/trace.cpp
// Function: DeleteOpaqueNodes()
void DeleteOpaqueNodes ()
{
	int i;
	for (i = 0; i < g_numfaces; i++)
	{
		opaqueface_t *of = &opaquefaces[i];
		if (of->winding)
			delete of->winding;
		if (of->edges)
			free (of->edges);
	}
	free (opaquefaces);
	free (opaquenodes);
	free (opaquemodels);
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
leaq 0x1b81ffd(%rip), %rcx   # 0x1be6404
cmpl (%rcx), %eax
jge 0x64475
movq 0x66cb6e6(%rip), %rax   # 0x672faf8
movslq 0x14(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x6444c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x6444a
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6444c
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x64466
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x43a0
jmp 0x64468
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x643fc
movq 0x66cb67c(%rip), %rdi   # 0x672faf8
callq 0x43a0
movq 0x66cb678(%rip), %rdi   # 0x672fb00
callq 0x43a0
movq 0x66cb674(%rip), %rdi   # 0x672fb08
callq 0x43a0
addq $0x18, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlrad/trace.cpp
// Function: CountOpaqueFaces_r(opaquenode_s*)
int CountOpaqueFaces_r (opaquenode_t *node)
{
	int count;
	count = node->numfaces;
	if (node->children[0] >= 0)
	{
		count += CountOpaqueFaces_r (&opaquenodes[node->children[0]]);
	}
	if (node->children[1] >= 0)
	{
		count += CountOpaqueFaces_r (&opaquenodes[node->children[1]]);
	}
	return count;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jl 0x65244
movq 0x66ca8d9(%rip), %rdi   # 0x672fb00
movq 0x10(%rsp), %rax
movslq 0x14(%rax), %rax
imulq $0x24, %rax, %rax
addq %rax, %rdi
callq 0x65200
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jl 0x65273
movq 0x66ca8aa(%rip), %rdi   # 0x672fb00
movq 0x10(%rsp), %rax
movslq 0x18(%rax), %rax
imulq $0x24, %rax, %rax
addq %rax, %rdi
callq 0x65200
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlrad/transparency.cpp
// Function: SortList(void const*, void const*)
static int CDECL SortList(const void *a, const void *b)
{
	const transList_t* item1 = (transList_t *)a;
	const transList_t* item2 = (transList_t *)b;
	
	if( item1->p1 == item2->p1 )
	{
		return item1->p2 - item2->p2;
	}
	else
	{
		return item1->p1 - item2->p1;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x28(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x66224
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rsp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x4(%rsp)
jmp 0x66236
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x28(%rsp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/transparency.cpp
// Function: FreeTransparencyArrays()
void	FreeTransparencyArrays( )
{
	if (s_sorted_list) free(s_sorted_list);
	if (s_trans_list)  free(s_trans_list);
	
	s_trans_list = NULL;
	s_sorted_list = NULL;
	
	s_max_trans_count = s_trans_count = s_sorted_count = 0;
}

// Assembly:
pushq %rax
cmpq $0x0, 0x66c98df(%rip)   # 0x672fb28
je 0x66257
movq 0x66c98d6(%rip), %rdi   # 0x672fb28
callq 0x43a0
cmpq $0x0, 0x66c98d9(%rip)   # 0x672fb38
je 0x6626d
movq 0x66c98d0(%rip), %rdi   # 0x672fb38
callq 0x43a0
movq $0x0, 0x66c98c0(%rip) # 0x672fb38
movq $0x0, 0x66c98a5(%rip) # 0x672fb28
movl $0x0, 0x66c9893(%rip)   # 0x672fb20
movl $0x0, 0x66c989d(%rip)   # 0x672fb34
movl $0x0, 0x66c988f(%rip)   # 0x672fb30
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/transparency.cpp
// Function: CreateFinalStyleArrays(char const*)
void	CreateFinalStyleArrays(const char *print_name)
{
	if( s_style_count == 0 )
	{
		return;
	}
	//need to sorted for fast search function
	qsort( s_style_list, s_style_count, sizeof(styleList_t), SortStyleList );
	
#ifdef ZHLT_64BIT_FIX
	size_t size = s_max_style_count * sizeof(styleList_t);
#else
	unsigned size = s_max_style_count * sizeof(styleList_t);
#endif
	if ( size > 1024 * 1024 )
        	Log("%-20s: %5.1f megs \n", print_name, (double)size / (1024.0 * 1024.0));
        else if ( size > 1024 )
        	Log("%-20s: %5.1f kilos\n", print_name, (double)size / 1024.0);
        else
        	Log("%-20s: %5.1f bytes\n", print_name, (double)size); //--vluzacn
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpl $0x0, 0x66c9530(%rip)   # 0x672fb40
jne 0x66617
jmp 0x6672e
movq 0x66c952a(%rip), %rdi   # 0x672fb48
movl 0x66c951c(%rip), %eax   # 0x672fb40
movl %eax, %esi
movl $0xc, %edx
leaq 0x10e(%rip), %rcx       # 0x66740
callq 0x4630
movl 0x66c9507(%rip), %eax   # 0x672fb44
imulq $0xc, %rax, %rax
movq %rax, 0x8(%rsp)
cmpq $0x100000, 0x8(%rsp)    # imm = 0x100000
jbe 0x6669d
movq 0x10(%rsp), %rsi
movaps 0xb433(%rip), %xmm1     # 0x71a90
movq 0x8(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb431(%rip), %xmm1     # 0x71aa0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x51da(%rip), %xmm1     # 0x6b860
divsd %xmm1, %xmm0
leaq 0xb7b2(%rip), %rdi      # 0x71e43
movb $0x1, %al
callq 0xb0d0
jmp 0x6672e
cmpq $0x400, 0x8(%rsp)       # imm = 0x400
jbe 0x666f1
movq 0x10(%rsp), %rsi
movaps 0xb3dc(%rip), %xmm1     # 0x71a90
movq 0x8(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb3da(%rip), %xmm1     # 0x71aa0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xb71b(%rip), %xmm1     # 0x71df8
divsd %xmm1, %xmm0
leaq 0xb76f(%rip), %rdi      # 0x71e57
movb $0x1, %al
callq 0xb0d0
jmp 0x6672c
movq 0x10(%rsp), %rsi
movaps 0xb393(%rip), %xmm1     # 0x71a90
movq 0x8(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb391(%rip), %xmm1     # 0x71aa0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
leaq 0xb746(%rip), %rdi      # 0x71e6b
movb $0x1, %al
callq 0xb0d0
jmp 0x6672e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/transparency.cpp
// Function: SortStyleList(void const*, void const*)
static int CDECL SortStyleList(const void *a, const void *b)
{
	const styleList_t* item1 = (styleList_t *)a;
	const styleList_t* item2 = (styleList_t *)b;
	
	if( item1->p1 == item2->p1 )
	{
		return item1->p2 - item2->p2;
	}
	else
	{
		return item1->p1 - item2->p1;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x28(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x66784
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rsp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x4(%rsp)
jmp 0x66796
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x28(%rsp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/transparency.cpp
// Function: GetStyle(unsigned int, unsigned int, int&, unsigned int&)
void GetStyle(const unsigned p1, const unsigned p2, int &style, unsigned int &next_index)
{
	style = -1;
	
	for( unsigned i = next_index; i < s_style_count; i++ )
	{
		if ( s_style_list[i].p1 < p1 )
		{
			continue;
		}
		else if ( s_style_list[i].p1 == p1 )
		{
			if ( s_style_list[i].p2 < p2 )
			{
				continue;
			}
			else if ( s_style_list[i].p2 == p2 )
			{
				style = (int)s_style_list[i].style;
				next_index = i + 1;
			
				return;
			}
			else //if ( s_style_list[i].p2 > p2 )
			{
				next_index = i;
			
				return;
			}
		}
		else //if ( s_style_list[i].p1 > p1 )
		{
			next_index = i;
			
			return;
		}
	}
	
	next_index = s_style_count;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl 0x66c932e(%rip), %eax   # 0x672fb40
jae 0x668e0
movq 0x66c9329(%rip), %rax   # 0x672fb48
movl -0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rsp), %eax
jae 0x66837
jmp 0x668d0
movq 0x66c930a(%rip), %rax   # 0x672fb48
movl -0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rsp), %eax
jne 0x668c3
movq 0x66c92f0(%rip), %rax   # 0x672fb48
movl -0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rsp), %eax
jae 0x6686e
jmp 0x668d0
movq 0x66c92d3(%rip), %rax   # 0x672fb48
movl -0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rsp), %eax
jne 0x668b6
movq 0x66c92b8(%rip), %rax   # 0x672fb48
movl -0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movsbl 0x8(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x668ed
movl -0x1c(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x668ed
movl -0x1c(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x668ed
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x66808
movl 0x66c925a(%rip), %ecx   # 0x672fb40
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
retq
nop
// File: FreeSlave[P]vhlt/hlrad/vismatrix.cpp
// Function: BuildVisMatrix()
static void     BuildVisMatrix()
{
    int             c;

#ifdef HALFBIT
    c = ((g_num_patches + 1) * (g_num_patches + 1)) / 16;
	c += 1; //--vluzacn
#else
    c = g_num_patches * ((g_num_patches + 7) / 8);
#endif

    Log("%-20s: %5.1f megs\n", "visibility matrix", c / (1024 * 1024.0));

    s_vismatrix = (byte*)AllocBlock(c);

    if (!s_vismatrix)
    {
        Log("Failed to allocate s_vismatrix");
        hlassume(s_vismatrix != NULL, assume_NoMemory);
    }

#ifdef HLRAD_VIS_FIX
    NamedRunThreadsOn(g_dmodels[0].visleafs, g_estimate, BuildVisLeafs);
#else
    NamedRunThreadsOn(g_numleafs - 1, g_estimate, BuildVisLeafs);
#endif
}

// Assembly:
pushq %rax
leaq 0x5406fa0(%rip), %rax   # 0x546da08
movl (%rax), %eax
addl $0x1, %eax
leaq 0x5406f94(%rip), %rcx   # 0x546da08
movl (%rcx), %ecx
addl $0x1, %ecx
imull %ecx, %eax
shrl $0x4, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
cvtsi2sdl 0x4(%rsp), %xmm0
movsd 0x4dc4(%rip), %xmm1     # 0x6b860
divsd %xmm1, %xmm0
leaq 0xb0d5(%rip), %rdi      # 0x71b7c
leaq 0xb0e1(%rip), %rsi      # 0x71b8f
movb $0x1, %al
callq 0xb0d0
movslq 0x4(%rsp), %rdi
callq 0x47a0
movq %rax, 0x66c908a(%rip)   # 0x672fb50
cmpq $0x0, 0x66c9082(%rip)   # 0x672fb50
jne 0x66af9
leaq 0xb436(%rip), %rdi      # 0x71f0d
movb $0x0, %al
callq 0xb0d0
cmpq $0x0, 0x66c906a(%rip)   # 0x672fb50
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbf00
leaq 0xafe1(%rip), %rdi      # 0x71ae1
callq 0xb2f0
movq %rax, %rsi
leaq 0x7b8e(%rip), %rdi      # 0x6e69d
movb $0x0, %al
callq 0xb0d0
leaq 0x17963(%rip), %rax     # 0x7e480
movl 0x34(%rax), %edi
leaq 0x1790d(%rip), %rax     # 0x7e434
movb (%rax), %al
leaq 0x190(%rip), %rdx       # 0x66cc0
andb $0x1, %al
movzbl %al, %esi
callq 0xd2a0
popq %rax
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlrad/vismatrix.cpp
// Function: CheckVisBitVismatrix(unsigned int, unsigned int, float (&) [3], unsigned int&)
static bool     CheckVisBitVismatrix(unsigned p1, unsigned p2
#ifdef HLRAD_HULLU
									 , vec3_t &transparency_out
									 , unsigned int &next_index
#endif
									 )
{
    unsigned        bitpos;

#ifdef HLRAD_HULLU
    const unsigned a = p1;
    const unsigned b = p2;

    VectorFill(transparency_out, 1.0);
#endif

    if (p1 > p2)
    {
#ifndef HLRAD_HULLU
        const unsigned a = p1;
        const unsigned b = p2;
#endif
        p1 = b;
        p2 = a;
    }

    if (p1 > g_num_patches)
    {
        Warning("in CheckVisBit(), p1 > num_patches");
    }
    if (p2 > g_num_patches)
    {
        Warning("in CheckVisBit(), p2 > num_patches");
    }

#ifdef HALFBIT
    bitpos = p1 * g_num_patches - (p1 * (p1 + 1)) / 2 + p2;
#else
    bitpos = p1 * g_num_patches + p2;
#endif

    if (s_vismatrix[bitpos >> 3] & (1 << (bitpos & 7)))
    {
#ifdef HLRAD_HULLU    	
    	if(g_customshadow_with_bouncelight)
    	{
    	    GetTransparency( a, b, transparency_out, next_index );
    	}
#endif
        return true;
    }

    return false;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movss 0x34d9(%rip), %xmm0     # 0x6a04c
movss %xmm0, (%rax)
movq 0x20(%rsp), %rax
movss 0x34c8(%rip), %xmm0     # 0x6a04c
movss %xmm0, 0x4(%rax)
movq 0x20(%rsp), %rax
movss 0x34b6(%rip), %xmm0     # 0x6a04c
movss %xmm0, 0x8(%rax)
movl 0x30(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jbe 0x66bb5
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x30(%rsp), %eax
leaq 0x5406e48(%rip), %rcx   # 0x546da08
cmpl (%rcx), %eax
jbe 0x66bd2
leaq 0xb361(%rip), %rdi      # 0x71f2c
movb $0x0, %al
callq 0xb9f0
movl 0x2c(%rsp), %eax
leaq 0x5406e2b(%rip), %rcx   # 0x546da08
cmpl (%rcx), %eax
jbe 0x66bef
leaq 0xb367(%rip), %rdi      # 0x71f4f
movb $0x0, %al
callq 0xb9f0
movl 0x30(%rsp), %eax
leaq 0x5406e0e(%rip), %rcx   # 0x546da08
imull (%rcx), %eax
movl 0x30(%rsp), %ecx
movl 0x30(%rsp), %edx
addl $0x1, %edx
imull %edx, %ecx
shrl %ecx
subl %ecx, %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x66c8f32(%rip), %rax   # 0x672fb50
movl 0x14(%rsp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl 0x14(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x66c6c
leaq 0x54c8dff(%rip), %rax   # 0x552fa48
testb $0x1, (%rax)
je 0x66c65
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x662b0
movb $0x1, 0x37(%rsp)
jmp 0x66c71
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlrad/vismatrixutil.cpp
// Function: FindTransferOffsetPatchnum(transfer_index_t*, patch_s const*, unsigned int)
int             FindTransferOffsetPatchnum(transfer_index_t* tIndex, const patch_t* const patch, const unsigned patchnum)
{
    //
    // binary search for match
    //
    int             low = 0;
    int             high = patch->iIndex - 1;
    int             offset;

    while (1)
    {
        offset = (low + high) / 2;

        if ((tIndex[offset].index + tIndex[offset].size) < patchnum)
        {
            low = offset + 1;
        }
        else if (tIndex[offset].index > patchnum)
        {
            high = offset - 1;
        }
        else
        {
            unsigned        x;
            unsigned int    rval = 0;
            transfer_index_t* pIndex = tIndex;

            for (x = 0; x < offset; x++, pIndex++)
            {
                rval += pIndex->size + 1;
            }
            rval += patchnum - tIndex[offset].index;
            return rval;
        }
        if (low > high)
        {
            return -1;
        }
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl 0x38(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rsp)
movl -0x20(%rsp), %eax
addl -0x24(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movslq -0x28(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0xc, %eax
movq -0x10(%rsp), %rcx
movslq -0x28(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
addl %ecx, %eax
cmpl -0x1c(%rsp), %eax
jae 0x67494
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x67537
movq -0x10(%rsp), %rax
movslq -0x28(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0xc, %eax
cmpl -0x1c(%rsp), %eax
jbe 0x674b7
movl -0x28(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x67535
movl $0x0, -0x30(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x38(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0x28(%rsp), %eax
jae 0x6750d
movq -0x38(%rsp), %rax
movl (%rax), %eax
andl $0xfff, %eax            # imm = 0xFFF
addl $0x1, %eax
addl -0x30(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
movq -0x38(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rsp)
jmp 0x674d1
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
movslq -0x28(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
shrl $0xc, %ecx
subl %ecx, %eax
addl -0x30(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x30(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x67550
jmp 0x67537
movl -0x20(%rsp), %eax
cmpl -0x24(%rsp), %eax
jle 0x6754b
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x67550
jmp 0x67445
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/vismatrixutil.cpp
// Function: GetLengthOfRun(unsigned int const*, unsigned int const*)
static unsigned GetLengthOfRun(const transfer_raw_index_t* raw, const transfer_raw_index_t* const end)
{
    unsigned        run_size = 0;

    while (raw < end)
    {
        if (((*raw) + 1) == (*(raw + 1)))
        {
            raw++;
            run_size++;

            if (run_size >= MAX_COMPRESSED_TRANSFER_INDEX_SIZE)
            {
                return run_size;
            }
        }
        else
        {
            return run_size;
        }
    }
    return run_size;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x697ad
movq -0x10(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movq -0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x697a1
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
cmpl $0xfff, -0x1c(%rsp)     # imm = 0xFFF
jb 0x6979f
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x697b5
jmp 0x697ab
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x697b5
jmp 0x69752
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: gtarcoder[P]libevent_utils/connection.cpp
// Function: Connection::PeerReadCallback(bufferevent*, void*)
void Connection::PeerReadCallback(struct bufferevent* bev, void* arg){
    Connection* item = (Connection*)arg;
    if(item->recv_raw_mode_){
        item->OnPeerRead();
    }else{
        struct evbuffer* input = bufferevent_get_input(bev);
        if(item->buffer_len_ < 0){
            evbuffer_remove(input, (void*)&item->buffer_len_, 4);   
            item->buffer_len_ = ntohl(item->buffer_len_);
        }
        if(item->buffer_len_ > 0 && item->buffer_len_ <= evbuffer_get_length(input)){
            evbuffer_remove(input, (void*)item->buffer_, item->buffer_len_); 
            item->buffer_[item->buffer_len_] = '\0';
            //process the data received
            item->OnPeerRead();
            //cleared the buffer
            item->buffer_len_ = -1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x10090(%rax)
je 0x26a4
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x2773
movq -0x8(%rbp), %rdi
callq 0x21e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1008c(%rax)
jge 0x26f2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1008c, %rsi          # imm = 0x1008C
movl $0x4, %edx
callq 0x2340
movq -0x18(%rbp), %rax
movl 0x1008c(%rax), %edi
callq 0x2350
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1008c(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1008c(%rax)
jle 0x2771
movq -0x18(%rbp), %rax
movslq 0x1008c(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x22f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
ja 0x2771
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8d, %rsi
movq -0x18(%rbp), %rax
movslq 0x1008c(%rax), %rdx
callq 0x2340
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x1008c(%rcx), %rcx
movb $0x0, 0x8d(%rax,%rcx)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x1008c(%rax) # imm = 0xFFFFFFFF
jmp 0x2773
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gtarcoder[P]libevent_utils/connection.cpp
// Function: Connection::Connection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, unsigned short, unsigned short)
Connection:: Connection(
    std::string peer_ip
    ,uint16_t peer_port
    ,uint16_t local_port
    ,uint16_t index 
    ):
    peer_ip_(peer_ip)
    ,peer_port_(peer_port)
    ,local_port_(local_port)
    ,index_(index)
    ,fd_(-1)
    ,connected_(false)
    ,buffer_len_(-1)
    ,recv_raw_mode_(false)
    ,send_raw_mode_(false)
    ,delconn_cb_(NULL)
{
  printf("local port : %u\n", local_port_);
  printf("peer port : %u\n", peer_port_);
  peer_event_ = NULL;
  conn_2_server_pair_[0] = conn_2_server_pair_[1] = NULL;
  server_2_conn_pair_[0] = server_2_conn_pair_[1] = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %dx, -0x12(%rbp)
movw %cx, -0x14(%rbp)
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0x844d(%rip), %rax      # 0xac70
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2d70
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0xffffffff, 0x58(%rdi) # imm = 0xFFFFFFFF
addq $0x60, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2150
jmp 0x2855
movq -0x40(%rbp), %rax
movw -0x12(%rbp), %cx
movw %cx, 0x80(%rax)
movw -0x14(%rbp), %cx
movw %cx, 0x82(%rax)
movw -0x16(%rbp), %cx
movw %cx, 0x84(%rax)
movb $0x0, 0x8c(%rax)
movl $0xffffffff, 0x1008c(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x10090(%rax)
movb $0x0, 0x10091(%rax)
movzwl 0x82(%rax), %esi
leaq 0x475d(%rip), %rdi      # 0x7004
xorl %eax, %eax
callq 0x2040
jmp 0x28b0
movq -0x40(%rbp), %rax
movzwl 0x80(%rax), %esi
leaq 0x4753(%rip), %rdi      # 0x7015
xorl %eax, %eax
callq 0x2040
jmp 0x28cb
movq -0x40(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x48(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2920
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21b0
movq -0x48(%rbp), %rdi
callq 0x2db0
movq -0x20(%rbp), %rdi
callq 0x2420
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/connection.cpp
// Function: Connection::~Connection()
Connection:: ~Connection(){
  printf("connection %u destroyed\n", index_);
  bufferevent_free(peer_event_);
  if(conn_2_server_pair_[0]){
    bufferevent_free(conn_2_server_pair_[0]);
    bufferevent_free(conn_2_server_pair_[1]);
  }
  if(server_2_conn_pair_[0]){
    bufferevent_free(server_2_conn_pair_[0]);
    bufferevent_free(server_2_conn_pair_[1]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x8315(%rip), %rcx      # 0xac70
movq %rcx, (%rax)
movzwl 0x84(%rax), %esi
leaq 0x46b9(%rip), %rdi      # 0x7025
xorl %eax, %eax
callq 0x2040
jmp 0x2975
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x20d0
jmp 0x2984
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x29af
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x20d0
jmp 0x299e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x20d0
jmp 0x29ad
jmp 0x29af
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x29da
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x20d0
jmp 0x29c9
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x20d0
jmp 0x29d8
jmp 0x29da
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x21b0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2db0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2dd0
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/connection.cpp
// Function: Connection::Start()
bool Connection::Start(){
    if (SetKeepLive(fd_, 20, 5, 3) < 0)
       return false;
    if (SetRecvSendBufSize(fd_, 0xfffff) < 0)
       return false;
    if(SetReuseAddr(fd_) < 0)
       return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x58(%rax), %edi
movl $0x14, %esi
movl $0x5, %edx
movl $0x3, %ecx
callq 0x6170
cmpl $0x0, %eax
jge 0x2a76
movb $0x0, -0x1(%rbp)
jmp 0x2aad
movq -0x18(%rbp), %rax
movl 0x58(%rax), %edi
movl $0xfffff, %esi          # imm = 0xFFFFF
callq 0x60e0
cmpl $0x0, %eax
jge 0x2a92
movb $0x0, -0x1(%rbp)
jmp 0x2aad
movq -0x18(%rbp), %rax
movl 0x58(%rax), %edi
callq 0x6080
cmpl $0x0, %eax
jge 0x2aa9
movb $0x0, -0x1(%rbp)
jmp 0x2aad
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gtarcoder[P]libevent_utils/connection.cpp
// Function: Connection::Initialize(event_base*, int, bool)
void Connection::Initialize(struct event_base* base, evutil_socket_t fd, bool write_callback_on){
    fd_ = fd;
    base_ = base;
    peer_event_ = bufferevent_socket_new(base, fd_, BEV_OPT_CLOSE_ON_FREE);
    if(!peer_event_){
        printf("create bufferevent failed in %s:%s!\n", __FILE__, __func__);
        fd_ = -1;
        return;
    }
    bufferevent_setcb(peer_event_, PeerReadCallback, write_callback_on? PeerWriteCallback: NULL, PeerEventCallback, this);
    bufferevent_enable(peer_event_, EV_WRITE|EV_READ);
    //for TCP packet, we have 4 bytes-len head
    bufferevent_setwatermark(peer_event_, EV_READ, 4, 0xfffff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movl 0x58(%rax), %esi
movl $0x1, %edx
callq 0x23f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
jne 0x2b3c
leaq 0x4524(%rip), %rdi      # 0x703e
leaq 0x4542(%rip), %rsi      # 0x7063
leaq 0x454a(%rip), %rdx      # 0x7072
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
jmp 0x2b9a
movq -0x20(%rbp), %r8
movq 0x28(%r8), %rdi
movb -0x15(%rbp), %cl
xorl %eax, %eax
movl %eax, %edx
leaq -0x3d2(%rip), %rax      # 0x2780
testb $0x1, %cl
cmovneq %rax, %rdx
leaq -0x4f0(%rip), %rsi      # 0x2670
leaq -0x3b7(%rip), %rcx      # 0x27b0
callq 0x22c0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movl $0x6, %esi
callq 0x2460
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movl $0x2, %esi
movl $0x4, %edx
movl $0xfffff, %ecx          # imm = 0xFFFFF
callq 0x20b0
addq $0x20, %rsp
popq %rbp
retq
// File: gtarcoder[P]libevent_utils/connection.cpp
// Function: Connection::OnPeerEvent(short)
void Connection::OnPeerEvent(short events){
   if (events & BEV_EVENT_CONNECTED){
        connected_ = true;
        printf("connected!\n");
   }else if (events & BEV_EVENT_EOF){
        evutil_closesocket(fd_);
        fd_ = -1;
        bufferevent_setfd(peer_event_, -1);
        connected_ = false;
        printf("connection closed!\n");
        if(delconn_cb_)
          delconn_cb_(this->index_);
   }else if (events & BEV_EVENT_ERROR){
        printf("got an error on connection in %s\n", strerror(errno));
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movswl -0xa(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2c97
movq -0x18(%rbp), %rax
movb $0x1, 0x8c(%rax)
leaq 0x43f2(%rip), %rdi      # 0x707d
movb $0x0, %al
callq 0x2040
jmp 0x2d3a
movswl -0xa(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2d0d
movq -0x18(%rbp), %rax
movl 0x58(%rax), %edi
callq 0x21c0
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2410
movq -0x18(%rbp), %rax
movb $0x0, 0x8c(%rax)
leaq 0x43af(%rip), %rdi      # 0x7089
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2de0
testb $0x1, %al
jne 0x2cf4
jmp 0x2d0b
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzwl 0x84(%rax), %esi
callq 0x2e10
jmp 0x2d38
movswl -0xa(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x2d36
callq 0x2030
movl (%rax), %edi
callq 0x20f0
movq %rax, %rsi
leaq 0x436e(%rip), %rdi      # 0x709d
movb $0x0, %al
callq 0x2040
jmp 0x2d38
jmp 0x2d3a
addq $0x20, %rsp
popq %rbp
retq
// File: gtarcoder[P]libevent_utils/tcp_client.cpp
// Function: TcpClient::KeepAliveCallback(int, short, void*)
void TcpClient::KeepAliveCallback(evutil_socket_t fd, short event, void* arg){
    printf("in %s:%s\n", __FILE__, __func__);
    TcpClient* client = (TcpClient*)arg;
    //reconnect
    if(!client->connected_){
        client->DoConnect();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0x41f7(%rip), %rdi      # 0x7114
leaq 0x41b9(%rip), %rsi      # 0x70dd
leaq 0x41c1(%rip), %rdx      # 0x70ec
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x8c(%rax)
jne 0x2f50
movq -0x18(%rbp), %rdi
callq 0x2f60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/tcp_client.cpp
// Function: TcpClient::DoConnect()
bool TcpClient::DoConnect(){
    if(fd_ < 0){
        fd_ = socket(AF_INET, SOCK_STREAM, 0);
        if(fd_ < 0){
            printf("create socket failed in %s:%s\n", __FILE__, __func__);
            return false;
        }
        bufferevent_setfd(peer_event_, fd_);
    }

    struct sockaddr_in peer_addr;
    peer_addr.sin_family = AF_INET;
    peer_addr.sin_addr.s_addr = inet_addr(peer_ip_.c_str());
    peer_addr.sin_port = htons(peer_port_);
    int ret = bufferevent_socket_connect(peer_event_, (const sockaddr*)&peer_addr, sizeof(peer_addr));
    if (ret < 0){
        printf("bufferevent socket connect failed in %s:%s!\n", __FILE__, __func__);
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x58(%rax)
jge 0x2fcf
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x20a0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x58(%rax)
cmpl $0x0, 0x58(%rax)
jge 0x2fbf
leaq 0x4228(%rip), %rdi      # 0x71c9
leaq 0x4135(%rip), %rsi      # 0x70dd
leaq 0x4239(%rip), %rdx      # 0x71e8
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
jmp 0x304b
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rdi
movl 0x58(%rax), %esi
callq 0x2410
movq -0x30(%rbp), %rdi
movw $0x2, -0x20(%rbp)
addq $0x60, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x22d0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movzwl 0x80(%rax), %edi
callq 0x2050
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, -0x1e(%rbp)
movq 0x28(%rax), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x2320
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x3047
leaq 0x41c6(%rip), %rdi      # 0x71f2
leaq 0x40aa(%rip), %rsi      # 0x70dd
leaq 0x41ae(%rip), %rdx      # 0x71e8
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
jmp 0x304b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/tcp_client.cpp
// Function: TcpClient::Start()
bool TcpClient::Start(){
    
    if(!DoConnect())
        return false;    

    if(SetKeepLive(fd_, 20, 5, 3) < 0){
        printf("set keep alive failed in %s:%s\n", __FILE__, __func__);
        return false;
    }
    if(SetRecvSendBufSize(fd_, 0xfffff) < 0){
        printf("set recv sned bufsize failed in %s:%s\n", __FILE__, __func__);
        return false;
    }

    //create a timer to keep connection alive
    keepalive_event_ = event_new(base_, -1, EV_PERSIST, TcpClient::KeepAliveCallback, this);
    if(!keepalive_event_){
        printf("create event failed in %s:%s!\n", __FILE__, __func__);
        return false;
    }
     
    struct timeval tv = {10, 0};
    evtimer_add(keepalive_event_, &tv);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2f60
testb $0x1, %al
jne 0x3166
movb $0x0, -0x1(%rbp)
jmp 0x326c
movq -0x28(%rbp), %rax
movl 0x58(%rax), %edi
movl $0x14, %esi
movl $0x5, %edx
movl $0x3, %ecx
callq 0x6170
cmpl $0x0, %eax
jge 0x31ab
leaq 0x3f71(%rip), %rdi      # 0x70fe
leaq 0x3f49(%rip), %rsi      # 0x70dd
leaq 0x3f83(%rip), %rdx      # 0x711e
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
jmp 0x326c
movq -0x28(%rbp), %rax
movl 0x58(%rax), %edi
movl $0xfffff, %esi          # imm = 0xFFFFF
callq 0x60e0
cmpl $0x0, %eax
jge 0x31e6
leaq 0x3f5c(%rip), %rdi      # 0x7124
leaq 0x3f0e(%rip), %rsi      # 0x70dd
leaq 0x3f48(%rip), %rdx      # 0x711e
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
jmp 0x326c
movq -0x28(%rbp), %r8
movq 0x30(%r8), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x10, %edx
leaq -0x2ff(%rip), %rcx      # 0x2f00
callq 0x2240
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10098(%rax)
cmpq $0x0, 0x10098(%rax)
jne 0x323e
leaq 0x3f28(%rip), %rdi      # 0x714b
leaq 0x3eb3(%rip), %rsi      # 0x70dd
leaq 0x3eed(%rip), %rdx      # 0x711e
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
jmp 0x326c
movq -0x28(%rbp), %rax
movq 0x3fd7(%rip), %rcx      # 0x7220
movq %rcx, -0x20(%rbp)
movq 0x3fd4(%rip), %rcx      # 0x7228
movq %rcx, -0x18(%rbp)
movq 0x10098(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2140
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gtarcoder[P]libevent_utils/tcp_client.cpp
// Function: TcpClient::OnPeerRead()
void TcpClient::OnPeerRead(){
    //this is for test
    printf("received data from peer, length = %d, data = %s\n", buffer_len_, buffer_);
    usleep(1000000);
    
    char *msg = "hello server!\n";
    Write(msg, strlen(msg));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movl 0x1008c(%rdx), %esi
addq $0x8d, %rdx
leaq 0x3ec2(%rip), %rdi      # 0x716a
movb $0x0, %al
callq 0x2040
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2390
leaq 0x3edb(%rip), %rax      # 0x719b
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2160
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl %eax, %edx
callq 0x2ba0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gtarcoder[P]libevent_utils/tcp_client.cpp
// Function: TcpClient::OnPeerEvent(short)
void TcpClient::OnPeerEvent(short events){
   if (events == BEV_EVENT_CONNECTED){
        printf("connected!\n");
        connected_ = true;

        //this is for test
        usleep(1000000);
        char *msg = "hello server!\n";
        Write(msg, strlen(msg));

   }else if (events & BEV_EVENT_EOF){
        evutil_closesocket(fd_);
        fd_ = -1;
        bufferevent_setfd(peer_event_, -1);
        connected_ = false;
        printf("connection closed!\n");
   }else if (events & BEV_EVENT_ERROR){
        printf("got an error on TcpClient: %s\n", strerror(errno));
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x80, %eax
jne 0x3366
leaq 0x3d60(%rip), %rdi      # 0x707d
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rax
movb $0x1, 0x8c(%rax)
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2390
leaq 0x3e5b(%rip), %rax      # 0x719b
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x2ba0
jmp 0x33df
movswl -0xa(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x33b2
movq -0x20(%rbp), %rax
movl 0x58(%rax), %edi
callq 0x21c0
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2410
movq -0x20(%rbp), %rax
movb $0x0, 0x8c(%rax)
leaq 0x3ce0(%rip), %rdi      # 0x7089
movb $0x0, %al
callq 0x2040
jmp 0x33dd
movswl -0xa(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x33db
callq 0x2030
movl (%rax), %edi
callq 0x20f0
movq %rax, %rsi
leaq 0x3dd6(%rip), %rdi      # 0x71aa
movb $0x0, %al
callq 0x2040
jmp 0x33dd
jmp 0x33df
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gtarcoder[P]libevent_utils/tcp_server.cpp
// Function: TcpServer::Bind(char const*, unsigned short, event_base*)
void TcpServer::Bind(const char* ip, uint16_t port, struct event_base* base){
    base_ = base;
    listen_addr_.sin_family = AF_INET;
    listen_addr_.sin_addr.s_addr = inet_addr(ip);
    listen_addr_.sin_port = htons(port);
    listener_ = evconnlistener_new_bind(
                base_, 
                ListenCallback,
                this, 
                LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,
                -1,
                (const sockaddr*)&listen_addr_, 
                sizeof(listen_addr_));
    if (!listener_){
        printf("evconnlistener create failed in %s:%s!\n", __FILE__, __func__);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movw $0x2, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x22d0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x1c(%rax)
movzwl -0x12(%rbp), %edi
callq 0x2050
movq -0x28(%rbp), %rdx
movw %ax, 0x1a(%rdx)
movq 0x8(%rdx), %rdi
movq %rdx, %r9
addq $0x18, %r9
leaq -0x226(%rip), %rsi      # 0x33f0
movl $0xa, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x10, (%rsp)
callq 0x2260
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
jne 0x365b
leaq 0x3bfa(%rip), %rdi      # 0x7240
leaq 0x3c1b(%rip), %rsi      # 0x7268
leaq 0x3c23(%rip), %rdx      # 0x7277
movb $0x0, %al
callq 0x2040
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/tcp_server.cpp
// Function: TcpServer::OnListen(evconnlistener*, int, sockaddr*, int)
void TcpServer::OnListen(struct evconnlistener* listener, evutil_socket_t sock, struct sockaddr* addr, int socklen){
    string client_ip = string(inet_ntoa(((struct sockaddr_in*)addr)->sin_addr));
    uint16_t client_port = ntohs(((struct sockaddr_in*)addr)->sin_port);
    printf("receive connection from %s:%d\n", client_ip.c_str(), client_port);
    Connection* conn = new Connection(client_ip, client_port, 0, next_client_index_);
    connections_[next_client_index_++] = conn;
    conn->Initialize(base_, sock);
    conn->Start();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x2170
movq %rax, -0xa0(%rbp)
leaq -0x4d(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2430
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x2380
jmp 0x36db
leaq -0x4d(%rbp), %rdi
callq 0x2300
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x2450
movw %ax, -0x5e(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2130
movq %rax, %rsi
movzwl -0x5e(%rbp), %edx
leaq 0x3b70(%rip), %rdi      # 0x727c
xorl %eax, %eax
callq 0x2040
jmp 0x3715
movl $0x10098, %edi          # imm = 0x10098
callq 0x22b0
movq %rax, -0xb0(%rbp)
jmp 0x3728
movb $0x1, -0x89(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2150
jmp 0x3741
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rax
movzwl -0x5e(%rbp), %edx
movzwl 0x68(%rax), %r8d
leaq -0x88(%rbp), %rsi
xorl %ecx, %ecx
callq 0x27f0
jmp 0x3768
movb $0x0, -0x89(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x21b0
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq %rcx, %rdi
addq $0x30, %rdi
movl 0x68(%rcx), %edx
movw %dx, %ax
incl %edx
movw %dx, 0x68(%rcx)
movw %ax, -0x8c(%rbp)
leaq -0x8c(%rbp), %rsi
callq 0x3910
movq %rax, -0xb8(%rbp)
jmp 0x37c7
movq -0xa8(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq -0xc0(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x68(%rbp), %rdi
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
callq 0x2ac0
jmp 0x37f3
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
jmp 0x3802
leaq -0x48(%rbp), %rdi
callq 0x21b0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x2300
jmp 0x3881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3878
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x385f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x21b0
testb $0x1, -0x89(%rbp)
jne 0x386a
jmp 0x3876
movq -0xb0(%rbp), %rdi
callq 0x2280
jmp 0x3878
leaq -0x48(%rbp), %rdi
callq 0x21b0
movq -0x58(%rbp), %rdi
callq 0x2420
nopw (%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::ReadCallback(int, short, void*)
void UdpSocket::ReadCallback(evutil_socket_t fd, short events, void* arg){
    UdpSocket* udp_socket = (UdpSocket*)arg;
    udp_socket->read_len_ = recv(udp_socket->fd_, udp_socket->read_buffer_, 0xffff, 0);
    udp_socket->read_buffer_[udp_socket->read_len_] = '\0';
    assert(udp_socket->read_cb_);
    udp_socket->read_cb_(udp_socket->read_buffer_, udp_socket->read_len_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1003c(%rax), %edi
movq -0x18(%rbp), %rsi
addq $0x38, %rsi
movl $0xffff, %edx           # imm = 0xFFFF
xorl %ecx, %ecx
callq 0x20e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10038(%rax)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x10038(%rcx), %rcx
movb $0x0, 0x38(%rax,%rcx)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x59f0
testb $0x1, %al
jne 0x51df
jmp 0x51e1
jmp 0x5200
leaq 0x20bf(%rip), %rdi      # 0x72a7
leaq 0x20cd(%rip), %rsi      # 0x72bc
movl $0xa, %edx
leaq 0x20d0(%rip), %rcx      # 0x72cb
callq 0x21d0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x38, %rsi
movq -0x18(%rbp), %rax
movl 0x10038(%rax), %edx
callq 0x5a20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::Bind(char const*, unsigned short, event_base*)
bool UdpSocket::Bind(const char* local_ip, uint16_t local_port, struct event_base* base){
    base_ = base;
    assert(base_);    
    if(!Bind(local_ip, local_port))
      return false;
    event_ = event_new(base_, fd_, EV_PERSIST|EV_READ, UdpSocket::ReadCallback, this); 
    if(!event_){
        printf("event new failed in %s!\n", __func__);
        return false;
    }
    event_add(event_, NULL);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
je 0x5264
jmp 0x5283
leaq 0x2098(%rip), %rdi      # 0x7303
leaq 0x204a(%rip), %rsi      # 0x72bc
movl $0x10, %edx
leaq 0x208b(%rip), %rcx      # 0x7309
callq 0x21d0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movzwl -0x1a(%rbp), %edx
callq 0x5310
testb $0x1, %al
jne 0x529e
movb $0x0, -0x1(%rbp)
jmp 0x5300
movq -0x30(%rbp), %r8
movq 0x28(%r8), %rdi
movl 0x1003c(%r8), %esi
movl $0x12, %edx
leaq -0x149(%rip), %rcx      # 0x5170
callq 0x2240
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
cmpq $0x0, 0x30(%rax)
jne 0x52eb
leaq 0x2074(%rip), %rdi      # 0x734b
leaq 0x1f99(%rip), %rsi      # 0x7277
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
jmp 0x5300
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2140
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::Bind(char const*, unsigned short)
bool UdpSocket::Bind(const char* local_ip, uint16_t local_port){
    struct sockaddr_in local_addr;
    local_addr.sin_family = AF_INET;
    local_addr.sin_port = htons(local_port);
    local_addr.sin_addr.s_addr = inet_addr(local_ip);
    uint32_t option = 1;
    if (setsockopt(fd_, SOL_SOCKET, SO_REUSEADDR, (char*)&option, sizeof(option)) < 0){
       perror("set socket reuse addr\n");
       return false;
    }
    if (bind(fd_, (sockaddr*)&local_addr, sizeof(local_addr)) != 0){
       perror("bind socket\n");
       return false;
    }
    SetRecvSendBufSize(fd_, 0xfffff);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movw $0x2, -0x2c(%rbp)
movzwl -0x1a(%rbp), %edi
callq 0x2050
movw %ax, -0x2a(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22d0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x28(%rbp)
movl $0x1, -0x30(%rbp)
movl 0x1003c(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x30(%rbp), %rcx
movl $0x4, %r8d
callq 0x2440
cmpl $0x0, %eax
jge 0x5391
leaq 0x2001(%rip), %rdi      # 0x7387
callq 0x2230
movb $0x0, -0x1(%rbp)
jmp 0x53d8
movq -0x38(%rbp), %rax
movl 0x1003c(%rax), %edi
leaq -0x2c(%rbp), %rsi
movl $0x10, %edx
callq 0x2070
cmpl $0x0, %eax
je 0x53c0
leaq 0x1fe9(%rip), %rdi      # 0x739e
callq 0x2230
movb $0x0, -0x1(%rbp)
jmp 0x53d8
movq -0x38(%rbp), %rax
movl 0x1003c(%rax), %edi
movl $0xfffff, %esi          # imm = 0xFFFFF
callq 0x60e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::UdpSocket()
UdpSocket::UdpSocket(){
#ifndef LINUX //in windows system
    static bool was_inited = false;
  	if (wsa_inited_){
		return;
	}

	WSADATA wsaData;
	int iErrorCode;
	if (WSAStartup(MAKEWORD(2, 1), &wsaData)) //µ÷ÓÃWindows Sockets DLL
	{
		printf("Winsock init failed in %s\n", __func__);
		WSACleanup();
		return;
	}
	wsa_inited_ = true;
#endif

#ifdef ASYNC_UDP
    event_ = NULL;
    base_ = NULL;
    read_cb_=NULL;
#endif

    //create a udp socket
    fd_ = socket(AF_INET, SOCK_DGRAM, 0);
    if(fd_ < 0){
        printf("udp create failed in %s\n", __func__);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x5965(%rip), %rax      # 0xad70
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x28(%rbp)
callq 0x5a70
movq -0x20(%rbp), %rdi
movq $0x0, 0x30(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ab0
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x20a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1003c(%rax)
cmpl $0x0, 0x1003c(%rax)
jge 0x5493
leaq 0x1efa(%rip), %rdi      # 0x7364
leaq 0x1f0c(%rip), %rsi      # 0x737d
xorl %eax, %eax
callq 0x2040
jmp 0x547a
jmp 0x5493
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5b10
jmp 0x5499
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2420
nopw %cs:(%rax,%rax)