LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorl %eax, %eax
testl %edx, %edx
jle 0x27c6
movl %edx, %edi
movq %rsi, %r8
movl %r8d, %r9d
andl $0x3, %r9d
leaq (%r9,%rax,4), %rax
xorq $0x3, %rax
shrq $0x2, %r8
decl %edi
jne 0x27af
leal 0x6(%rdx), %edi
cmpl $0x7, %edi
jae 0x27d2
xorl %eax, %eax
jmp 0x2801
addl $0x3, %edx
cmovsl %edi, %edx
sarl $0x2, %edx
cmpq %rsi, %rax
cmovbq %rax, %rsi
cmpl $0x1, %edx
adcl $0x0, %edx
xorl %eax, %eax
leaq (%rax,%rax,8), %rdi
leaq (%rax,%rdi,2), %rdi
movzbl %sil, %eax
addq %rdi, %rax
shrq $0x8, %rsi
decl %edx
jne 0x27ea
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::printKmerCounting(parameter*, MPIEnviroment*)
void kmerGraph::printKmerCounting(parameter *parameters, MPIEnviroment *MPIcontrol)
{
        ofstream fs(parameters->kmerGraph);
        if(!fs.is_open())
        {
                cout<<"Error opening file"<<endl;
                exit(1);
        }

	int lineLen = parameters->hashLength+1+4*8+5;
	int totLen = kmolecules.size()*lineLen;
	
	char *buf = new char [totLen];
	int i=0;

	for(unordered_map<unsigned long long, unsigned long long>::iterator I=kmolecules.begin(); I!=kmolecules.end(); I++)
	{
		sprintf(buf+i*lineLen, "%s ", longLongToString(I->first, parameters).c_str());
		unsigned char *p = (unsigned char *) &I->second;
		int t=0;
		/*for(int j=0;j<8;j++)	
		{
			t += p[j];
			sprintf(buf+i*lineLen+parameters->hashLength+1+j*4, "%3d ", (int) p[j]);
		}*/
		sprintf(buf+i*lineLen+parameters->hashLength+1+4*8, "%4d\n", t);	
		i++;	
	}
	buf[totLen] = 0;
	MPIcontrol->File_write(parameters->kmerGraph, buf, totLen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8f7(%rsi), %r12
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x2290
leaq 0xb8(%rsp), %rdi
callq 0x2080
testb %al, %al
je 0x4067
movq %r12, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movslq 0xaf8(%r15), %r12
addq $0x26, %r12
movl 0x18(%rbx), %eax
imull %r12d, %eax
cltq
testl %eax, %eax
movq $-0x1, %rdi
movq %rax, 0x10(%rsp)
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
movq 0x10(%rbx), %rbp
testq %rbp, %rbp
je 0x4006
leaq 0x258f(%rip), %rbx      # 0x652b
leaq 0x258c(%rip), %r14      # 0x652f
movq 0x8(%rsp), %r13
movq 0x8(%rbp), %rsi
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x2694
movq 0x28(%rsp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2070
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3fdf
callq 0x2240
movslq 0xaf8(%r15), %rax
leaq (%rax,%r13), %rdi
addq $0x21, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
movq (%rbp), %rbp
addq %r12, %r13
testq %rbp, %rbp
jne 0x3fa8
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x0, (%rdx,%rcx)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x59ae
movq 0x4f76(%rip), %rax      # 0x8fa0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x48(%rsp,%rcx)
callq 0x21f0
leaq 0x140(%rsp), %rdi
callq 0x20a0
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4f4a(%rip), %rdi      # 0x8fb8
leaq 0x24a3(%rip), %rsi      # 0x6518
movl $0x12, %edx
callq 0x22c0
movq 0x4f32(%rip), %rdi      # 0x8fb8
callq 0x2110
movl $0x1, %edi
callq 0x2300
jmp 0x409b
jmp 0x409b
jmp 0x409b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x23e0
movq %rbx, %rdi
callq 0x2460
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpq $0x0, 0x8(%rdi)
je 0x449b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x14(%rdi), %rax
movq %rax, -0x8(%rsp)
testq %rax, %rax
jle 0x44a0
movq 0x18(%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x10(%rdi), %r9d
xorl %ebx, %ebx
testq %r9, %r9
setne %bl
movslq %r9d, %rax
movq %rax, -0x18(%rsp)
movq (%rdi), %r15
movl $0x40000000, %r8d       # imm = 0x40000000
xorl %r12d, %r12d
movq -0x10(%rsp), %rax
movq (%rax,%r12,8), %rcx
movq 0x8(%rdi), %r13
movl $0x8, %ebp
xorl %edx, %edx
movq %rsi, %r10
imulq %rcx, %rdx
movl %r10d, %eax
addq %rdx, %rax
xorl %edx, %edx
divq %r13
testq %r10, %r10
je 0x43ed
shrq $0x8, %r10
decl %ebp
jne 0x43d1
movq %rbx, %rax
testl %r9d, %r9d
jle 0x4484
imulq -0x18(%rsp), %rdx
movq %r9, %rax
xorl %ecx, %ecx
xorl %r13d, %r13d
leaq (%rdx,%rcx), %r14
movq %r14, %rbp
shrq $0x6, %rbp
movq (%r15,%rbp,8), %rbp
xorl %r11d, %r11d
btq %r14, %rbp
setb %r11b
leaq (%r11,%r13,2), %r13
incq %rcx
decq %rax
jne 0x4407
leaq 0x1(%r13), %rax
movq %rax, %r11
movl %r9d, %ecx
shrq %cl, %r11
testq %r11, %r11
cmovneq %r13, %rax
testl %r9d, %r9d
jle 0x4484
movq %rsi, %r10
movq %r9, %r13
xorl %ebp, %ebp
leaq (%rdx,%rbp), %rcx
movq %rcx, %rsi
shrq $0x6, %rsi
movq (%r15,%rsi,8), %r11
btrq %rcx, %r11
decq %r13
xorl %r14d, %r14d
btq %r13, %rax
setb %r14b
shlq %cl, %r14
orq %r11, %r14
movq %r14, (%r15,%rsi,8)
incq %rbp
testq %r13, %r13
jne 0x444e
movq %r10, %rsi
cmpq %r8, %rax
cmovbq %rax, %r8
incq %r12
cmpq -0x8(%rsp), %r12
jne 0x43ba
jmp 0x44a6
xorl %r8d, %r8d
jmp 0x44b0
movl $0x40000000, %r8d       # imm = 0x40000000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movl $0x1, %eax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
leaq 0x38(%rdi), %r14
leaq 0x68(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movl %ecx, 0x58(%rdi)
leaq 0xa0(%rdi), %r15
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movq 0x4ad6(%rip), %rsi      # 0x8ff0
movl $0xa, %edi
movq %r15, %rdx
callq 0x2160
movq %r15, %rdi
callq 0x2320
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x493c
movq %rbx, %rdi
callq 0x493c
movq %r15, %rdi
callq 0x2460
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
cltd
idivl 0x278(%rdi)
testl %edx, %edx
jne 0x5662
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2180
movq %rax, %r15
leaq 0x218(%rbx), %r8
movq 0x39ae(%rip), %rdi      # 0x8fd0
movq 0x399f(%rip), %rcx      # 0x8fc8
movq %r14, %rsi
movl $0x2, %edx
callq 0x2190
movl %eax, 0x210(%rbx)
movl (%rbx), %esi
testl %eax, %eax
jne 0x5668
leaq 0x158d(%rip), %rdi      # 0x6bd6
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
callq 0x2180
subq %r15, %rax
addq %rax, 0x248(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1545(%rip), %rdi      # 0x6bb4
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x38f8(%rip), %rax      # 0x8f78
movq (%rax), %rdi
callq 0x22e0
xorl %edi, %edi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rdi), %eax
cltd
idivl 0x278(%rdi)
testl %edx, %edx
je 0x5938
xorl %ebx, %ebx
jmp 0x599e
movq %rsi, %r15
movq %rdi, %r14
callq 0x2180
movq %rax, %r12
movq 0x218(%r14), %rdi
movq 0x238(%r14), %rax
cmpq %rbx, %rax
cmovlq %rax, %rbx
movq 0x240(%r14), %rsi
leaq 0x260(%r14), %r9
movq 0x3610(%rip), %r8       # 0x8f80
movq %r15, %rdx
movl %ebx, %ecx
callq 0x23f0
addq %rbx, 0x240(%r14)
subq %rbx, 0x238(%r14)
callq 0x2180
subq %r12, %rax
addq %rax, 0x248(%r14)
addq %rax, 0x258(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
callq 0x2180
movq %rax, %r14
movq 0x35b8(%rip), %rdi      # 0x8f90
movq 0x35e9(%rip), %rcx      # 0x8fc8
movq %rsp, %r8
movq %r12, %rsi
movl $0x5, %edx
callq 0x2190
movl %eax, 0x210(%rbx)
movl (%rbx), %esi
testl %eax, %eax
jne 0x5a8e
leaq 0x125a(%rip), %rdi      # 0x6c60
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x35d9(%rip), %rcx      # 0x8ff0
movq 0x3552(%rip), %r8       # 0x8f70
movq 0x356b(%rip), %r9       # 0x8f90
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x22a0
movq (%r13), %rsi
movq (%r12), %rcx
subq %rcx, %rsi
movq %rsi, (%r13)
movq %rsp, %r12
movq (%r12), %rdi
movq 0x3524(%rip), %r8       # 0x8f80
leaq 0x18(%rsp), %r9
movq %r15, %rdx
callq 0x2350
movq %r12, %rdi
callq 0x23c0
callq 0x2180
subq %r14, %rax
addq %rax, 0x248(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x111f(%rip), %rdi      # 0x6bb4
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x34d2(%rip), %rax      # 0x8f78
movq (%rax), %rdi
callq 0x22e0
xorl %edi, %edi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4e98
movl $0x3, 0x138a0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x138a4(%rbx)
movl $0x0, 0x138b4(%rbx)
cmpl $0x2, %ebp
jg 0x4129
cmpl $0x1, %ebp
je 0x413d
cmpl $0x2, %ebp
jne 0x414f
movq %rbx, %rdi
callq 0x432e
jmp 0x414f
cmpl $0x3, %ebp
je 0x4147
cmpl $0x1b, %ebp
jne 0x414f
movq %rbx, %rdi
callq 0x45d2
jmp 0x414f
movq %rbx, %rdi
callq 0x4168
jmp 0x414f
movq %rbx, %rdi
callq 0x44c0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4f26
movq %r14, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
callq 0x39ee
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x8434
movl $0x50, %edi
callq 0x32d0
movq %rax, %r14
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x3fb6
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x47c0
movq %r14, 0x138a8(%rbx)
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x4215
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32f0
movl $0x50, %edi
callq 0x32d0
movq %rax, %r14
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x3fb6
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x47c0
movq %r14, 0x138b0(%rbx)
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x4274
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x428a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x42a1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x42e7
movq 0x50(%rsp), %rsi
jmp 0x42da
jmp 0x42e4
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x42e7
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x42e7
movq %rax, %rbx
movl $0x50, %esi
movq %r14, %rdi
callq 0x32f0
jmp 0x42f9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x430f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4326
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
callq 0x39ee
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x874a
movl $0x50, %edi
callq 0x32d0
movq %rax, %r14
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x3fb6
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x47c0
movq %r14, 0x138a8(%rbx)
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x43c4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x32f0
movl $0x80, %edi
callq 0x32d0
movq %rax, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x509f(%rip), %rsi      # 0x9481
leaq 0x509b(%rip), %rdx      # 0x9484
leaq 0x28(%rsp), %rdi
callq 0x404c
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x6df8
movq %r14, 0x138b0(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x4426
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x443d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x4468
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x4468
movq %rax, %rbx
movl $0x80, %esi
jmp 0x4493
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x448e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x448e
movq %rax, %rbx
movl $0x50, %esi
movq %r14, %rdi
callq 0x32f0
jmp 0x44a0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x44b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
callq 0x39ee
movq %rsp, %rsi
movq %rax, %rdi
callq 0x88ee
movl %eax, %ebp
movl $0x58, %edi
callq 0x32d0
movq %rax, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x3fb6
xorl %r8d, %r8d
cmpl $0x1, %ebp
setne %r8b
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
movq %r14, %rcx
callq 0x626c
movq %rbx, 0x138a8(%r14)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x4560
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4576
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x45a2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x45a2
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x32f0
jmp 0x45b4
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x45ca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNLogService.cpp
// Function: DNLogService::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DNLogService::log(string  message)
{
//    time_t t = time(0);
    ofstream myfile;
    myfile.open ("log.txt", ios_base::app);
//    struct tm * now = localtime( & t );
//    myfile  << (now->tm_year + 1900) << '-'
//            << (now->tm_mon + 1) << '-'
//            << now->tm_mday << " -> "
//            << now->tm_hour << ':'
//            << now->tm_min
//            << endl;
    myfile << message ;
    
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3470
leaq 0x4506(%rip), %rsi      # 0x90a3
movq %r14, %rdi
movl $0x1, %edx
callq 0x3040
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x3360
movq 0x83fe(%rip), %rax      # 0xcfc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x3260
leaq 0x100(%rsp), %rdi
callq 0x3130
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3400
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %esi, %ebx
leaq 0x28(%rsp), %rdi
callq 0x3200
leaq 0x38(%rsp), %rdi
movl %ebx, %esi
callq 0x3490
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3440
leaq 0x8(%rsp), %rsi
callq 0x4b7c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d64
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x3f98
movq %rax, %rbx
movq 0x8235(%rip), %rsi      # 0xcfa8
leaq 0x28(%rsp), %rdi
callq 0x3220
leaq 0xa8(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4db9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x4db9
movq %rax, %rbx
movq 0x81e8(%rip), %rsi      # 0xcfa8
leaq 0x28(%rsp), %rdi
callq 0x3220
leaq 0xa8(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x64, (%rdi)
movabsq $0x6400000064, %rax     # imm = 0x6400000064
movq %rax, 0x8(%rdi)
movl $0x5, 0x10(%rdi)
addq $0x18, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movl $0x18, %edi
callq 0x32d0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3a0e
movq %r12, (%rbx,%r15,8)
incq %r15
cmpq $0x64, %r15
jne 0x4ec9
incq %r14
addq $0x320, %rbx            # imm = 0x320
cmpq $0x64, %r14
jne 0x4ec6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3200
cmpq $0x0, (%rbx)
je 0x505d
leaq 0x18(%rbx), %r12
leaq 0x40(%rsp), %r14
xorl %r13d, %r13d
leaq 0x40ee(%rip), %rbp      # 0x90ab
leaq 0x40e9(%rip), %r15      # 0x90ad
movq %r13, 0x8(%rsp)
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
callq 0x3a24
movq %rbp, %rsi
cmpl $0x2, %eax
je 0x4fee
movq (%r12,%r13,8), %rdi
callq 0x3a24
movq %r15, %rsi
cmpl $0x1, %eax
jne 0x4ffd
movl $0x1, %edx
movq %r14, %rdi
callq 0x3360
jmp 0x5014
movb $0x2e, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
leaq 0x7(%rsp), %rsi
callq 0x3360
incq %r13
cmpq (%rbx), %r13
jb 0x4fcc
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32c0
movq 0x8(%rsp), %r13
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31e0
incq %r13
addq $0x320, %r12            # imm = 0x320
cmpq (%rbx), %r13
jb 0x4fc4
leaq 0x40(%rsp), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31e0
callq 0x3f98
movq %rax, %rbx
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3440
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b7c
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50f2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x7eaf(%rip), %rsi      # 0xcfa8
leaq 0x30(%rsp), %rdi
callq 0x3220
leaq 0xb0(%rsp), %rdi
callq 0x3130
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5149
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x5149
jmp 0x5146
jmp 0x5146
movq %rax, %rbx
movq 0x7e58(%rip), %rsi      # 0xcfa8
leaq 0x30(%rsp), %rdi
callq 0x3220
leaq 0xb0(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movl %esi, %edi
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
xorl %ecx, %ecx
callq 0x31a0
movq %rax, %rbx
testq %rax, %rax
js 0x5fc1
callq 0x3f98
leaq 0x31e1(%rip), %rsi      # 0x9135
movq %rax, %rdi
callq 0x4ca4
leaq 0x3370(%rip), %rsi      # 0x92d3
movq %rax, %rdi
callq 0x4ca4
movq %rax, %r15
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x3fb6
movq %r15, %rdi
movq %r14, %rsi
callq 0x4de0
leaq 0x356d(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4ca4
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x6078
movq 0x58(%rsp), %rsi
jmp 0x6070
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x32ec(%rip), %rsi      # 0x92bd
leaq 0x32fa(%rip), %rdx      # 0x92d2
leaq 0x8(%rsp), %rdi
callq 0x404c
callq 0x3f98
leaq 0x30c1(%rip), %rsi      # 0x90af
movq %rax, %rdi
callq 0x4ca4
leaq 0x32c9(%rip), %rsi      # 0x92c6
movq %rax, %rdi
callq 0x4ca4
leaq 0x3502(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4ca4
callq 0x39ee
movq %rax, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3fb6
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x82b0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6061
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6078
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
testq %rbx, %rbx
setns %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x60c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x60c2
movq %rax, %rbx
jmp 0x60d9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x60d9
movq 0x58(%rsp), %rsi
jmp 0x60d1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x60d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x5b8, %rsp            # imm = 0x5B8
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x1b0(%rsp), %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x31c0
movl $0x400, %edx            # imm = 0x400
movl %ebp, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3200
leaq 0x38(%rsp), %r15
movq %r14, %rdi
callq 0x3170
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3360
callq 0x3f98
leaq 0x2fe8(%rip), %rsi      # 0x9135
movq %rax, %rdi
callq 0x4ca4
leaq 0x318b(%rip), %rsi      # 0x92e7
movq %rax, %rdi
callq 0x4ca4
movq %rax, %r15
leaq 0x40(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3440
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x4de0
leaq 0x3381(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4ca4
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3440
movq 0x6de6(%rip), %rsi      # 0xcfa8
leaq 0x28(%rsp), %rdi
callq 0x3220
leaq 0xa8(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x5b8, %rsp            # imm = 0x5B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x620d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x620d
movq %rax, %rbx
movq 0x6d94(%rip), %rsi      # 0xcfa8
leaq 0x28(%rsp), %rdi
callq 0x3220
leaq 0xa8(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
leaq 0x6a82(%rip), %rax      # 0xcd20
movq %rax, (%rbx)
callq 0x31b0
movl %r15d, 0x28(%rbx)
movq %r14, 0x48(%rbx)
movb %bpl, 0x50(%rbx)
testb %bpl, %bpl
je 0x62c6
callq 0x6dda
movq %rax, %rdi
callq 0x5438
jmp 0x62d3
callq 0x6dda
movq %rax, %rdi
callq 0x5a8e
movl %eax, 0x54(%rbx)
movzbl %bpl, %esi
movq 0x6cf7(%rip), %rdi      # 0xcfd8
callq 0x3460
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4836
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x6dda
movq %rax, %r14
movl 0x54(%rbx), %ebp
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2815(%rip), %rsi      # 0x93b4
leaq 0x2812(%rip), %rdx      # 0x93b8
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x404c
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x5f22
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6bd7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x6dda
movl 0x54(%rbx), %esi
movq %rax, %rdi
callq 0x6234
callq 0x39ee
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x27b9(%rip), %rsi      # 0x93b9
leaq 0x27d1(%rip), %rdx      # 0x93d8
movq %rsp, %r14
movq %r14, %rdi
callq 0x404c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82b0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6c33
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x6c51
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c62
movq (%r12), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3200
leaq 0x38(%rsp), %rdi
movl %r14d, %esi
callq 0x3490
leaq 0x7(%rsp), %rsi
movb $0x3b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3360
movq %rax, %rdi
movl %ebp, %esi
callq 0x3490
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31e0
callq 0x3f98
leaq 0x26ad(%rip), %rsi      # 0x9396
movq %rax, %rdi
callq 0x4ca4
leaq 0x2816(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4ca4
callq 0x6dda
movq %rax, %r14
movl 0x54(%rbx), %ebx
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3440
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x5f22
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x3f98
leaq 0x265a(%rip), %rsi      # 0x93aa
movq %rax, %rdi
callq 0x4ca4
leaq 0x27af(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4ca4
movq 0x623a(%rip), %rsi      # 0xcfa8
leaq 0x28(%rsp), %rdi
callq 0x3220
leaq 0xa8(%rsp), %rdi
callq 0x3130
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6db4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x6db4
movq %rax, %rbx
movq 0x61ed(%rip), %rsi      # 0xcfa8
leaq 0x28(%rsp), %rdi
callq 0x3220
leaq 0xa8(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::init()
void DNWindow::init()
{
    initscr();
    raw();
    keypad(stdscr, TRUE);
    noecho();
    drawMainMenu();
    refresh();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3410
callq 0x3110
movq 0x5a0b(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3150
callq 0x3370
movq %rbx, %rdi
callq 0x75e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawMainMenu()
void DNWindow::drawMainMenu()
{
    drawHeader();
    drawMenu();
    drawOptions();
    drawCommandLine();
    string input = "";
    drawCommandLine();
    inputString(input);
    executeMenuOption(input);


}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x7692
callq 0x7b96
callq 0x78f8
callq 0x7c66
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1eff(%rip), %rdx      # 0x950f
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x404c
callq 0x7c66
movq %rsp, %rsi
callq 0x7da6
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x3fb6
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7eba
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x7673
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x7673
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x7689
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawHeader()
void DNWindow::drawHeader()
{
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    for (int i = 0; i < w.ws_col; i++) {
        if (i == 0) {
            addch(ACS_ULCORNER);
            continue;
        }
        if (i == w.ws_col - 1) {
            addch(ACS_URCORNER);
            continue;
        }
        addch(ACS_HLINE);
    }
    addch(ACS_VLINE);
    printw("TicTacToe\n");
    move(1, w.ws_col - 1);
    addch(ACS_VLINE);
    for (int i = 0; i < w.ws_col; i++) {
        if (i == 0) {
            addch(ACS_LLCORNER);
            continue;
        }
        if (i == w.ws_col - 1) {
            addch(ACS_LRCORNER);
            continue;
        }
        addch(ACS_HLINE);
    }
    refreshDN();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
movq %rsp, %rbx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl 0x2(%rbx), %eax
testl %eax, %eax
je 0x76fa
movl $0x1b0, %ebx            # imm = 0x1B0
movq 0x590a(%rip), %r14      # 0xcfd0
movq 0x58d3(%rip), %r15      # 0xcfa0
decl %eax
movl $0x1ac, %ecx            # imm = 0x1AC
cmpl %eax, %ebp
je 0x76dd
movl $0x1c4, %ecx            # imm = 0x1C4
testl %ebp, %ebp
cmoveq %rbx, %rcx
movq (%r14), %rdi
movl (%r15,%rcx), %esi
callq 0x30e0
incl %ebp
movzwl 0x2(%rsp), %eax
cmpl %eax, %ebp
jb 0x76cd
movq 0x58cf(%rip), %rbx      # 0xcfd0
movq (%rbx), %rdi
movq 0x5895(%rip), %r14      # 0xcfa0
movl 0x1e0(%r14), %esi
callq 0x30e0
leaq 0x1d36(%rip), %rdi      # 0x9454
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x32e0
movzwl 0x2(%rsp), %esi
decl %esi
movl $0x1, %edi
callq 0x31f0
movq (%rbx), %rdi
movl 0x1e0(%r14), %esi
callq 0x30e0
movzwl 0x2(%rsp), %eax
testl %eax, %eax
je 0x7783
movl $0x1b4, %r15d           # imm = 0x1B4
decl %eax
movl $0x1a8, %ecx            # imm = 0x1A8
cmpl %eax, %ebp
je 0x7766
movl $0x1c4, %ecx            # imm = 0x1C4
testl %ebp, %ebp
cmoveq %r15, %rcx
movq (%rbx), %rdi
movl (%r14,%rcx), %esi
callq 0x30e0
incl %ebp
movzwl 0x2(%rsp), %eax
cmpl %eax, %ebp
jb 0x7756
callq 0x3480
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawHeaderWithGuide(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DNWindow::drawHeaderWithGuide(string guide)
{
    
    int x_pos, y_pos;
    
    getsyx(y_pos, x_pos);
    
    move(0,0);
    
    
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    for (int i = 0; i < w.ws_col; i++) {
        if (i == 0) {
            addch(ACS_ULCORNER);
            continue;
        }
        if (i == w.ws_col - 1) {
            addch(ACS_URCORNER);
            continue;
        }
        addch(ACS_HLINE);
    }
    addch(ACS_VLINE);
    printw(guide.c_str());
    move(1, w.ws_col - 1);
    addch(ACS_VLINE);
    for (int i = 0; i < w.ws_col; i++) {
        if (i == 0) {
            addch(ACS_LLCORNER);
            continue;
        }
        if (i == w.ws_col - 1) {
            addch(ACS_LRCORNER);
            continue;
        }
        addch(ACS_HLINE);
    }
    move(y_pos,x_pos);
    refreshDN();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x5816(%rip), %rax      # 0xcfc8
movq (%rax), %rax
testq %rax, %rax
je 0x77da
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpb $0x0, 0x1a(%rax)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
jne 0x77da
movswl (%rax), %ecx
movl %ecx, 0xc(%rsp)
movswl 0x2(%rax), %ebp
jmp 0x77da
xorl %r12d, %r12d
xorl %edi, %edi
xorl %esi, %esi
callq 0x31f0
leaq 0x10(%rsp), %r15
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl 0x2(%r15), %eax
testl %eax, %eax
je 0x784d
movl $0x1b0, %r15d           # imm = 0x1B0
movq 0x57bb(%rip), %r13      # 0xcfd0
movq 0x5784(%rip), %rbx      # 0xcfa0
decl %eax
movl $0x1ac, %ecx            # imm = 0x1AC
cmpl %eax, %r12d
je 0x782d
movl $0x1c4, %ecx            # imm = 0x1C4
testl %r12d, %r12d
cmoveq %r15, %rcx
movq (%r13), %rdi
movl (%rbx,%rcx), %esi
callq 0x30e0
incl %r12d
movzwl 0x12(%rsp), %eax
cmpl %eax, %r12d
jb 0x781c
movq 0x577c(%rip), %r15      # 0xcfd0
movq (%r15), %rdi
movq 0x5742(%rip), %r12      # 0xcfa0
movl 0x1e0(%r12), %esi
callq 0x30e0
movq (%r14), %rdi
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x32e0
movzwl 0x12(%rsp), %esi
decl %esi
movl $0x1, %edi
callq 0x31f0
movq (%r15), %rdi
movl 0x1e0(%r12), %esi
callq 0x30e0
movzwl 0x12(%rsp), %eax
testl %eax, %eax
je 0x78d8
movl $0x1b4, %ebx            # imm = 0x1B4
decl %eax
movl $0x1a8, %ecx            # imm = 0x1A8
cmpl %eax, %r14d
je 0x78b8
movl $0x1c4, %ecx            # imm = 0x1C4
testl %r14d, %r14d
cmoveq %rbx, %rcx
movq (%r15), %rdi
movl (%r12,%rcx), %esi
callq 0x30e0
incl %r14d
movzwl 0x12(%rsp), %eax
cmpl %eax, %r14d
jb 0x78a7
movl 0xc(%rsp), %edi
movl %ebp, %esi
callq 0x31f0
callq 0x3480
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawMenu()
void DNWindow::drawMenu()
{
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    move(w.ws_row + 3, w.ws_col);
    middleString(string("Please select one of these following options:"), 3);


}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x20(%rsp), %rbx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl (%rbx), %edi
addl $0x3, %edi
movzwl 0x2(%rbx), %esi
callq 0x31f0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18e8(%rip), %rsi      # 0x94bf
leaq 0x190e(%rip), %rdx      # 0x94ec
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x404c
leaq 0x28(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl 0x2(%r14), %esi
subq 0x8(%rbx), %rsi
shrq %rsi
movq (%rbx), %rcx
leaq 0x18a4(%rip), %rdx      # 0x94bc
movl $0x3, %edi
xorl %eax, %eax
callq 0x33d0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7c3a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7c5d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveUp()
void DNWindow::moveUp()
{
    int y, x;
    getsyx(y, x);
    move(y - 1, x);
    refresh();
}

// Assembly:
movq 0x52db(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7d02
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
jmp 0x7d0b
movswl (%rax), %edi
decl %edi
movswl 0x2(%rax), %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveDown()
void DNWindow::moveDown()
{
    int y, x;
    getsyx(y, x);
    move(y + 1, x);
    refresh();
}

// Assembly:
movq 0x52a9(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7d31
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edi, %edi
jmp 0x7d3a
movswl (%rax), %edi
incl %edi
movswl 0x2(%rax), %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveLeft()
void DNWindow::moveLeft()
{
    int y, x;
    getsyx(y, x);
    move(y, x - 1);
    refresh();
}

// Assembly:
movq 0x527b(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7d62
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0x7d6b
movswl (%rax), %edi
movswl 0x2(%rax), %esi
decl %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveRight()
void DNWindow::moveRight()
{
    int y, x;
    getsyx(y, x);
    move(y, x + 1);
    refresh();

}

// Assembly:
movq 0x5249(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7d91
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0x7d9a
movswl (%rax), %edi
movswl 0x2(%rax), %esi
incl %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::inputString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void DNWindow::inputString(string& input)
{
    
    refreshDN();

    char ch;
    int key;
    allowMacDev();

    while ((key = getch())) {
        ch = key;
        DNLogService::sharedObject().log(ch);

        if (key == KEY_BACKSPACE && input.size() > 0) {
            input = input.substr(0, input.size() - 1);
            moveLeft();
            addch(' ');
            refreshDN();
            moveLeft();
            refreshDN();
            continue;
        }
        else if (key == KEY_BACKSPACE) {
            sound();
            continue;
        }
        if (key == '\n') {
            break;
        }
        input += ch;
        addch(ch);
        moveRight();
        refreshDN();

    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
callq 0x3480
movq 0x520d(%rip), %r12      # 0xcfd0
movq (%r12), %rdi
movl $0x1, %esi
callq 0x3150
movq (%r12), %rdi
callq 0x3140
testl %eax, %eax
je 0x7eab
movl %eax, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
callq 0x3f98
movsbl %bpl, %r15d
movq %rax, %rdi
movl %r15d, %esi
callq 0x4c0e
cmpl $0x107, %ebp            # imm = 0x107
je 0x7e32
cmpl $0xa, %ebp
je 0x7eab
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3270
movq (%r12), %rdi
movsbl %bpl, %esi
callq 0x30e0
callq 0x7d78
jmp 0x7e8a
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x7ea4
decq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3310
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33b0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7e6d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x7d46
movq (%r12), %rdi
movl $0x20, %esi
callq 0x30e0
callq 0x3480
callq 0x7d46
callq 0x3480
movq (%r12), %rdi
callq 0x3140
movl %eax, %ebp
testl %eax, %eax
jne 0x7dee
jmp 0x7eab
callq 0x3080
jmp 0x7e8f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq