LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b4e(%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 0x48b2
movq %rbx, %rdi
callq 0x48b2
movq %r15, %rdi
callq 0x2460
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
leaq 0x10(%rsp), %rsi
movq %rdx, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x248(%rbx)
movq $0x0, 0x258(%rbx)
movl $0x1, 0x278(%rbx)
callq 0x2390
movq 0x3b7c(%rip), %r14      # 0x8f90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2380
leaq 0x4(%rbx), %rsi
movq %r14, %rdi
callq 0x22d0
leaq 0x8(%rbx), %rdi
addq $0x20c, %rbx            # imm = 0x20C
movq %rbx, %rsi
callq 0x22b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55ae
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2180
movq %rax, %r15
leaq 0x218(%rbx), %r8
movq 0x3a62(%rip), %rdi      # 0x8fd0
movq 0x3a53(%rip), %rcx      # 0x8fc8
movq %r14, %rsi
movl $0x2, %edx
callq 0x2190
movl %eax, 0x210(%rbx)
movl (%rbx), %esi
testl %eax, %eax
jne 0x55b4
leaq 0x1641(%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 0x15f9(%rip), %rdi      # 0x6bb4
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x39ac(%rip), %rax      # 0x8f78
movq (%rax), %rdi
callq 0x22e0
xorl %edi, %edi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58b2
xorl %ebx, %ebx
jmp 0x5918
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 0x3696(%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_O1/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 0x363e(%rip), %rdi      # 0x8f90
movq 0x366f(%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 0x5a08
leaq 0x12e0(%rip), %rdi      # 0x6c60
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x365f(%rip), %rcx      # 0x8ff0
movq 0x35d8(%rip), %r8       # 0x8f70
movq 0x35f1(%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 0x35aa(%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 0x11a5(%rip), %rdi      # 0x6bb4
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x3558(%rip), %rax      # 0x8f78
movq (%rax), %rdi
callq 0x22e0
xorl %edi, %edi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ea4
movl $0x3, 0x138a0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x138a4(%rbx)
movl $0x0, 0x138b4(%rbx)
cmpl $0x2, %ebp
jg 0x411d
cmpl $0x1, %ebp
je 0x4131
cmpl $0x2, %ebp
jne 0x4143
movq %rbx, %rdi
callq 0x4322
jmp 0x4143
cmpl $0x3, %ebp
je 0x413b
cmpl $0x1b, %ebp
jne 0x4143
movq %rbx, %rdi
callq 0x45c6
jmp 0x4143
movq %rbx, %rdi
callq 0x415c
jmp 0x4143
movq %rbx, %rdi
callq 0x44b4
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4f32
movq %r14, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8444
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 0x3fb8
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x47b4
movq %r14, 0x138a8(%rbx)
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x4209
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 0x3fb8
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x47b4
movq %r14, 0x138b0(%rbx)
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x4268
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x427e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4295
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 0x42db
movq 0x50(%rsp), %rsi
jmp 0x42ce
jmp 0x42d8
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x42db
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x42db
movq %rax, %rbx
movl $0x50, %esi
movq %r14, %rdi
callq 0x32f0
jmp 0x42ed
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4303
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x431a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x875a
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 0x3fb8
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x47b4
movq %r14, 0x138a8(%rbx)
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x43b8
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 0x50ab(%rip), %rsi      # 0x9481
leaq 0x50a7(%rip), %rdx      # 0x9484
leaq 0x28(%rsp), %rdi
callq 0x4048
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x6e2c
movq %r14, 0x138b0(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x441a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4431
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 0x445c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x445c
movq %rax, %rbx
movl $0x80, %esi
jmp 0x4487
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x4482
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x4482
movq %rax, %rbx
movl $0x50, %esi
movq %r14, %rdi
callq 0x32f0
jmp 0x4494
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x44ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x88fe
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 0x3fb8
xorl %r8d, %r8d
cmpl $0x1, %ebp
setne %r8b
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
movq %r14, %rcx
callq 0x625c
movq %rbx, 0x138a8(%r14)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x4554
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x456a
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 0x4596
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x4596
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x32f0
jmp 0x45a8
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x45be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44fa(%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 0x83f2(%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_O1/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 0x4b88
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d70
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x3f9a
movq %rax, %rbx
movq 0x8229(%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 0x4dc5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x4dc5
movq %rax, %rbx
movq 0x81dc(%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_O1/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 0x4ed5
incq %r14
addq $0x320, %rbx            # imm = 0x320
cmpq $0x64, %r14
jne 0x4ed2
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_O1/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 0x5062
leaq 0x18(%rbx), %r12
leaq 0x40(%rsp), %r14
xorl %r13d, %r13d
leaq 0x40e2(%rip), %rbp      # 0x90ab
cmpq $0x0, (%rbx)
je 0x5026
xorl %r15d, %r15d
movq (%r12,%r15,8), %rdi
callq 0x3a24
movq %rbp, %rsi
cmpl $0x2, %eax
je 0x4ff8
movq (%r12,%r15,8), %rdi
callq 0x3a24
leaq 0x40ba(%rip), %rsi      # 0x90ad
cmpl $0x1, %eax
jne 0x5007
movl $0x1, %edx
movq %r14, %rdi
callq 0x3360
jmp 0x501e
movb $0x2e, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
leaq 0xf(%rsp), %rsi
callq 0x3360
incq %r15
cmpq (%rbx), %r15
jb 0x4fd2
movq 0x40(%rsp), %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
incq %r13
addq $0x320, %r12            # imm = 0x320
cmpq (%rbx), %r13
jb 0x4fc9
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 0x3f9a
movq %rax, %rbx
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3440
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b88
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50f7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x7eaa(%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 0x514e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x514e
jmp 0x514b
jmp 0x514b
movq %rax, %rbx
movq 0x7e53(%rip), %rsi      # 0xcfa8
leaq 0x30(%rsp), %rdi
callq 0x3220
leaq 0xb0(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %ecx, %rax
imulq $0x320, %rax, %r12      # imm = 0x320
addq %rdi, %r12
movslq %edx, %r13
movq 0x18(%r12,%r13,8), %rdi
callq 0x3a24
movl %eax, %r15d
testl %eax, %eax
jne 0x5418
leaq (%r12,%r13,8), %rax
addq $0x18, %rax
movq (%rax), %rdi
movl %ebp, %esi
callq 0x3a20
movq %r14, %rdi
movl %ebp, %esi
callq 0x5174
movl %eax, (%rbx)
testl %r15d, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5fb1
callq 0x3f9a
leaq 0x31f1(%rip), %rsi      # 0x9135
movq %rax, %rdi
callq 0x4cb0
leaq 0x3380(%rip), %rsi      # 0x92d3
movq %rax, %rdi
callq 0x4cb0
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 0x3fb8
movq %r15, %rdi
movq %r14, %rsi
callq 0x4dec
leaq 0x357d(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4cb0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x6068
movq 0x58(%rsp), %rsi
jmp 0x6060
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x32fc(%rip), %rsi      # 0x92bd
leaq 0x330a(%rip), %rdx      # 0x92d2
leaq 0x8(%rsp), %rdi
callq 0x4048
callq 0x3f9a
leaq 0x30d1(%rip), %rsi      # 0x90af
movq %rax, %rdi
callq 0x4cb0
leaq 0x32d9(%rip), %rsi      # 0x92c6
movq %rax, %rdi
callq 0x4cb0
leaq 0x3512(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4cb0
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 0x3fb8
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x82c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6051
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6068
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 0x60b2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x60b2
movq %rax, %rbx
jmp 0x60c9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x60c9
movq 0x58(%rsp), %rsi
jmp 0x60c1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x60c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f9a
leaq 0x2ff8(%rip), %rsi      # 0x9135
movq %rax, %rdi
callq 0x4cb0
leaq 0x319b(%rip), %rsi      # 0x92e7
movq %rax, %rdi
callq 0x4cb0
movq %rax, %r15
leaq 0x40(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3440
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x4dec
leaq 0x3391(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4cb0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3440
movq 0x6df6(%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 0x61fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x61fd
movq %rax, %rbx
movq 0x6da4(%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_O1/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 0x6a92(%rip), %rax      # 0xcd20
movq %rax, (%rbx)
callq 0x31b0
movl %r15d, 0x28(%rbx)
movq %r14, 0x48(%rbx)
movb %bpl, 0x50(%rbx)
testb %bpl, %bpl
je 0x62b6
callq 0x6e0c
movq %rax, %rdi
callq 0x5430
jmp 0x62c3
callq 0x6e0c
movq %rax, %rdi
callq 0x5a84
movl %eax, 0x54(%rbx)
movzbl %bpl, %esi
movq 0x6d07(%rip), %rdi      # 0xcfd8
callq 0x3460
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x482a
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e0c
movq %rax, %r14
movl 0x54(%rbx), %ebp
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x27e3(%rip), %rsi      # 0x93b4
leaq 0x27e0(%rip), %rdx      # 0x93b8
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4048
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x5f12
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c09
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x6e0c
movl 0x54(%rbx), %esi
movq %rax, %rdi
callq 0x6224
callq 0x39ee
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2787(%rip), %rsi      # 0x93b9
leaq 0x279f(%rip), %rdx      # 0x93d8
movq %rsp, %r14
movq %r14, %rdi
callq 0x4048
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6c65
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 0x6c83
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c94
movq (%r12), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f9a
leaq 0x267b(%rip), %rsi      # 0x9396
movq %rax, %rdi
callq 0x4cb0
leaq 0x27e4(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4cb0
callq 0x6e0c
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 0x5f12
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d76
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x3f9a
leaq 0x2628(%rip), %rsi      # 0x93aa
movq %rax, %rdi
callq 0x4cb0
leaq 0x277d(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4cb0
movq 0x6208(%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 0x6de6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x6de6
movq %rax, %rbx
movq 0x61bb(%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_O1/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 0x59fb(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3150
callq 0x3370
movq %rbx, %rdi
callq 0x75f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76a2
callq 0x7ba6
callq 0x7908
callq 0x7c76
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1eef(%rip), %rdx      # 0x950f
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x4048
callq 0x7c76
movq %rsp, %rsi
callq 0x7db6
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x3fb8
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7eca
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x7683
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x7683
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x7699
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x770a
movl $0x1b0, %ebx            # imm = 0x1B0
movq 0x58fa(%rip), %r14      # 0xcfd0
movq 0x58c3(%rip), %r15      # 0xcfa0
decl %eax
movl $0x1ac, %ecx            # imm = 0x1AC
cmpl %eax, %ebp
je 0x76ed
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 0x76dd
movq 0x58bf(%rip), %rbx      # 0xcfd0
movq (%rbx), %rdi
movq 0x5885(%rip), %r14      # 0xcfa0
movl 0x1e0(%r14), %esi
callq 0x30e0
leaq 0x1d26(%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 0x7793
movl $0x1b4, %r15d           # imm = 0x1B4
decl %eax
movl $0x1a8, %ecx            # imm = 0x1A8
cmpl %eax, %ebp
je 0x7776
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 0x7766
callq 0x3480
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5806(%rip), %rax      # 0xcfc8
movq (%rax), %rax
testq %rax, %rax
je 0x77ea
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpb $0x0, 0x1a(%rax)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
jne 0x77ea
movswl (%rax), %ecx
movl %ecx, 0xc(%rsp)
movswl 0x2(%rax), %ebp
jmp 0x77ea
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 0x785d
movl $0x1b0, %r15d           # imm = 0x1B0
movq 0x57ab(%rip), %r13      # 0xcfd0
movq 0x5774(%rip), %rbx      # 0xcfa0
decl %eax
movl $0x1ac, %ecx            # imm = 0x1AC
cmpl %eax, %r12d
je 0x783d
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 0x782c
movq 0x576c(%rip), %r15      # 0xcfd0
movq (%r15), %rdi
movq 0x5732(%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 0x78e8
movl $0x1b4, %ebx            # imm = 0x1B4
decl %eax
movl $0x1a8, %ecx            # imm = 0x1A8
cmpl %eax, %r14d
je 0x78c8
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 0x78b7
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_O1/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 0x18d8(%rip), %rsi      # 0x94bf
leaq 0x18fe(%rip), %rdx      # 0x94ec
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4048
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 0x1894(%rip), %rdx      # 0x94bc
movl $0x3, %edi
xorl %eax, %eax
callq 0x33d0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7c4a
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 0x7c6d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawCommandLine()
void DNWindow::drawCommandLine()
{
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    start_color();
    init_pair(1, COLOR_RED, COLOR_BLACK);
    attron(COLOR_PAIR(1));
    mvprintw(w.ws_row - 1, 0, "COMMAND> ");
    move(w.ws_col - 1, 10);
    attron(COLOR_PAIR(0));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x33e0
callq 0x3090
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3060
movq 0x5322(%rip), %r14      # 0xcfd0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x3190
movzwl (%rbx), %edi
decl %edi
leaq 0x1824(%rip), %rdx      # 0x94ed
xorl %esi, %esi
xorl %eax, %eax
callq 0x33d0
movzwl 0x2(%rbx), %edi
decl %edi
movl $0xa, %esi
callq 0x31f0
movq (%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52cb(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7d12
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
jmp 0x7d1b
movswl (%rax), %edi
decl %edi
movswl 0x2(%rax), %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5299(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7d41
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edi, %edi
jmp 0x7d4a
movswl (%rax), %edi
incl %edi
movswl 0x2(%rax), %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/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 0x526b(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7d72
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0x7d7b
movswl (%rax), %edi
movswl 0x2(%rax), %esi
decl %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5239(%rip), %rax      # 0xcfc8
movq (%rax), %rax
cmpb $0x0, 0x1a(%rax)
je 0x7da1
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0x7daa
movswl (%rax), %edi
movswl 0x2(%rax), %esi
incl %esi
pushq %rax
callq 0x31f0
popq %rax
jmp 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/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 0x51fd(%rip), %r12      # 0xcfd0
movq (%r12), %rdi
movl $0x1, %esi
callq 0x3150
movq (%r12), %rdi
callq 0x3140
testl %eax, %eax
je 0x7ebb
movl %eax, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
callq 0x3f9a
movsbl %bpl, %r15d
movq %rax, %rdi
movl %r15d, %esi
callq 0x4c1a
cmpl $0x107, %ebp            # imm = 0x107
je 0x7e42
cmpl $0xa, %ebp
je 0x7ebb
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3270
movq (%r12), %rdi
movsbl %bpl, %esi
callq 0x30e0
callq 0x7d88
jmp 0x7e9a
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x7eb4
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 0x7e7d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x7d56
movq (%r12), %rdi
movl $0x20, %esi
callq 0x30e0
callq 0x3480
callq 0x7d56
callq 0x3480
movq (%r12), %rdi
callq 0x3140
movl %eax, %ebp
testl %eax, %eax
jne 0x7dfe
jmp 0x7ebb
callq 0x3080
jmp 0x7e9f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawBoard(int, int, int)
void DNWindow::drawBoard(int start_Y, int start_X, int size)
{
    this->clearScreen();
    this->drawHeaderWithGuide(string("TicTacToe - press 'x' to trigger turn"));
    this->drawHeader();
    this->refreshDN();
    
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    

    move(start_Y, start_X);

    for (int y = 0; y < size; y++) {
        for (int x = 0; x < size * 2; x++) {
            mvaddch(start_Y + y, start_X + x, ACS_CKBOARD);
        }
    }

    this->refreshDN();
    this->moveToCenter();
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, 0x18(%rsp)
callq 0x34a0
callq 0x3480
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1390(%rip), %rsi      # 0x9532
leaq 0x13ae(%rip), %rdx      # 0x9557
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4048
movq %r15, %rsi
callq 0x77aa
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x81d5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x76a2
callq 0x3480
xorl %r13d, %r13d
leaq 0x40(%rsp), %rdx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
xorl %eax, %eax
callq 0x33e0
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x31f0
cmpl $0x0, 0x8(%rsp)
jle 0x826a
movq 0x8(%rsp), %rax
addl %eax, %eax
movl %eax, 0x14(%rsp)
movq 0x4db1(%rip), %r14      # 0xcfd0
movq 0x4d7a(%rip), %rbx      # 0xcfa0
movq 0x18(%rsp), %rax
leal (%rax,%r13), %r15d
movl 0x4(%rsp), %r12d
movl 0x14(%rsp), %ebp
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x3320
cmpl $-0x1, %eax
je 0x8259
movq (%r14), %rdi
movl 0x184(%rbx), %esi
callq 0x30e0
incl %r12d
decl %ebp
jne 0x8238
incl %r13d
cmpl 0x8(%rsp), %r13d
jne 0x8226
callq 0x3480
callq 0x840a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x829d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::terminateWithErrorMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DNWindow::terminateWithErrorMessage(string  message)
{
    DNLogService::sharedObject() << "ERROR => " << message << "\n";
    DNWindow::getInstance().clearScreen();
    DNWindow::getInstance().middleString(message, 13);
    DNWindow:: getInstance().refreshDN();
    sleep(3);
    DNWindow::getInstance().terminate();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
callq 0x3f9a
leaq 0xdd5(%rip), %rsi       # 0x90af
movq %rax, %rdi
callq 0x4cb0
movq %rax, %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3fb8
movq %r14, %rdi
movq %r15, %rsi
callq 0x4dec
leaq 0x11f6(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4cb0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x8337
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x39ee
callq 0x34a0
callq 0x3480
callq 0x39ee
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3fb8
leaq 0x40(%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 0x1123(%rip), %rdx      # 0x94bc
movl $0xd, %edi
xorl %eax, %eax
callq 0x33d0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x83bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x39ee
callq 0x3480
movl $0x3, %edi
callq 0x3230
callq 0x39ee
callq 0x3390
xorl %edi, %edi
callq 0x33a0
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x83f1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x8402
movq (%r12), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0