LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::longLongToString[abi:cxx11](unsigned long long, parameter*)
string kmerGraph::longLongToString(unsigned long long a, parameter *parameters)
{
	string descriptor;
        descriptor.clear();
        for(int i=0;i<parameters->hashLength;i++)
        {
                descriptor += parameters->nucleotideArray[a%4];
                a = (a>>2);
        }
        reverse(descriptor.begin(), descriptor.end());
	return descriptor;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
callq 0x8950
movq 0x10(%rsp), %rdi
callq 0x88b0
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0xaf8(%rcx), %eax
jge 0x9163
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
andl $0x3, %ecx
movsbl 0xbb8(%rax,%rcx), %esi
callq 0x83b0
jmp 0x912e
movq 0x48(%rsp), %rax
shrq $0x2, %rax
movq %rax, 0x48(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x90fc
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x8390
jmp 0x91b2
movq 0x10(%rsp), %rdi
callq 0x85a0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x8350
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd1d0
jmp 0x9192
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x91a8
movq 0x10(%rsp), %rdi
callq 0x8390
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x8c20
nopl (%rax)
// File: Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::arcPos(unsigned long long&, unsigned long long&, char, char, int)
int kmerGraph::arcPos(unsigned long long &A, unsigned long long &B, char directA, char directB, int hashLength)
{
	int lastB;
	if(directB=='+')	lastB = B%4;
	else			lastB = 3-(B>>((hashLength-1)*2));
	
	if(directA=='-')	lastB += 4;
	assert(lastB>=0&&lastB<8);
	return lastB;
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movb %cl, 0xf(%rsp)
movb %al, 0xe(%rsp)
movl %r9d, 0x8(%rsp)
movsbl 0xe(%rsp), %eax
cmpl $0x2b, %eax
jne 0x91ff
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x3, %rax
movl %eax, 0x4(%rsp)
jmp 0x9224
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rsp), %ecx
subl $0x1, %ecx
shll %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, %rcx
movl $0x3, %eax
subq %rcx, %rax
movl %eax, 0x4(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x2d, %eax
jne 0x9239
movl 0x4(%rsp), %eax
addl $0x4, %eax
movl %eax, 0x4(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x4(%rsp)
movb %al, 0x3(%rsp)
jl 0x9252
cmpl $0x8, 0x4(%rsp)
setl %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x925c
jmp 0x925e
jmp 0x927d
leaq 0xce5b(%rip), %rdi      # 0x160c0
leaq 0xcde7(%rip), %rsi      # 0x16053
movl $0x30, %edx
leaq 0xce5a(%rip), %rcx      # 0x160d2
callq 0x83d0
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::getProcsID(unsigned long long, int, MPIEnviroment*)
unsigned long long kmerGraph::getProcsID(unsigned long long kmerID, int hashLength, MPIEnviroment *MPIcontrol)
{
        unsigned long long revKmer = 0, tmpID = kmerID;
        for(int i=0;i<hashLength;i++)
        {
                revKmer = revKmer * 4;
                revKmer += ( 3 - tmpID%4 );
                tmpID = tmpID / 4;
        }

        if(revKmer>kmerID) revKmer = kmerID;

         unsigned int factor = 19;
         unsigned int numBytes = (hashLength + 3) / 4;

         unsigned long long sum = 0;
         for(unsigned i = 0; i < numBytes; i++){
                 sum = sum * factor + (revKmer & 0xFF);
                 revKmer >>= 8;
         }
         return sum % MPIcontrol->nprocs;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x930c
movq -0x28(%rsp), %rax
shlq $0x2, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rcx
andq $0x3, %rcx
movl $0x3, %eax
subq %rcx, %rax
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x30(%rsp)
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x92be
movq -0x28(%rsp), %rax
cmpq -0x10(%rsp), %rax
jbe 0x9322
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x13, -0x38(%rsp)
movl -0x14(%rsp), %eax
addl $0x3, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rsp)
movq $0x0, -0x48(%rsp)
movl $0x0, -0x4c(%rsp)
movl -0x4c(%rsp), %eax
cmpl -0x3c(%rsp), %eax
jae 0x9394
movq -0x48(%rsp), %rax
movl -0x38(%rsp), %ecx
imulq %rcx, %rax
movq -0x28(%rsp), %rcx
andq $0xff, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rsp)
movq -0x28(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x28(%rsp)
movl -0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rsp)
jmp 0x934e
movq -0x48(%rsp), %rax
movq -0x20(%rsp), %rcx
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
retq
nopl (%rax,%rax)
// File: Mengjintao[P]SWAPCounter/src/bloomFilter.h
// Function: bloomFilter::bloomAdd(unsigned long long)
int bloomAdd(unsigned long long a)
	{
//		printf("bloomAdd: %llu\n", a);
//		fflush(stdout);	
		if(size==0)	return 0;
		unsigned long long minC = (1ull<<30);
		for(int i=0; i<funNum; i++)
		{
			unsigned long long pos = hashFun(a, i);		
			pos *= bits;
			unsigned long long sum=0;
			for(int j=0; j<bits; j++)
			{
				unsigned long long k = pos+j;
				sum = sum*2 + ((bitSet[k/64]>>(k%64))&1);
			}
			
			if(sum+1<(1ull<<bits))	sum++; 
			for(int j=0;j<bits;j++)
			{
				unsigned long long k = pos+j;
				bitSet[k/64] &= ~((unsigned long long) 1 << (k%64)); 
				bitSet[k/64] |= ( ((sum>>(bits-1-j))&1) << (k%64));
			}
			minC = min(minC, sum);
		}
		return (int) minC;
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0xd32c
movl $0x0, 0x64(%rsp)
jmp 0xd4f5
movq $0x40000000, 0x48(%rsp) # imm = 0x40000000
movl $0x0, 0x44(%rsp)
movq 0x8(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0x14(%rcx), %eax
jge 0xd4ec
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x44(%rsp), %edx
callq 0x11ed0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rsp)
movslq 0x10(%rax), %rax
imulq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0xd3f4
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rdx
addq %rdx, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
shlq %rax
movq (%rcx), %rcx
movq 0x20(%rsp), %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x20(%rsp), %rcx
andq $0x3f, %rcx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0x1, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xd38f
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
addq $0x1, %rax
movl 0x10(%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jae 0xd423
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0xd4c5
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %esi
shlq %cl, %rsi
xorq $-0x1, %rsi
movq (%rax), %rcx
movq 0x10(%rsp), %rdx
shrq $0x6, %rdx
andq (%rcx,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
movq 0x30(%rsp), %rdx
movl 0x10(%rax), %ecx
subl $0x1, %ecx
subl 0x1c(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
andq $0x1, %rdx
movq 0x10(%rsp), %rcx
andq $0x3f, %rcx
shlq %cl, %rdx
movq (%rax), %rax
movq 0x10(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xd42b
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11f90
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xd33d
movq 0x48(%rsp), %rax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nop
// File: Mengjintao[P]SWAPCounter/src/kmerGraph.h
// Function: kmerGraph::kmerGraph()
kmerGraph()
	{
		size     = 0;
		read_pos = 0;
		commtime = 0;
		commtimetot = 0;
		cuttime = 0;
		storagetime = 0;	
		
		MPI_Type_contiguous(KMER_COMM_TYPE_LEN, MPI_UNSIGNED_LONG_LONG, &commType);
		MPI_Type_commit(&commType);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x11ff0
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x10(%rsp)
callq 0x11ff0
movq 0x18(%rsp), %rdx
movq $0x0, 0x70(%rdx)
movq $0x0, 0x78(%rdx)
movq $0x0, 0x80(%rdx)
movq $0x0, 0x88(%rdx)
movq $0x0, 0x90(%rdx)
movq $0x0, 0x98(%rdx)
addq $0xa0, %rdx
movq 0xf97e(%rip), %rsi      # 0x1cff0
movl $0xa, %edi
callq 0x83a0
jmp 0xd67e
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x8850
jmp 0xd691
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x12000
movq 0x18(%rsp), %rdi
callq 0x12000
movq 0x28(%rsp), %rdi
callq 0x8c20
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Mengjintao[P]SWAPCounter/src/bloomFilter.h
// Function: bloomFilter::hashFun(unsigned long long, int)
unsigned long long hashFun(unsigned long long a, int index)
	{
//		printf("hashFun a, index =%llu %d %d\n", a, index, factorArray.size());
//		fflush(stdout); 
         	unsigned long long factor = factorArray[index];
        	unsigned long long sum = 0;
         	for(unsigned i = 0; i<8; i++){
                 	sum = (sum * factor + (a & 0xFFFFFFFF))%size;
			if(a==0)	break;
			a = (a>>8);
         	}
         	return sum%size;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0x11fd0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jae 0x11f6a
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
imulq 0x18(%rsp), %rax
movabsq $0xffffffff, %rdx       # imm = 0xFFFFFFFF
andq 0x28(%rsp), %rdx
addq %rdx, %rax
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x11f4f
jmp 0x11f6a
movq 0x28(%rsp), %rax
shrq $0x8, %rax
movq %rax, 0x28(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11f12
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Mengjintao[P]SWAPCounter/src/mympi.cpp
// Function: MPIEnviroment::init(int, char**)
void MPIEnviroment::init(int argc, char *argv[])
{
	elapsedTime = 0;
	locateTime = 0;
	readTime = 0;
	groupProc=1;
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
	MPI_Get_processor_name(processor_name, &namelen);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x248(%rax)
movq $0x0, 0x250(%rax)
movq $0x0, 0x258(%rax)
movl $0x1, 0x278(%rax)
leaq 0x1c(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x89b0
movq 0x8(%rsp), %rsi
movq 0x7d2e(%rip), %rdi      # 0x1cf90
callq 0x89a0
movq 0x8(%rsp), %rsi
addq $0x4, %rsi
movq 0x7d19(%rip), %rdi      # 0x1cf90
callq 0x87a0
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x20c, %rsi            # imm = 0x20C
callq 0x8790
addq $0x28, %rsp
retq
nopl (%rax)
// File: Mengjintao[P]SWAPCounter/src/mympi.cpp
// Function: MPIEnviroment::print(char const*)
void MPIEnviroment::print(const char *message)
{
	int who = RUSAGE_SELF;
	struct rusage usage;
	int usageErrno;
	usageErrno = getrusage(who, &usage);
	if(usageErrno == EFAULT)  		printf("Error: EFAULT\n");
	else if(usageErrno == EINVAL) 		printf("Error: EINVAL\n");

	printf("Proc:%d (%s)[Mem=%ld KB] -> %s\n", rank, processor_name, usage.ru_maxrss, message); 
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xa4(%rsp)
movl 0xa4(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0x82f0
movl %eax, 0xc(%rsp)
cmpl $0xe, 0xc(%rsp)
jne 0x152fa
leaq 0x1a79(%rip), %rdi      # 0x16d6a
movb $0x0, %al
callq 0x8040
jmp 0x15311
cmpl $0x16, 0xc(%rsp)
jne 0x1530f
leaq 0x1a71(%rip), %rdi      # 0x16d79
movb $0x0, %al
callq 0x8040
jmp 0x15311
movq (%rsp), %rdx
movl (%rdx), %esi
addq $0x8, %rdx
movq 0x30(%rsp), %rcx
movq 0xa8(%rsp), %r8
leaq 0x1a59(%rip), %rdi      # 0x16d88
movb $0x0, %al
callq 0x8040
addq $0xb8, %rsp
retq
nop
// File: Mengjintao[P]SWAPCounter/src/mympi.cpp
// Function: MPIEnviroment::print(char const*, _IO_FILE*)
void MPIEnviroment::print(const char *message, FILE *fp)
{
	int who = RUSAGE_SELF;
	struct rusage usage;
	int usageErrno;
	usageErrno = getrusage(who, &usage);
	if(usageErrno == EFAULT)  		printf("Error: EFAULT\n");
	else if(usageErrno == EINVAL) 		printf("Error: EINVAL\n");

	fprintf(fp, "Proc:%d [Mem=%ld KB] ->%s\n", rank, usage.ru_maxrss, message);	
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0xac(%rsp)
movl 0xac(%rsp), %edi
leaq 0x18(%rsp), %rsi
callq 0x82f0
movl %eax, 0x14(%rsp)
cmpl $0xe, 0x14(%rsp)
jne 0x153a3
leaq 0x19d0(%rip), %rdi      # 0x16d6a
movb $0x0, %al
callq 0x8040
jmp 0x153ba
cmpl $0x16, 0x14(%rsp)
jne 0x153b8
leaq 0x19c8(%rip), %rdi      # 0x16d79
movb $0x0, %al
callq 0x8040
jmp 0x153ba
movq 0x8(%rsp), %rax
movq 0xb0(%rsp), %rdi
movl (%rax), %edx
movq 0x38(%rsp), %rcx
movq 0xb8(%rsp), %r8
leaq 0x19cb(%rip), %rsi      # 0x16da8
movb $0x0, %al
callq 0x8a00
addq $0xc8, %rsp
retq
nopl (%rax)
// File: Mengjintao[P]SWAPCounter/src/mympi.cpp
// Function: MPIEnviroment::File_open(char*)
void MPIEnviroment::File_open(char *File_name)
{
	if(rank%this->groupProc)	return;
	clock_t startTime, endTime;

	startTime = clock();	
        rc = MPI_File_open(MPI_COMM_SELF, File_name, MPI_MODE_RDONLY, MPI_INFO_NULL, &cFile);

        if(rc) {
                printf("Proc:%d Unable to open file \"%s\"\n", rank, File_name); fflush(stdout);
                exit(0);
        }
        else    {
                printf("Proc:%d file\"%s\" opened ...\n", rank, File_name);
        }
	endTime = clock();
	elapsedTime += endTime-startTime;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl (%rcx), %eax
cltd
idivl 0x278(%rcx)
cmpl $0x0, %edx
je 0x1545a
jmp 0x15512
callq 0x83e0
movq (%rsp), %r8
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rsi
addq $0x218, %r8             # imm = 0x218
movq 0x7b55(%rip), %rdi      # 0x1cfd0
movl $0x2, %edx
movq 0x7b41(%rip), %rcx      # 0x1cfc8
callq 0x8400
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x210(%rax)
cmpl $0x0, 0x210(%rax)
je 0x154d0
movq (%rsp), %rax
movl (%rax), %esi
movq 0x18(%rsp), %rdx
leaq 0x1959(%rip), %rdi      # 0x16e0c
movb $0x0, %al
callq 0x8040
movq 0x7aaf(%rip), %rax      # 0x1cf70
movq (%rax), %rdi
callq 0x87b0
xorl %edi, %edi
callq 0x8800
movq (%rsp), %rax
movl (%rax), %esi
movq 0x18(%rsp), %rdx
leaq 0x194c(%rip), %rdi      # 0x16e2e
movb $0x0, %al
callq 0x8040
callq 0x83e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
subq 0x10(%rsp), %rcx
addq 0x248(%rax), %rcx
movq %rcx, 0x248(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Mengjintao[P]SWAPCounter/src/mympi.cpp
// Function: MPIEnviroment::File_read(char*, long long)
unsigned long long MPIEnviroment::File_read(char *buf, long long int n)
{
	if(rank%this->groupProc)	return 0;
	clock_t startTime, endTime;
	startTime = clock();
	long long int len = n<datasize? n : datasize;
	MPI_File_read_at_all(cFile, read_offset, buf, len, MPI_CHAR, &status);
	read_offset += len;	
	datasize -= len;
	endTime = clock();
	elapsedTime += endTime-startTime;
	readTime += endTime-startTime;
	return len;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl (%rcx), %eax
cltd
idivl 0x278(%rcx)
cmpl $0x0, %edx
je 0x159f9
movq $0x0, 0x40(%rsp)
jmp 0x15ae6
callq 0x83e0
movq 0x8(%rsp), %rcx
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x238(%rcx), %rax
jge 0x15a21
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
jmp 0x15a31
movq 0x8(%rsp), %rax
movq 0x238(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %r9
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x218(%r9), %rdi
movq 0x240(%r9), %rsi
movq 0x30(%rsp), %rdx
movq 0x10(%rsp), %rax
movl %eax, %ecx
addq $0x260, %r9             # imm = 0x260
movq 0x7511(%rip), %r8       # 0x1cf78
callq 0x8a80
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x240(%rax), %rcx
movq %rcx, 0x240(%rax)
movq 0x10(%rsp), %rdx
movq 0x238(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x238(%rax)
callq 0x83e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rcx
addq 0x248(%rax), %rcx
movq %rcx, 0x248(%rax)
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rcx
addq 0x258(%rax), %rcx
movq %rcx, 0x258(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: Mengjintao[P]SWAPCounter/src/mympi.cpp
// Function: MPIEnviroment::File_write(char*, char const*, unsigned long long)
void MPIEnviroment::File_write(char *filename, const char *buf, unsigned long long int n)
{
	clock_t startTime, endTime;
	startTime = clock();
	MPI_File writeFile;
	rc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_CREATE|MPI_MODE_WRONLY, MPI_INFO_NULL, &writeFile);
//        rc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_CREATE|MPI_MODE_APPEND, MPI_INFO_NULL, &writeFile);
        if(rc) {
                printf("Proc:%d Unable to open file \"%s\"\n", rank, filename); fflush(stdout);
                exit(0);
        }
        else    {
                printf("Proc:%d file\"%s\" was opened ...\n", rank, filename);
        }

	char *localBuf = const_cast<char*> (buf);
	unsigned long long  startPos;
	MPI_Scan(&n, &startPos, 1, MPI_UNSIGNED_LONG_LONG, MPI_SUM, MPI_COMM_WORLD);
	startPos = startPos-n;

	MPI_Status writeStatus;
	MPI_File_write_at_all(writeFile, startPos, localBuf, n, MPI_CHAR, &writeStatus);
	MPI_File_close(&writeFile);

	endTime = clock();
	elapsedTime += endTime-startTime;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
callq 0x83e0
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rsi
movq 0x7469(%rip), %rdi      # 0x1cf90
movl $0x5, %edx
movq 0x7495(%rip), %rcx      # 0x1cfc8
leaq 0x30(%rsp), %r8
callq 0x8400
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x210(%rax)
cmpl $0x0, 0x210(%rax)
je 0x15b81
movq (%rsp), %rax
movl (%rax), %esi
movq 0x58(%rsp), %rdx
leaq 0x12a8(%rip), %rdi      # 0x16e0c
movb $0x0, %al
callq 0x8040
movq 0x73fe(%rip), %rax      # 0x1cf70
movq (%rax), %rdi
callq 0x87b0
xorl %edi, %edi
callq 0x8800
movq (%rsp), %rax
movl (%rax), %esi
movq 0x58(%rsp), %rdx
leaq 0x1325(%rip), %rdi      # 0x16eb8
movb $0x0, %al
callq 0x8040
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x1, %edx
movq 0x7436(%rip), %rcx      # 0x1cff0
movq 0x73a7(%rip), %r8       # 0x1cf68
movq 0x73c8(%rip), %r9       # 0x1cf90
callq 0x8780
movq 0x20(%rsp), %rax
subq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x48(%rsp), %rax
movl %eax, %ecx
movq 0x737f(%rip), %r8       # 0x1cf78
leaq 0x8(%rsp), %r9
callq 0x88d0
leaq 0x30(%rsp), %rdi
callq 0x8a10
callq 0x83e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rcx
subq 0x40(%rsp), %rcx
addq 0x248(%rax), %rcx
movq %rcx, 0x248(%rax)
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: syky27[P]TicTacToe/src/DNGame.cpp
// Function: DNGame::DNGame(int)
DNGame::DNGame(int i) : y_offset(3), x_offset(0), playerOne(NULL), playerTwo(NULL)
{
    switch (i) {
    case 1:
    {
        initLocalGameTwoHumans();
        break;
    }
    case 2:
    {
        initLocalGameHumanVsCPU();
        break;
    }
    case 3:
    {
        initRemoteGameTwoHumans();
        break;
    }
    case 27:
    {
        initLocalGameTwoDumb();
        break;
    }
    default:
    {
        break;
    }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x5730
movq -0x30(%rbp), %rax
movl $0x3, 0x138a0(%rax)
movl $0x0, 0x138a4(%rax)
movq $0x0, 0x138a8(%rax)
movq $0x0, 0x138b0(%rax)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x1a, %eax
ja 0x47a0
movq -0x28(%rbp), %rax
leaq 0x791c(%rip), %rcx      # 0xc068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
callq 0x47c0
jmp 0x4760
jmp 0x47a2
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5810
jmp 0x47a8
movq -0x38(%rbp), %rdi
callq 0x49c0
jmp 0x4784
jmp 0x47a2
movq -0x38(%rbp), %rdi
callq 0x4bc0
jmp 0x4791
jmp 0x47a2
movq -0x38(%rbp), %rdi
callq 0x4cf0
jmp 0x479e
jmp 0x47a2
jmp 0x47a2
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: syky27[P]TicTacToe/src/DNGame.cpp
// Function: DNGame::initLocalGameTwoHumans()
void DNGame::initLocalGameTwoHumans()
{
    string nameOfFirstPlayer, nameOfSecondPlayer;
    DNWindow::getInstance().startLocalGameTwoHumans(nameOfFirstPlayer, nameOfSecondPlayer);
    this->playerOne = new DNHumanPlayer(nameOfFirstPlayer, DNCellState(CROSS), &map);
    this->playerTwo = new DNHumanPlayer(nameOfSecondPlayer, DNCellState(CIRCLE), &map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34e0
leaq -0x48(%rbp), %rdi
callq 0x34e0
callq 0x3a90
movq %rax, -0xb0(%rbp)
jmp 0x47fa
movq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xb100
jmp 0x4810
movl $0x50, %edi
callq 0x3370
movq %rax, -0xc0(%rbp)
jmp 0x4823
movb $0x1, -0x79(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3190
jmp 0x4836
movq -0xb8(%rbp), %rcx
movq -0xc0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x2, %edx
callq 0x4fc0
jmp 0x4854
movq -0xb8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movb $0x0, -0x79(%rbp)
movq %rcx, 0x138a8(%rax)
leaq -0x78(%rbp), %rdi
callq 0x3200
movl $0x50, %edi
callq 0x3370
movq %rax, -0xc8(%rbp)
jmp 0x4889
movb $0x1, -0xa1(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3190
jmp 0x48a2
movq -0xb8(%rbp), %rcx
movq -0xc8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x1, %edx
callq 0x4fc0
jmp 0x48c3
movq -0xb8(%rbp), %rax
movq -0xc8(%rbp), %rcx
movb $0x0, -0xa1(%rbp)
movq %rcx, 0x138b0(%rax)
leaq -0xa0(%rbp), %rdi
callq 0x3200
leaq -0x48(%rbp), %rdi
callq 0x3200
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4999
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x493a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3200
testb $0x1, -0x79(%rbp)
jne 0x4942
jmp 0x4953
movq -0xc0(%rbp), %rdi
movl $0x50, %esi
callq 0x3390
jmp 0x4999
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x497b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3200
testb $0x1, -0xa1(%rbp)
jne 0x4986
jmp 0x4997
movq -0xc8(%rbp), %rdi
movl $0x50, %esi
callq 0x3390
jmp 0x4999
leaq -0x48(%rbp), %rdi
callq 0x3200
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x50(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: syky27[P]TicTacToe/src/DNGame.cpp
// Function: DNGame::initLocalGameHumanVsCPU()
void DNGame::initLocalGameHumanVsCPU()
{
    string nameOfFirstPlayer;
    DNWindow::getInstance().startLocalGameHumanVsCPU(nameOfFirstPlayer);
    this->playerOne = new DNHumanPlayer(nameOfFirstPlayer, DNCellState(CROSS), &map);
//    this->playerTwo = new DNDumbBotPlayer("CPU",DNCellState(CIRCLE), & map);
    this->playerTwo =new DNSmarterBotPlayer("CPU", CIRCLE, &map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34e0
callq 0x3a90
movq %rax, -0x90(%rbp)
jmp 0x49f1
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb440
jmp 0x4a03
movl $0x50, %edi
callq 0x3370
movq %rax, -0xa0(%rbp)
jmp 0x4a16
movb $0x1, -0x59(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3190
jmp 0x4a29
movq -0x98(%rbp), %rcx
movq -0xa0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x2, %edx
callq 0x4fc0
jmp 0x4a47
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rcx
movb $0x0, -0x59(%rbp)
movq %rcx, 0x138a8(%rax)
leaq -0x58(%rbp), %rdi
callq 0x3200
movl $0x80, %edi
callq 0x3370
movq %rax, -0xa8(%rbp)
jmp 0x4a7c
movb $0x1, -0x82(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x35e0
movq -0xb0(%rbp), %rdx
leaq 0x7a29(%rip), %rsi      # 0xc4cd
leaq -0x80(%rbp), %rdi
callq 0x42f0
jmp 0x4aaf
movq -0x98(%rbp), %rcx
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x1, %edx
callq 0x8100
jmp 0x4acd
movq -0x98(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb $0x0, -0x82(%rbp)
movq %rcx, 0x138b0(%rax)
leaq -0x80(%rbp), %rdi
callq 0x3200
leaq -0x81(%rbp), %rdi
callq 0x3400
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4bac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4b44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3200
testb $0x1, -0x59(%rbp)
jne 0x4b4c
jmp 0x4b5d
movq -0xa0(%rbp), %rdi
movl $0x50, %esi
callq 0x3390
jmp 0x4bac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4b82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3200
leaq -0x81(%rbp), %rdi
callq 0x3400
testb $0x1, -0x82(%rbp)
jne 0x4b99
jmp 0x4baa
movq -0xa8(%rbp), %rdi
movl $0x80, %esi
callq 0x3390
jmp 0x4bac
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x30(%rbp), %rdi
callq 0x35d0
nop
// File: syky27[P]TicTacToe/src/DNGame.cpp
// Function: DNGame::initRemoteGameTwoHumans()
void DNGame::initRemoteGameTwoHumans()
{
    string nameOfPlayer;
    int server = DNWindow::getInstance().startRemoteGameTwoHumans(nameOfPlayer);
    server--;
    this->playerOne = new DNRemoteHumanPlayer(nameOfPlayer, DNCellState(CROSS), &map, (bool)server);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34e0
callq 0x3a90
movq %rax, -0x70(%rbp)
jmp 0x4beb
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb5f0
movl %eax, -0x7c(%rbp)
jmp 0x4bfd
movl -0x7c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
decl %eax
movl %eax, -0x2c(%rbp)
movl $0x58, %edi
callq 0x3370
movq %rax, -0x88(%rbp)
jmp 0x4c1e
movb $0x1, -0x61(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3190
jmp 0x4c31
movq -0x78(%rbp), %rcx
movq -0x88(%rbp), %rdi
movl -0x2c(%rbp), %eax
testl %eax, %eax
setne %al
movzbl %al, %r8d
leaq -0x60(%rbp), %rsi
movl $0x2, %edx
callq 0x7210
jmp 0x4c58
movq -0x78(%rbp), %rax
movq -0x88(%rbp), %rcx
movb $0x0, -0x61(%rbp)
movq %rcx, 0x138a8(%rax)
leaq -0x60(%rbp), %rdi
callq 0x3200
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4cd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4cba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3200
testb $0x1, -0x61(%rbp)
jne 0x4cc2
jmp 0x4cd3
movq -0x88(%rbp), %rdi
movl $0x58, %esi
callq 0x3390
jmp 0x4cd5
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rdi
callq 0x35d0
nopw (%rax,%rax)
// File: syky27[P]TicTacToe/src/DNGame.cpp
// Function: DNGame::play()
void DNGame::play()
{
//    DNWindow::getInstance().allowMacDev();
    int turnCounter = 0;
    while (true) {
        turnCounter++;
        if (turnCounter % 2) {
            this->playerOne->triggerTurn(3, 0);
        }else{
            this->playerTwo->triggerTurn(3, 0);
        }
    }
 
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4f6d
movq -0x18(%rbp), %rax
movq 0x138a8(%rax), %rdi
movq (%rdi), %rax
movl $0x3, %esi
xorl %edx, %edx
callq *(%rax)
jmp 0x4f84
movq -0x18(%rbp), %rax
movq 0x138b0(%rax), %rdi
movq (%rdi), %rax
movl $0x3, %esi
xorl %edx, %edx
callq *(%rax)
jmp 0x4f3b
nopw %cs:(%rax,%rax)
// File: syky27[P]TicTacToe/src/DNLogService.cpp
// Function: DNLogService::operator<<(int)
DNLogService &  DNLogService::operator << (const int num){
    stringstream tmp;
    tmp << num;
    log(tmp.str());
    return sharedObject();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3270
leaq -0x188(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x35b0
jmp 0x560a
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3350
jmp 0x561f
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x53e0
jmp 0x5634
leaq -0x1c8(%rbp), %rdi
callq 0x3200
callq 0x43c0
movq %rax, -0x1d8(%rbp)
jmp 0x564e
leaq -0x198(%rbp), %rdi
callq 0x3290
movq -0x1d8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x569c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3200
leaq -0x198(%rbp), %rdi
callq 0x3290
movq -0x1a0(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: syky27[P]TicTacToe/src/DNMap.cpp
// Function: DNMap::DNMap()
DNMap::DNMap(){
    this->size = 100;
    this->col = 100;
    this->row = 100;
    this->goal = 5;
    for (size_t i = 0; i < 100; i++) {
        for (size_t j = 0; j < 100; j++) {
            my_map[i][j] = new DNCell(i,j);
        }
    }
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x64, (%rax)
movl $0x64, 0xc(%rax)
movl $0x64, 0x8(%rax)
movl $0x5, 0x10(%rax)
movq $0x0, -0x10(%rbp)
cmpq $0x64, -0x10(%rbp)
jae 0x5801
movq $0x0, -0x18(%rbp)
cmpq $0x64, -0x18(%rbp)
jae 0x57ee
movl $0x18, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b50
jmp 0x57a5
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
addq $0x18, %rax
imulq $0x320, -0x10(%rbp), %rcx # imm = 0x320
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x577b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x3390
jmp 0x5807
jmp 0x57f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5768
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x35d0
// File: syky27[P]TicTacToe/src/DNMap.cpp
// Function: DNMap::debugToFile()
void DNMap::debugToFile()
{
    
    std::stringstream ss;
    for (size_t i = 0; i < size; i++) {
        for (size_t j = 0; j < size; j++) {
            if (my_map[i][j]->getState() == CROSS) {
                ss << "X";
            }else if (my_map[i][j]->getState() == CIRCLE) {
                ss << "O";
            }
            else {
                ss << '.';
            }
        }
        ss << endl;

    }
    ss << endl << endl;
    
    DNLogService::sharedObject().log(ss.str());

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x3270
movq $0x0, -0x198(%rbp)
movq -0x1d8(%rbp), %rcx
movq -0x198(%rbp), %rax
cmpq (%rcx), %rax
jae 0x5a58
movq $0x0, -0x1a0(%rbp)
movq -0x1d8(%rbp), %rcx
movq -0x1a0(%rbp), %rax
cmpq (%rcx), %rax
jae 0x5a2a
movq -0x1d8(%rbp), %rax
movq -0x198(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movq -0x1a0(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x3bb0
movl %eax, -0x1dc(%rbp)
jmp 0x596b
movl -0x1dc(%rbp), %eax
cmpl $0x2, %eax
jne 0x59a7
leaq -0x180(%rbp), %rdi
leaq 0x6783(%rip), %rsi      # 0xc107
callq 0x3360
jmp 0x598b
jmp 0x5a11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x5b00
movq -0x1d8(%rbp), %rax
movq -0x198(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movq -0x1a0(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x3bb0
movl %eax, -0x1e0(%rbp)
jmp 0x59d8
movl -0x1e0(%rbp), %eax
cmpl $0x1, %eax
jne 0x59fa
leaq -0x180(%rbp), %rdi
leaq 0x6718(%rip), %rsi      # 0xc109
callq 0x3360
jmp 0x59f8
jmp 0x5a0f
leaq -0x180(%rbp), %rdi
movl $0x2e, %esi
callq 0x3470
jmp 0x5a0d
jmp 0x5a0f
jmp 0x5a11
jmp 0x5a13
movq -0x1a0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1a0(%rbp)
jmp 0x5923
leaq -0x180(%rbp), %rdi
movq 0xb580(%rip), %rsi      # 0x10fb8
callq 0x33e0
jmp 0x5a3f
jmp 0x5a41
movq -0x198(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x198(%rbp)
jmp 0x5901
leaq -0x180(%rbp), %rdi
movq 0xb552(%rip), %rsi      # 0x10fb8
callq 0x33e0
movq %rax, -0x1e8(%rbp)
jmp 0x5a74
movq -0x1e8(%rbp), %rdi
movq 0xb536(%rip), %rsi      # 0x10fb8
callq 0x33e0
jmp 0x5a89
callq 0x43c0
movq %rax, -0x1f0(%rbp)
jmp 0x5a97
leaq -0x1d0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x3350
jmp 0x5aac
movq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x53e0
jmp 0x5ac1
leaq -0x1d0(%rbp), %rdi
callq 0x3200
leaq -0x190(%rbp), %rdi
callq 0x3290
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3200
leaq -0x190(%rbp), %rdi
callq 0x3290
movq -0x1a8(%rbp), %rdi
callq 0x35d0
nopl (%rax,%rax)
// File: syky27[P]TicTacToe/src/DNMap.cpp
// Function: DNMap::recordMove(DNCellState, int, int, DNCellState&)
bool DNMap::recordMove(DNCellState  player, int y, int x, DNCellState & winner){
    if (this->my_map[x][y]->getState() == EMPTY) {
//        this->filled.push_back(this->my_map[x][y]);
        this->my_map[x][y]->setState(player);
        winner = this->checkForWinnerWithSymbol(player);
        return true;
    }
    
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3bb0
cmpl $0x0, %eax
jne 0x5ec5
movq -0x30(%rbp), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x14(%rbp), %esi
callq 0x3b90
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5b20
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5ec9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: syky27[P]TicTacToe/src/DNNetworkConnection.cpp
// Function: DNNetworkConnection::sendData(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DNNetworkConnection::sendData(int socketDescriptor, string message)
{
    if (send(socketDescriptor, (void *) message . c_str(), message . size(), 0) < 0) {
        string fekalError("ERROR => Send failed!");
        DNLogService::sharedObject() << "ERROR => " << "Send failed!" << "\n";
        DNWindow::getInstance().terminateWithErrorMessage(fekalError);
        return false;
    }
    DNLogService::sharedObject() << "INFO => " << "This data sent ==> " << message << "\n";
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xb8(%rbp)
movq %rdi, %rax
movq -0xb8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq %rax, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xa4(%rbp)
callq 0x3180
movq -0xb0(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x3250
movl -0xa4(%rbp), %edi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
cmpq $0x0, %rax
jge 0x6f02
leaq -0x41(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x35e0
movq -0xc0(%rbp), %rdx
leaq 0x551b(%rip), %rsi      # 0xc319
leaq -0x40(%rbp), %rdi
callq 0x42f0
jmp 0x6e09
leaq -0x41(%rbp), %rdi
callq 0x3400
callq 0x43c0
movq %rax, -0xc8(%rbp)
jmp 0x6e20
movq -0xc8(%rbp), %rdi
leaq 0x52dd(%rip), %rsi      # 0xc10b
callq 0x5520
movq %rax, -0xd0(%rbp)
jmp 0x6e3c
movq -0xd0(%rbp), %rdi
leaq 0x54d8(%rip), %rsi      # 0xc322
callq 0x5520
movq %rax, -0xd8(%rbp)
jmp 0x6e58
movq -0xd8(%rbp), %rdi
leaq 0x56f4(%rip), %rsi      # 0xc55a
callq 0x5520
jmp 0x6e6d
callq 0x3a90
movq %rax, -0xe0(%rbp)
jmp 0x6e7b
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3190
jmp 0x6e8a
movq -0xe0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xaf80
jmp 0x6e9c
leaq -0x78(%rbp), %rdi
callq 0x3200
movb $0x0, -0x1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3200
jmp 0x6fa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3400
jmp 0x6fb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6ef4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3200
leaq -0x40(%rbp), %rdi
callq 0x3200
jmp 0x6fb1
callq 0x43c0
movq %rax, %rdi
leaq 0x5280(%rip), %rsi      # 0xc191
callq 0x5520
movq %rax, %rdi
leaq 0x540f(%rip), %rsi      # 0xc32f
callq 0x5520
movq -0xb0(%rbp), %rsi
movq %rax, -0xf8(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3190
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x56c0
movq %rax, -0xe8(%rbp)
jmp 0x6f62
movq -0xe8(%rbp), %rdi
leaq 0x55ea(%rip), %rsi      # 0xc55a
callq 0x5520
jmp 0x6f77
leaq -0x98(%rbp), %rdi
callq 0x3200
movb $0x1, -0x1(%rbp)
jmp 0x6fa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3200
jmp 0x6fb1
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x35d0
nopw (%rax,%rax)
// File: syky27[P]TicTacToe/src/DNNetworkConnection.cpp
// Function: DNNetworkConnection::receiveData[abi:cxx11](int)
string DNNetworkConnection::receiveData(int socketDescriptor)
{
    char buffer[1024];
    /* cekame na data. navratova hodnota = pocet ziskanych bajtu */
    memset(buffer, 0, sizeof ( buffer));

    recv(socketDescriptor, buffer, sizeof ( buffer), 0);
    stringstream ss;
    ss << buffer;
    DNLogService::sharedObject() << "INFO => " << "This Data received" << ss.str() << "\n";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x620, %rsp            # imm = 0x620
movq %rdi, -0x600(%rbp)
movq %rdi, %rax
movq %rax, -0x5f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x420(%rbp), %rdi
movq %rdi, -0x5e0(%rbp)
xorl %esi, %esi
movl %esi, -0x5e4(%rbp)
movl $0x400, %edx            # imm = 0x400
movq %rdx, -0x5f0(%rbp)
callq 0x31e0
movq -0x5f0(%rbp), %rdx
movl -0x5e4(%rbp), %ecx
movq -0x5e0(%rbp), %rsi
movl -0x14(%rbp), %edi
callq 0x3130
leaq -0x5a8(%rbp), %rdi
callq 0x3270
movq -0x5e0(%rbp), %rsi
leaq -0x598(%rbp), %rdi
callq 0x3360
jmp 0x704b
callq 0x43c0
movq %rax, -0x608(%rbp)
jmp 0x7059
movq -0x608(%rbp), %rdi
leaq 0x512a(%rip), %rsi      # 0xc191
callq 0x5520
movq %rax, -0x610(%rbp)
jmp 0x7075
movq -0x610(%rbp), %rdi
leaq 0x52c0(%rip), %rsi      # 0xc343
callq 0x5520
movq %rax, -0x618(%rbp)
jmp 0x7091
leaq -0x5d8(%rbp), %rdi
leaq -0x5a8(%rbp), %rsi
callq 0x3350
jmp 0x70a6
movq -0x618(%rbp), %rdi
leaq -0x5d8(%rbp), %rsi
callq 0x56c0
movq %rax, -0x620(%rbp)
jmp 0x70c2
movq -0x620(%rbp), %rdi
leaq 0x548a(%rip), %rsi      # 0xc55a
callq 0x5520
jmp 0x70d7
leaq -0x5d8(%rbp), %rdi
callq 0x3200
movq -0x600(%rbp), %rdi
leaq -0x5a8(%rbp), %rsi
callq 0x3350
jmp 0x70f8
leaq -0x5a8(%rbp), %rdi
callq 0x3290
movq -0x5f8(%rbp), %rax
addq $0x620, %rsp            # imm = 0x620
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5b0(%rbp)
movl %eax, -0x5b4(%rbp)
jmp 0x7146
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5b0(%rbp)
movl %eax, -0x5b4(%rbp)
leaq -0x5d8(%rbp), %rdi
callq 0x3200
leaq -0x5a8(%rbp), %rdi
callq 0x3290
movq -0x5b0(%rbp), %rdi
callq 0x35d0
nop
// File: syky27[P]TicTacToe/src/DNRemoteHumanPlayer.cpp
// Function: DNRemoteHumanPlayer::DNRemoteHumanPlayer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, DNCellState, DNMap*, bool)
DNRemoteHumanPlayer::DNRemoteHumanPlayer(string nick, DNCellState symbol, DNMap* map, bool server)
{
    
    this->nick = nick;
    this->symbol = symbol;
    this->game_map = map;
    this->amIServer = server;
    if(server) this->clientSocket = DNNetworkConnection::getInstance().startServer();
    else this->clientSocket = DNNetworkConnection::getInstance().connectToServer();
    cout << server;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x40(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x8010
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0x9ad9(%rip), %rax      # 0x10d28
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x3030
jmp 0x725d
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movb -0x21(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x50(%rax)
testb $0x1, -0x21(%rbp)
je 0x72ba
callq 0x8050
movq %rax, -0x50(%rbp)
jmp 0x7289
movq -0x50(%rbp), %rdi
callq 0x5ee0
movl %eax, -0x54(%rbp)
jmp 0x7297
movq -0x48(%rbp), %rax
movl -0x54(%rbp), %ecx
movl %ecx, 0x54(%rax)
jmp 0x72dd
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5040
jmp 0x72f8
callq 0x8050
movq %rax, -0x60(%rbp)
jmp 0x72c5
movq -0x60(%rbp), %rdi
callq 0x6700
movl %eax, -0x64(%rbp)
jmp 0x72d3
movq -0x48(%rbp), %rax
movl -0x64(%rbp), %ecx
movl %ecx, 0x54(%rax)
movzbl -0x21(%rbp), %esi
andl $0x1, %esi
movq 0x9ced(%rip), %rdi      # 0x10fd8
callq 0x35f0
jmp 0x72f2
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: syky27[P]TicTacToe/src/DNRemoteHumanPlayer.cpp
// Function: DNRemoteHumanPlayer::transferQuitGame()
void DNRemoteHumanPlayer::transferQuitGame()
{
    DNNetworkConnection::getInstance().sendData(this->clientSocket, string("QUIT"));
    //close connection;
    DNNetworkConnection::getInstance().closeConnection(this->clientSocket);
    DNWindow::getInstance().terminateWithErrorMessage(string("You Have Quited this game :(   "));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x8050
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x80(%rbp)
movl 0x54(%rax), %eax
movl %eax, -0x74(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x35e0
movq -0x70(%rbp), %rdx
leaq 0x46bf(%rip), %rsi      # 0xc3ea
leaq -0x28(%rbp), %rdi
callq 0x42f0
jmp 0x7d36
movl -0x74(%rbp), %esi
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x6d70
jmp 0x7d48
leaq -0x28(%rbp), %rdi
callq 0x3200
leaq -0x29(%rbp), %rdi
callq 0x3400
callq 0x8050
movq %rax, %rdi
movq -0x88(%rbp), %rax
movl 0x54(%rax), %esi
callq 0x7160
callq 0x3a90
movq %rax, -0x98(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x35e0
movq -0x90(%rbp), %rdx
leaq 0x4654(%rip), %rsi      # 0xc3ef
leaq -0x60(%rbp), %rdi
callq 0x42f0
jmp 0x7da6
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xaf80
jmp 0x7db8
leaq -0x60(%rbp), %rdi
callq 0x3200
leaq -0x61(%rbp), %rdi
callq 0x3400
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7df6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3200
leaq -0x29(%rbp), %rdi
callq 0x3400
jmp 0x7e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7e24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3200
leaq -0x61(%rbp), %rdi
callq 0x3400
movq -0x38(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: syky27[P]TicTacToe/src/DNRemoteHumanPlayer.cpp
// Function: DNRemoteHumanPlayer::transferTurn(int, int)
void DNRemoteHumanPlayer::transferTurn(int y, int x)
{
    stringstream tmp;
    tmp << y << ';' << x << endl;
    DNLogService::sharedObject() << "going to sent data " << "\n";
    DNNetworkConnection::getInstance().sendData(this->clientSocket, tmp.str());
    DNLogService::sharedObject() << "data sent" << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3270
leaq -0x188(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x35b0
movq %rax, -0x1d0(%rbp)
jmp 0x7e84
movq -0x1d0(%rbp), %rdi
movl $0x3b, %esi
callq 0x3470
movq %rax, -0x1e0(%rbp)
jmp 0x7e9e
movq -0x1e0(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x35b0
movq %rax, -0x1e8(%rbp)
jmp 0x7eb6
movq -0x1e8(%rbp), %rdi
movq 0x90f4(%rip), %rsi      # 0x10fb8
callq 0x33e0
jmp 0x7ecb
callq 0x43c0
movq %rax, -0x1f0(%rbp)
jmp 0x7ed9
movq -0x1f0(%rbp), %rdi
leaq 0x44e5(%rip), %rsi      # 0xc3cc
callq 0x5520
movq %rax, -0x1f8(%rbp)
jmp 0x7ef5
movq -0x1f8(%rbp), %rdi
leaq 0x4657(%rip), %rsi      # 0xc55a
callq 0x5520
jmp 0x7f0a
callq 0x8050
movq %rax, -0x200(%rbp)
jmp 0x7f18
movq -0x1d8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x204(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3350
jmp 0x7f3d
movl -0x204(%rbp), %esi
movq -0x200(%rbp), %rdi
leaq -0x1c8(%rbp), %rdx
callq 0x6d70
jmp 0x7f58
leaq -0x1c8(%rbp), %rdi
callq 0x3200
callq 0x43c0
movq %rax, -0x210(%rbp)
jmp 0x7f72
movq -0x210(%rbp), %rdi
leaq 0x4460(%rip), %rsi      # 0xc3e0
callq 0x5520
movq %rax, -0x218(%rbp)
jmp 0x7f8e
movq -0x218(%rbp), %rdi
leaq 0x45be(%rip), %rsi      # 0xc55a
callq 0x5520
jmp 0x7fa3
leaq -0x198(%rbp), %rdi
callq 0x3290
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x7fea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3200
leaq -0x198(%rbp), %rdi
callq 0x3290
movq -0x1a0(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::init()
void DNWindow::init()
{
    initscr();
    raw();
    keypad(stdscr, TRUE);
    noecho();
    drawMainMenu();
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x3530
callq 0x3120
movq 0x75cb(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3160
callq 0x3450
movq -0x10(%rbp), %rdi
callq 0x9a30
callq 0x35a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)