LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_vcopy_dcomplex(long, double const*, long, double*, long, char const*)
void _ialglib_vcopy_dcomplex(ae_int_t n, const double *a, ae_int_t stridea, double *b, ae_int_t strideb, const char *conj)
{
    ae_int_t i;

    /*
     * more general case
     */
    if( conj[0]=='N' || conj[0]=='n' )
    {
        for(i=0; i<n; i++,a+=2*stridea,b+=2*strideb)
        {
            b[0] = a[0];
            b[1] = a[1];
        }
    }
    else
    {
        for(i=0; i<n; i++,a+=2*stridea,b+=2*strideb)
        {
            b[0] = a[0];
            b[1] = -a[1];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
je 0x4ded4
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x4df41
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4df3c
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4dedc
jmp 0x4dfc2
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x4dfc0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4df49
jmp 0x4dfc2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::_ialglib_pack_n2(double*, double*, long, long, double*)
void _ialglib_pack_n2(
    double *col0,
    double *col1,
    ae_int_t n,
    ae_int_t src_stride,
    double *dst)
{
    ae_int_t n2, j, stride2;
    
    /*
     * handle special case
     */
    if( col1==NULL )
    {
        for(j=0; j<n; j++)
        {
            dst[0] = *col0;
            dst[1] = 0.0;
            col0 += src_stride;
            dst  += 2;
        }
        return;
    }

    /*
     * handle general case
     */
    n2 = n/2;
    stride2 = src_stride*2;
    for(j=0; j<n2; j++)
    {
        dst[0] = *col0;
        dst[1] = *col1;
        dst[2] = col0[src_stride];
        dst[3] = col1[src_stride];
        col0 += stride2;
        col1 += stride2;
        dst  += 4;
    }
    if( n%2 )
    {
        dst[0] = *col0;
        dst[1] = *col1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x51ccc
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x51cc7
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x51c77
jmp 0x51dbe
movq -0x18(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x51d89
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x40(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x40(%rbp), %rax
shlq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x51cf1
movq -0x18(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x51dbe
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_split_length(long, long, long*, long*)
static void x_split_length(ae_int_t n, ae_int_t nb, ae_int_t* n1, ae_int_t* n2)
{
    ae_int_t r;
    if( n<=nb )
    {
        *n1 = n;
        *n2 = 0;
    }
    else
    {
        if( n%nb!=0 )
        {
            *n2 = n%nb;
            *n1 = n-(*n2);
        }
        else
        {
            *n2 = n/2;
            *n1 = n-(*n2);
            if( *n1%nb==0 )
            {
                return;
            }
            r = nb-*n1%nb;
            *n1 = *n1+r;
            *n2 = *n2-r;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jg 0x52259
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x52316
movq -0x8(%rbp), %rax
cqto
idivq -0x10(%rbp)
cmpq $0x0, %rdx
je 0x52291
movq -0x8(%rbp), %rax
cqto
idivq -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rdx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
subq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x52314
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
subq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cqto
idivq -0x10(%rbp)
cmpq $0x0, %rdx
jne 0x522d0
jmp 0x52316
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cqto
idivq -0x10(%rbp)
movq -0x30(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
subq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x52316
popq %rbp
retq
nopl (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/ap.cpp
// Function: alglib_impl::x_safepythag2(double, double)
static double x_safepythag2(double x, double y)
{
    double w;
    double xabs;
    double yabs;
    double z;
    xabs = fabs(x);
    yabs = fabs(y);
    w = xabs>yabs ? xabs : yabs;
    z = xabs<yabs ? xabs : yabs;
    if( z==0 )
        return w;
    else
    {
        double t;
        t = z/w;
        return w*sqrt(1+t*t);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movaps 0x55d2(%rip), %xmm1     # 0x580b0
pand %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x55bd(%rip), %xmm1     # 0x580b0
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x52b14
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x52b1e
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x52b44
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x52b4e
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x52b74
jp 0x52b74
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x52bbd
movsd -0x38(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x2465(%rip), %xmm1     # 0x55008
addsd %xmm1, %xmm0
callq 0x3200
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/examples/format-traits-ex01.cxx
// Function: main
int main() {
    std::map<int, int> map;
        cxon::from_bytes<UQK>(map, R"({1: 2, 3: 4})");
    assert(map == (std::map<int, int> {{1, 2}, {3, 4}}));
    std::string str;
        cxon::to_bytes<UQK>(str, map);
    assert(str == R"({1:2,3:4})");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x2900
movq -0x108(%rbp), %rsi
leaq 0x4ce8(%rip), %rdx      # 0x7028
leaq -0x50(%rbp), %rdi
callq 0x2920
jmp 0x234b
movl $0x1, -0xb4(%rbp)
movl $0x2, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb4(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x2980
jmp 0x237b
leaq -0xa8(%rbp), %rdi
movl $0x3, -0xbc(%rbp)
movl $0x4, -0xc0(%rbp)
leaq -0xbc(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x2980
jmp 0x23ab
leaq -0xb0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x2, -0x98(%rbp)
leaq -0xc2(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x29b0
movq -0x110(%rbp), %r8
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0xc1(%rbp), %rcx
callq 0x29d0
jmp 0x2401
leaq -0x38(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2950
movb %al, -0x111(%rbp)
jmp 0x2419
movb -0x111(%rbp), %al
testb $0x1, %al
jne 0x2425
jmp 0x2427
jmp 0x2485
leaq 0x4c07(%rip), %rdi      # 0x7035
leaq 0x4c2d(%rip), %rsi      # 0x7062
movl $0x11, %edx
leaq 0x4c38(%rip), %rcx      # 0x7079
callq 0x20e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x255a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2511
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2aa0
jmp 0x2511
leaq -0x90(%rbp), %rdi
callq 0x2aa0
leaq -0xc2(%rbp), %rdi
callq 0x2ac0
leaq -0xe8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x21a0
movq -0x120(%rbp), %rsi
leaq -0x100(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x2ae0
jmp 0x24c9
leaq 0x4bb4(%rip), %rsi      # 0x7084
leaq -0xe8(%rbp), %rdi
callq 0x2b10
movb %al, -0x121(%rbp)
jmp 0x24e4
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x24f0
jmp 0x24f2
jmp 0x2539
leaq 0x4b95(%rip), %rdi      # 0x708e
leaq 0x4b62(%rip), %rsi      # 0x7062
movl $0x14, %edx
leaq 0x4b6d(%rip), %rcx      # 0x7079
callq 0x20e0
leaq -0xc2(%rbp), %rdi
callq 0x2ac0
jmp 0x255a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x20c0
jmp 0x255a
leaq -0xe8(%rbp), %rdi
callq 0x20c0
leaq -0x38(%rbp), %rdi
callq 0x2aa0
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x2aa0
movq -0x58(%rbp), %rdi
callq 0x21e0
nopl (%rax)
// File: akw0088[P]openssl/getrandom.cpp
// Function: main
int main(int argc, char *argv[])
{
	char buf[256] = {0};
	ssize_t size;

	if (argc > 1)
	{
		size = getrandom(buf, 256, 0);
	}
	else
	{
		printf("Using /dev/random, may block add a parameter to use /dev/urandom\r\n");
		size = getrandom(buf, 256, GRND_RANDOM);
	}

	if (size > 0)
	{
		for (int i = 0; i < size; i++)
		{
			printf("%02X", (unsigned int)buf[i]);
		}
		printf("\r\n");
	}
	else
	{
		printf("getrandom() returned %d try again later\r\n", (int)size);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x1050
cmpl $0x1, -0x8(%rbp)
jle 0x11ae
leaq -0x110(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x1040
movq %rax, -0x118(%rbp)
jmp 0x11d9
leaq 0xe4f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq -0x110(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x2, %edx
callq 0x1040
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
jle 0x123b
movl $0x0, -0x11c(%rbp)
movslq -0x11c(%rbp), %rax
cmpq -0x118(%rbp), %rax
jge 0x122b
movslq -0x11c(%rbp), %rax
movsbl -0x110(%rbp,%rax), %esi
leaq 0xe34(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1030
movl -0x11c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0x11ed
leaq 0xe12(%rip), %rdi       # 0x2044
movb $0x0, %al
callq 0x1030
jmp 0x1252
movq -0x118(%rbp), %rax
movl %eax, %esi
leaq 0xe01(%rip), %rdi       # 0x204c
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
// File: BelfordZ[P]SimpleFileServer/Server.cpp
// Function: Server::~Server()
Server::~Server() 
{
   delete dispatchIn;
   delete dispatchOut;
   
   for (int i = 0; i<threads.size(); i++)
   {
      delete threads.front();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x40eb
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4107
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xc27b(%rip), %rdi      # 0x10398
callq 0x5040
movq %rax, -0x30(%rbp)
jmp 0x4128
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jae 0x4173
leaq 0xc25c(%rip), %rdi      # 0x10398
callq 0x5060
movq %rax, -0x40(%rbp)
jmp 0x4147
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4166
movq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0x32e0
jmp 0x4168
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x410e
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x3548
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3de0
nop
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::Frame(FrameType const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
Frame::Frame(const FrameType& frameType, const std::string& payload, bool goodFrame) {
   fType = frameType;
   data = pad_data(payload, FRAME_DATA_LENGTH);
   set_parity(data);
   if(!goodFrame) {
      parity = !parity;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
movq %rdi, -0x88(%rbp)
callq 0x3400
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x80(%rbp)
callq 0x3400
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsi)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movl $0x3e, %ecx
callq 0x7d60
jmp 0x7ca8
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x90(%rbp)
leaq -0x40(%rbp), %rsi
movq %rsi, -0x98(%rbp)
callq 0x33a0
movq -0x98(%rbp), %rdi
callq 0x3548
movq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x3150
jmp 0x7ce5
movq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7e90
jmp 0x7cf4
leaq -0x70(%rbp), %rdi
callq 0x3548
testb $0x1, -0x19(%rbp)
jne 0x7d38
movq -0x78(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x7d38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7d41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3548
jmp 0x7d41
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3548
movq -0x88(%rbp), %rdi
callq 0x3548
movq -0x48(%rbp), %rdi
callq 0x3490
nop
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::pad_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::string Frame::pad_data(const std::string& rawData, int size) {
   std::string appendStr = "\0";
   std::string returnStr = rawData;
   
   for(int i = rawData.length(); i < size-1; i++) {
      appendStr += " ";
   }
   
   returnStr += appendStr;
   return returnStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x34a0
movq -0x68(%rbp), %rdx
leaq 0x34d7(%rip), %rsi      # 0xb274
leaq -0x40(%rbp), %rdi
callq 0x3ad0
jmp 0x7da8
leaq -0x41(%rbp), %rdi
callq 0x3330
movq -0x78(%rbp), %rdi
movb $0x0, -0x55(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3150
jmp 0x7dc4
movq -0x18(%rbp), %rdi
callq 0x3430
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7e38
leaq 0x32c6(%rip), %rsi      # 0xb0aa
leaq -0x40(%rbp), %rdi
callq 0x32a0
jmp 0x7def
jmp 0x7df1
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x7dd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3330
jmp 0x7e79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7e70
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3548
jmp 0x7e70
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x33d0
jmp 0x7e47
movb $0x1, -0x55(%rbp)
testb $0x1, -0x55(%rbp)
jne 0x7e5a
movq -0x78(%rbp), %rdi
callq 0x3548
leaq -0x40(%rbp), %rdi
callq 0x3548
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x3548
movq -0x50(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::set_parity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Frame::set_parity(std::string pStr) {
   int checksum = 0;
   for(int i = 0; i < pStr.length(); i++) {
      checksum = (checksum + pStr[i]) % 2;
   }

   parity = checksum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3430
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x7f0b
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x3530
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7eba
movq -0x20(%rbp), %rax
cmpl $0x0, -0x14(%rbp)
setne %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::Frame(FrameType const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Frame::Frame(const FrameType& frameType, const std::string& payload, const std::string& pid) {
   fType = frameType;
   data = pad_data(payload, FRAME_DATA_PID_LENGTH);
   procId = pad_data(pid, FRAME_PID_LENGTH);
   set_parity(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x8, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3400
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3400
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsi)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movl $0x39, %ecx
callq 0x7d60
jmp 0x7fa1
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x33a0
movq -0xb0(%rbp), %rdi
callq 0x3548
movq -0x98(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movl $0x5, %ecx
callq 0x7d60
jmp 0x7fe3
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x33a0
movq -0xb8(%rbp), %rdi
callq 0x3548
movq -0x98(%rbp), %rsi
addq $0x28, %rsi
leaq -0x90(%rbp), %rdi
callq 0x3150
jmp 0x8023
movq -0x98(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x7e90
jmp 0x8038
leaq -0x90(%rbp), %rdi
callq 0x3548
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8073
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3548
movq -0xa0(%rbp), %rdi
callq 0x3548
movq -0xa8(%rbp), %rdi
callq 0x3548
movq -0x48(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::Frame(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Frame::Frame(const std::string& rawData) {
   fType = char_to_frametype(rawData[0]);
   char pChar = rawData[1];
   if(pChar == '0') {
      parity = 0;
   } else {
      parity = 1;
   }

   // If we have a CLIENT_HELLO or a SERVER_HELLO, then we need to
   // associate a PID with our Frame (for use in the Server).
   if(fType == CLIENT_HELLO || fType == SERVER_HELLO) {
      procId = rawData.substr(2, FRAME_PID_LENGTH);
      data = rawData.substr(7, FRAME_DATA_PID_LENGTH);
   } else {
      data = rawData.substr(2, FRAME_DATA_LENGTH);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3400
movq -0x90(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x98(%rbp)
callq 0x3400
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3350
movq -0x90(%rbp), %rdi
movsbl (%rax), %esi
callq 0x8250
movl %eax, -0x84(%rbp)
jmp 0x8109
movq -0x90(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3350
movb (%rax), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x30, %eax
jne 0x816a
movq -0x90(%rbp), %rax
movb $0x0, (%rax)
jmp 0x8174
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3548
movq -0xa0(%rbp), %rdi
callq 0x3548
jmp 0x8245
movq -0x90(%rbp), %rax
movb $0x1, (%rax)
movq -0x90(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x818e
movq -0x90(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8206
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x2, %edx
movl $0x5, %ecx
callq 0x3300
jmp 0x81a7
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x33a0
movq -0xa8(%rbp), %rdi
callq 0x3548
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movl $0x7, %edx
movl $0x39, %ecx
callq 0x3300
jmp 0x81e7
movq -0x90(%rbp), %rdi
addq $0x28, %rdi
leaq -0x60(%rbp), %rsi
callq 0x33a0
leaq -0x60(%rbp), %rdi
callq 0x3548
jmp 0x823c
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x2, %edx
movl $0x3e, %ecx
callq 0x3300
jmp 0x821f
movq -0x90(%rbp), %rdi
addq $0x28, %rdi
leaq -0x80(%rbp), %rsi
callq 0x33a0
leaq -0x80(%rbp), %rdi
callq 0x3548
addq $0xb0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3490
nop
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::char_to_frametype(char) const
FrameType Frame::char_to_frametype(char frameTypeChar) const {
   switch(frameTypeChar) {
      case '0':
	 return CLIENT_HELLO;
      case '1':
	 return SERVER_HELLO;
      case '2':
	 return SYNC;
      case '3':
	 return GOODBYE;
      case '4':
	 return DATA;
      case '5':
	 return ACK;
      case '6':
	 return NAK;
      default:
	 return NAK;
   }

   return NAK; // this should never happen!!!
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x6, %eax
ja 0x82c3
movq -0x20(%rbp), %rax
leaq 0x2fc1(%rip), %rcx      # 0xb23c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x82ca
movl $0x1, -0x4(%rbp)
jmp 0x82ca
movl $0x2, -0x4(%rbp)
jmp 0x82ca
movl $0x3, -0x4(%rbp)
jmp 0x82ca
movl $0x4, -0x4(%rbp)
jmp 0x82ca
movl $0x5, -0x4(%rbp)
jmp 0x82ca
movl $0x6, -0x4(%rbp)
jmp 0x82ca
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::check_parity() const
bool Frame::check_parity() const {
   int checksum = 0;
   for(int i = 0; i < data.length(); i++) {
      checksum = (checksum + data[i]) % 2;
   }

   return checksum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x3430
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x834b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3350
movq %rax, %rcx
movl -0x24(%rbp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x82f2
cmpl $0x0, -0xc(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Frame.cpp
// Function: Frame::get_frame_as_string[abi:cxx11]() const
std::string Frame::get_frame_as_string() const {
   std::string frameStr = frametype_to_string(fType);
   frameStr += to_string<bool>(parity);
   
   if(fType == CLIENT_HELLO || fType == SERVER_HELLO) {
      frameStr += procId;
   }
   
   frameStr += data;
   return frameStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
movq %rsi, %rdx
addq $0x4, %rdx
callq 0x8450
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8710
jmp 0x83a2
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x33d0
jmp 0x83b1
leaq -0x38(%rbp), %rdi
callq 0x3548
movq -0x50(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x83ce
movq -0x50(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8408
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
callq 0x33d0
jmp 0x83e1
jmp 0x8408
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8438
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3548
jmp 0x8438
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x28, %rsi
callq 0x33d0
jmp 0x841b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x842e
movq -0x60(%rbp), %rdi
callq 0x3548
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3548
movq -0x40(%rbp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/FrameSet.cpp
// Function: FrameSet::ravage_frameset()
void FrameSet::ravage_frameset()
{ 
   int index,damagedFrameNumber;
   float er = 0.2;

   // Determining How many frames am i going to damage?
   damagedFrameNumber = floor(get_number_of_frames() * er);
   std::cout << "Number of frames to ravage: " << damagedFrameNumber << std::endl;

   // generate a random number between 0-MaxNumOfFrames in the vector array
   index = rand() % (get_number_of_frames()-1);	// this number is used as an idex.

   for (int i=0 ; i<damagedFrameNumber; i++)
   {
      frames[index].flip_parity();
      // generate next index
      std::cout << "Ravaged index: " << index << std::endl;
      index = rand() % (get_number_of_frames()-1);	
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movss 0x2678(%rip), %xmm0     # 0xb284
movss %xmm0, -0x14(%rbp)
callq 0x8bd0
cvtsi2ss %eax, %xmm0
mulss -0x14(%rbp), %xmm0
callq 0x8dc0
cvttss2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movq 0x73a6(%rip), %rdi      # 0xffd8
leaq 0x265d(%rip), %rsi      # 0xb296
callq 0x32c0
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x3480
movq %rax, %rdi
movq 0x736d(%rip), %rsi      # 0xffc0
callq 0x3310
callq 0x30d0
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
callq 0x8bd0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x8cf2
movq -0x28(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x5260
movq %rax, %rdi
callq 0x8de0
movq 0x7336(%rip), %rdi      # 0xffd8
leaq 0x260a(%rip), %rsi      # 0xb2b3
callq 0x32c0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3480
movq %rax, %rdi
movq 0x72fd(%rip), %rsi      # 0xffc0
callq 0x3310
callq 0x30d0
movq -0x28(%rbp), %rdi
movl %eax, -0x2c(%rbp)
callq 0x8bd0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
subl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8c7e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Socket.cpp
// Function: Socket::create()
bool Socket::create()
{
   try
   {
      m_sock = socket(AF_INET, SOCK_STREAM, 0);
   } catch(SocketException &e)
   {
      std::cout << "ERROR:Socket.cpp:create(): " << e.description() << std::endl;
   }  
   if (!is_valid())
   {
      std::cout << "ERROR:Socket.cpp:create(): !is_valid() returned false" << std::endl;
      return false;
   }
   
   // TIME_WAIT - argh
   int on = 1;
   if (setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, (const char*) &on, sizeof (on)) == -1)
   {
      std::cout << "ERROR:Socket.cpp:create(): !setsockopt returned -1" << std::endl;
      return false;
   }
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30b0
movq -0x20(%rbp), %rdi
movl %eax, 0x8(%rdi)
callq 0xa0d0
testb $0x1, %al
jne 0x9bbd
movq 0x643c(%rip), %rdi      # 0xffd8
leaq 0x179b(%rip), %rsi      # 0xb33e
callq 0x32c0
movq %rax, %rdi
movq 0x640e(%rip), %rsi      # 0xffc0
callq 0x3310
movb $0x0, -0x1(%rbp)
jmp 0x9c15
movq -0x20(%rbp), %rax
movl $0x1, -0x14(%rbp)
movl 0x8(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x34c0
cmpl $-0x1, %eax
jne 0x9c11
movq 0x63e8(%rip), %rdi      # 0xffd8
leaq 0x177d(%rip), %rsi      # 0xb374
callq 0x32c0
movq %rax, %rdi
movq 0x63ba(%rip), %rsi      # 0xffc0
callq 0x3310
movb $0x0, -0x1(%rbp)
jmp 0x9c15
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: BelfordZ[P]SimpleFileServer/Socket.cpp
// Function: Socket::bind(int)
bool Socket::bind (const int port)
{
   if (!is_valid()){
      return false;
   }

   m_addr.sin_family = AF_INET;
   m_addr.sin_addr.s_addr = INADDR_ANY;
   m_addr.sin_port = htons (port);

   int bind_return = ::bind (m_sock,
			     (struct sockaddr *)&m_addr,
			     sizeof(m_addr));
   if (bind_return == -1){
      return false;
   }
   
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa0d0
testb $0x1, %al
jne 0x9c46
movb $0x0, -0x1(%rbp)
jmp 0x9c8e
movq -0x20(%rbp), %rax
movw $0x2, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x3060
movq -0x20(%rbp), %rsi
movw %ax, 0xe(%rsi)
movl 0x8(%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x3070
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x9c8a
movb $0x0, -0x1(%rbp)
jmp 0x9c8e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BelfordZ[P]SimpleFileServer/Socket.cpp
// Function: Socket::listen() const
bool Socket::listen() const
{
   if (!is_valid()){
      return false;
   }

   int listen_return = ::listen (m_sock, MAXCONNECTIONS);

   if (listen_return == -1){
      return false;
   }
   
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa0d0
testb $0x1, %al
jne 0x9cc3
movb $0x0, -0x1(%rbp)
jmp 0x9ce7
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movl $0x5, %esi
callq 0x3370
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x9ce3
movb $0x0, -0x1(%rbp)
jmp 0x9ce7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Socket.cpp
// Function: Socket::accept(Socket&) const
bool Socket::accept (Socket& new_socket) const
{

   int addr_length = sizeof (m_addr);
   new_socket.m_sock = ::accept (m_sock, (sockaddr *)&m_addr, (socklen_t *)&addr_length);

   if (new_socket.m_sock <= 0)
      return false;
   else
      return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl $0x10, -0x1c(%rbp)
movl 0x8(%rsi), %edi
addq $0xc, %rsi
leaq -0x1c(%rbp), %rdx
callq 0x30f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jg 0x9dc4
movb $0x0, -0x1(%rbp)
jmp 0x9dc8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Socket.cpp
// Function: Socket::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Socket::send(const std::string s) const
{
   //std::cout << "Sending a frame on port " << m_sock << std::endl;
   //std::cout << s << std::endl;
   int status = ::send(m_sock, s.c_str(), s.size(), MSG_NOSIGNAL);
   if (status == -1)
      return false;
   
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x3140
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x31e0
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movl $0x4000, %ecx           # imm = 0x4000
callq 0x3180
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x9e3e
movb $0x0, -0x1(%rbp)
jmp 0x9e42
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BelfordZ[P]SimpleFileServer/Socket.cpp
// Function: Socket::recv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
int Socket::recv(std::string& s) const
{
   //std::cout << "Receiving a frame on port " << m_sock << std::endl;
   char buf[MAXRECV + 1];
   s = "";

   memset(buf, 0, MAXRECV + 1);

   int status = ::recv(m_sock, buf, MAXRECV, 0);
   
   if (status == -1){
      std::cout << buf << std::endl;
      std::cout << "status == -1   errno == " << errno << "  in Socket::recv\n";
      return 0;
   }
   else if (status == 0){
      return 0;
   }
   else{
      s = buf;
      return status;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x155c(%rip), %rsi      # 0xb3d2
callq 0x33f0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x41, %edx
callq 0x31a0
movq -0x70(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x3100
movl %eax, -0x64(%rbp)
cmpl $-0x1, -0x64(%rbp)
jne 0x9f09
leaq -0x60(%rbp), %rsi
movq 0x6122(%rip), %rdi      # 0xffd8
callq 0x32c0
movq %rax, %rdi
movq 0x60fb(%rip), %rsi      # 0xffc0
callq 0x3310
movq 0x6107(%rip), %rdi      # 0xffd8
leaq 0x14cf(%rip), %rsi      # 0xb3a7
callq 0x32c0
movq %rax, -0x78(%rbp)
callq 0x3050
movq -0x78(%rbp), %rdi
movl (%rax), %esi
callq 0x3480
movq %rax, %rdi
leaq 0x14c5(%rip), %rsi      # 0xb3c0
callq 0x32c0
movl $0x0, -0x4(%rbp)
jmp 0x9f2b
cmpl $0x0, -0x64(%rbp)
jne 0x9f18
movl $0x0, -0x4(%rbp)
jmp 0x9f2b
leaq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x33f0
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BelfordZ[P]SimpleFileServer/Socket.cpp
// Function: Socket::connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool Socket::connect (const std::string host, const int port)
{
   if (!is_valid())
   {
      std::cout << "ERROR: Socket.cpp::connect: is_valid() returned false;" << std::endl;
      return false;
   }

   m_addr.sin_family = AF_INET;
   m_addr.sin_port = htons(port);

   int status = inet_pton(AF_INET, host.c_str(), &m_addr.sin_addr);

   if (errno == EAFNOSUPPORT)
   {
      std::cout << "ERROR: Socket.cpp::connect: " << errno << " ;" << std::endl;
      return false;
   }

   status = ::connect(m_sock, (sockaddr *)&m_addr, sizeof (m_addr));

   if (status == 0)
   {
      return true;
   }
   else
   {									\
      std::cout << "ERROR: Socket.cpp::connect: " << errno << " ;" << std::endl;
      return false;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xa0d0
testb $0x1, %al
jne 0x9f93
movq 0x6069(%rip), %rdi      # 0xffd8
leaq 0x145d(%rip), %rsi      # 0xb3d3
callq 0x32c0
movq %rax, %rdi
movq 0x603b(%rip), %rsi      # 0xffc0
callq 0x3310
movb $0x0, -0x1(%rbp)
jmp 0xa09a
movq -0x28(%rbp), %rax
movw $0x2, 0xc(%rax)
movl -0x1c(%rbp), %eax
movzwl %ax, %edi
callq 0x3060
movq -0x30(%rbp), %rdi
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0xe(%rax)
callq 0x3140
movq -0x28(%rbp), %rdx
movq %rax, %rsi
addq $0xc, %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x34f0
movl %eax, -0x20(%rbp)
callq 0x3050
cmpl $0x61, (%rax)
jne 0xa02d
movq 0x5fef(%rip), %rdi      # 0xffd8
leaq 0x141a(%rip), %rsi      # 0xb40a
callq 0x32c0
movq %rax, -0x38(%rbp)
callq 0x3050
movq -0x38(%rbp), %rdi
movl (%rax), %esi
callq 0x3480
movq %rax, %rdi
leaq 0x1414(%rip), %rsi      # 0xb427
callq 0x32c0
movq %rax, %rdi
movq 0x5f9e(%rip), %rsi      # 0xffc0
callq 0x3310
movb $0x0, -0x1(%rbp)
jmp 0xa09a
movq -0x28(%rbp), %rsi
movl 0x8(%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x3260
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0xa051
movb $0x1, -0x1(%rbp)
jmp 0xa09a
movq 0x5f80(%rip), %rdi      # 0xffd8
leaq 0x13ab(%rip), %rsi      # 0xb40a
callq 0x32c0
movq %rax, -0x40(%rbp)
callq 0x3050
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x3480
movq %rax, %rdi
leaq 0x13a5(%rip), %rsi      # 0xb427
callq 0x32c0
movq %rax, %rdi
movq 0x5f2f(%rip), %rsi      # 0xffc0
callq 0x3310
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: table_rehash(table*)
void table_rehash(table *table) {
	uint32_t old_bins = table->bins;
	uint32_t i, mask, pos;
	entry **pe, *e;
	table->bins = old_bins == 0 ? 8 : old_bins * 2;
	mask = table->bins - 1;
	table->entries = (entry**)realloc(table->entries, table->bins*sizeof(entry*));
	memset(table->entries+old_bins, 0, sizeof(entry*)*(table->bins - old_bins));
	assert(table->entries != NULL);
	for (i = 0; i < old_bins; i++) {
		pe = &table->entries[i];
		while (*pe != NULL) {
			e = *pe;
			pos = e->hash & mask;
			if (pos != i) {
				*pe = e->next;
				e->next = table->entries[pos];
				table->entries[pos] = e;
			} else {
				pe = &e->next;
			}
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x23f7
movl $0x8, %eax
movl %eax, 0xc(%rsp)
jmp 0x2401
movl 0x2c(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x2290
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x2c(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
subl 0x2c(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x20d0
movq 0x30(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2481
jmp 0x24a0
leaq 0x5bb9(%rip), %rdi      # 0x8041
leaq 0x5bc9(%rip), %rsi      # 0x8058
movl $0x26, %edx
leaq 0x5bcd(%rip), %rcx      # 0x8068
callq 0x2100
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0x2570
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x255e
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rsp), %ecx
andq %rcx, %rax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x28(%rsp), %eax
je 0x254b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdx
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x2559
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x24cf
jmp 0x2560
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x24a8
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: table_insert(table*, char const*, unsigned long)
void table_insert(table *table, const char* str, size_t len) {
	uint64_t hash;
	uint32_t pos;
	entry* en;
	/* lets fill factor to be 3x, so it will be easier to get collisions */
	if (table->size == table->bins) {
		table_rehash(table);
	}
	hash = hashsum(str, len);
	pos = (uint32_t)hash & (table->bins - 1);
	en = table->entries[pos];
	while (en != NULL) {
		if (en->hash == hash && en->len == len && memcmp(en->str, str, len) == 0) {
			/* found match */
			return;
		}
		en = en->next;
	}
	en = (entry*)malloc(sizeof(entry) + len);
	en->hash = hash;
	en->next = table->entries[pos];
	en->len = len;
	memcpy(en->str, str, len);
	en->str[len] = 0;
	table->entries[pos] = en;
	table->size++;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movq 0x30(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x25ae
movq 0x30(%rsp), %rdi
callq 0x23d0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x26e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2647
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x2637
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x2637
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x20c0
cmpl $0x0, %eax
jne 0x2637
jmp 0x26d8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x25ee
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2150
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x0, 0x20(%rax,%rcx)
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: funny-falcon[P]fanom_hash/test_fanom.cpp
// Function: hashsum_(char const*, unsigned long)
static inline uint64_t
_hashsum_(const char* str, size_t len) {
	if (use_32 == 0) {
		return fanom64_string_hash2(str, len, seed[0], seed[1]);
	} else {
		return fanom32_string_hash2(str, len, (uint32_t)seed[0], (uint32_t)seed[1]);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpl $0x0, 0x9bcc(%rip)      # 0xc2c0
jne 0x2719
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x9a7a(%rip), %rdx      # 0xc180
movq 0x9a7b(%rip), %rcx      # 0xc188
callq 0x3bb0
movq %rax, 0x10(%rsp)
jmp 0x2740
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x9a57(%rip), %rax      # 0xc180
movl %eax, %edx
movq 0x9a56(%rip), %rax      # 0xc188
movl %eax, %ecx
callq 0x3bf0
movl %eax, %eax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: checksum_add(char const*, unsigned long)
void checksum_add(const char* p, size_t len) {
	size_t i;
	uint64_t h0 = 0x100, h1 = 0x200;
	for (i = 0; i < len; i++) {
		h0 += (uint8_t)p[i];
		h1 += (uint8_t)p[i];
		h0 *= 0x1234567;
		h1 *= 0xabcdef9;
		h0 = rotl(h0, 13);
		h1 = rotl(h1, 19);
	}
	checksum[0] ^= h0;
	checksum[1] ^= h1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x100, -0x20(%rsp)     # imm = 0x100
movq $0x200, -0x28(%rsp)     # imm = 0x200
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x2818
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
imulq $0x1234567, -0x20(%rsp), %rax # imm = 0x1234567
movq %rax, -0x20(%rsp)
imulq $0xabcdef9, -0x28(%rsp), %rax # imm = 0xABCDEF9
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
shlq $0xd, %rax
movq -0x20(%rsp), %rcx
shrq $0x33, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
shlq $0x13, %rax
movq -0x28(%rsp), %rcx
shrq $0x2d, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x2775
movq -0x20(%rsp), %rcx
movl 0x998d(%rip), %eax      # 0xc1b0
xorq %rcx, %rax
movl %eax, 0x9984(%rip)      # 0xc1b0
movq -0x28(%rsp), %rcx
movl 0x997d(%rip), %eax      # 0xc1b4
xorq %rcx, %rax
movl %eax, 0x9974(%rip)      # 0xc1b4
retq
nopw %cs:(%rax,%rax)
// File: funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: fill_dehex()
void fill_dehex() {
	int i;
	for (i=0; i<255; i++) dehex[i] = -1;
	for (i='0'; i<='9'; i++) dehex[i] = i-'0';
	for (i='a'; i<='f'; i++) dehex[i] = i-'a'+10;
	for (i='A'; i<='F'; i++) dehex[i] = i-'A'+10;
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0xff, -0x4(%rsp)
jge 0x287f
movslq -0x4(%rsp), %rcx
leaq 0x9952(%rip), %rax      # 0xc1c0
movb $-0x1, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2858
movl $0x30, -0x4(%rsp)
cmpl $0x39, -0x4(%rsp)
jg 0x28b3
movl -0x4(%rsp), %eax
subl $0x30, %eax
movb %al, %dl
movslq -0x4(%rsp), %rcx
leaq 0x991d(%rip), %rax      # 0xc1c0
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2887
movl $0x61, -0x4(%rsp)
cmpl $0x66, -0x4(%rsp)
jg 0x28ea
movl -0x4(%rsp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, %dl
movslq -0x4(%rsp), %rcx
leaq 0x98e6(%rip), %rax      # 0xc1c0
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x28bb
movl $0x41, -0x4(%rsp)
cmpl $0x46, -0x4(%rsp)
jg 0x2921
movl -0x4(%rsp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, %dl
movslq -0x4(%rsp), %rcx
leaq 0x98af(%rip), %rax      # 0xc1c0
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x28f2
retq
nopw %cs:(%rax,%rax)