LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__idleMove2Busy(Thread::threadWork*)
void threadPool::__idleMove2Busy(threadWork* idleThread)
	{
		_busyMutex.lock(__FUNCTION__,__LINE__);
		_workBusyVec.push_back(idleThread);
		_busyNum++;
		_busyMutex.unlock(__FUNCTION__,__LINE__);


		_idleMutex.lock(__FUNCTION__,__LINE__);
		std::vector<threadWork *>::iterator pos;
		pos = find(_workIdleVec.begin(), _workIdleVec.end(), idleThread);
		if(pos != _workIdleVec.end())
		{
			_workIdleVec.erase(pos);
			_idleNum--;
		}
		_idleMutex.unlock(__FUNCTION__,__LINE__);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x18, %rdi
leaq 0x1f99(%rip), %rsi      # 0x513c
movl $0xa0, %edx
callq 0x2590
movq -0x50(%rbp), %rdi
addq $0xf0, %rdi
leaq -0x10(%rbp), %rsi
callq 0x3a20
movq -0x50(%rbp), %rdi
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
addq $0x18, %rdi
leaq 0x1f63(%rip), %rsi      # 0x513c
movl $0xa3, %edx
callq 0x25c0
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1f4a(%rip), %rsi      # 0x513c
movl $0xa6, %edx
callq 0x2590
leaq -0x18(%rbp), %rdi
callq 0x3860
movq -0x50(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x38d0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x108, %rdi            # imm = 0x108
callq 0x3900
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x3880
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x108, %rdi            # imm = 0x108
callq 0x3900
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3930
testb $0x1, %al
jne 0x3271
jmp 0x32ad
movq -0x50(%rbp), %rax
addq $0x108, %rax            # imm = 0x108
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x39e0
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3970
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1e80(%rip), %rsi      # 0x513c
movl $0xae, %edx
callq 0x25c0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__createIdleThread(int)
void threadPool::__createIdleThread(int num)
	{
		for(int i=0; i< num; i++)
		{
		   threadWork* work = new threadWork(this);
		   __appendIdleThread(work);
		   work->Start();
		}
		_num = _num + num;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x335a
movl $0xb8, %edi
callq 0x2130
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x4b80
jmp 0x3315
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2de0
movq -0x18(%rbp), %rdi
callq 0x2790
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x32ee
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xb8, %esi
callq 0x2140
jmp 0x336d
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__busyMove2Idle(Thread::threadWork*)
void threadPool::__busyMove2Idle(threadWork* busyThread)
	{

		_idleMutex.lock(__FUNCTION__,__LINE__);
		_workIdleVec.push_back(busyThread);
		_idleNum++;
		_idleMutex.unlock(__FUNCTION__,__LINE__);


		_busyMutex.lock(__FUNCTION__,__LINE__);
		std::vector<threadWork *>::iterator pos;
		pos = find(_workBusyVec.begin(), _workBusyVec.end(), busyThread);
		if(pos != _workBusyVec.end())
		{
			_workBusyVec.erase(pos);
			_busyNum--;
		}
		_busyMutex.unlock(__FUNCTION__,__LINE__);

        _idleCond.notify();
        _busyCond.notify();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x40, %rdi
leaq 0x1b39(%rip), %rsi      # 0x512c
movl $0x8a, %edx
callq 0x2590
movq -0x50(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
leaq -0x10(%rbp), %rsi
callq 0x3a20
movq -0x50(%rbp), %rdi
movl 0x10(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x10(%rdi)
addq $0x40, %rdi
leaq 0x1b03(%rip), %rsi      # 0x512c
movl $0x8d, %edx
callq 0x25c0
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1aea(%rip), %rsi      # 0x512c
movl $0x90, %edx
callq 0x2590
leaq -0x18(%rbp), %rdi
callq 0x3860
movq -0x50(%rbp), %rdi
addq $0xf0, %rdi
callq 0x38d0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0xf0, %rdi
callq 0x3900
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x3880
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0xf0, %rdi
callq 0x3900
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3930
testb $0x1, %al
jne 0x36c1
jmp 0x36fd
movq -0x50(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x39e0
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3970
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1a20(%rip), %rsi      # 0x512c
movl $0x98, %edx
callq 0x25c0
movq -0x50(%rbp), %rdi
addq $0xa0, %rdi
callq 0x26e0
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
callq 0x26e0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: tiancihui[P]bo/./thread/threadWork.cpp
// Function: Thread::threadWork::~threadWork()
threadWork::~threadWork()
	{
		_argv = NULL;
        if(_job != NULL)
		{
		  delete _job ;
		}
		_pool = NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x311d(%rip), %rcx      # 0x7d88
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x28(%rax)
cmpq $0x0, 0x20(%rax)
je 0x4c9f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4c9d
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4c9f
movq -0x10(%rbp), %rdi
movq $0x0, 0x18(%rdi)
addq $0x80, %rdi
callq 0x2690
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2560
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2560
movq -0x10(%rbp), %rdi
callq 0x2740
addq $0x20, %rsp
popq %rbp
retq
// File: tiancihui[P]bo/./thread/threadWork.cpp
// Function: Thread::threadWork::Run()
void threadWork::Run()
	{
        for(;;)
		{
		  
           _workMutex.lock(__FUNCTION__,__LINE__);
		   while(_job == NULL)
		   {
			   _workCond.wait();
		   }

		   _job->Run(_argv);

		   _job->setWorkThread(NULL);
		   _job = NULL;
		   _pool->__busyMove2Idle(this);

           	_workMutex.unlock(__FUNCTION__,__LINE__);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
leaq 0x3bf(%rip), %rsi       # 0x50f2
movl $0x21, %edx
callq 0x2590
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x4d5a
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x26b0
jmp 0x4d3d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29d0
movq -0x10(%rbp), %rsi
movq $0x0, 0x20(%rsi)
movq 0x18(%rsi), %rdi
callq 0x35d0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
leaq 0x351(%rip), %rsi       # 0x50f2
movl $0x2d, %edx
callq 0x25c0
jmp 0x4d24
// File: tiancihui[P]bo/./thread/threadWork.cpp
// Function: Thread::threadWork::setJob(Thread::threadJob*, void*)
void threadWork::setJob(threadJob* job, void* argv)
	{
        _varMutex.lock(__FUNCTION__,__LINE__);
		_job = job;
		_argv = argv;
		_job->setWorkThread(this);
        _varMutex.unlock(__FUNCTION__,__LINE__);
        
		_workCond.notify();
        _workMutex.unlock(__FUNCTION__,__LINE__);

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
leaq 0x3a5(%rip), %rsi       # 0x517c
movl $0x33, %edx
callq 0x2590
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, 0x20(%rsi)
movq -0x18(%rbp), %rax
movq %rax, 0x28(%rsi)
movq 0x20(%rsi), %rdi
callq 0x29d0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
leaq 0x36f(%rip), %rsi       # 0x517c
movl $0x37, %edx
callq 0x25c0
movq -0x20(%rbp), %rdi
addq $0x80, %rdi
callq 0x26e0
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
leaq 0x346(%rip), %rsi       # 0x517c
movl $0x3a, %edx
callq 0x25c0
addq $0x20, %rsp
popq %rbp
retq
// File: 111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::log<char [4]>(char const (&) [4])
void ConsoleLogger::log(const Args&... args)
{
	if (loglevel > 0) return;
	mtx.lock();
	out << "    ";
	print(args...);
	mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x6c(%rax)
jle 0x2860
jmp 0x28a0
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x3740
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x67a6(%rip), %rsi      # 0x9024
callq 0x21c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3770
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::info<char [21]>(char const (&) [21])
void ConsoleLogger::info(const Args&... args)
{
	if (loglevel > 1) return;
	mtx.lock();
	if (colored) out << infoColor;
	out << "[i] ";
	if (colored) out << "\033[0m";
	print(args...);
	mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, 0x6c(%rax)
jle 0x3e90
jmp 0x3f07
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x3740
movq -0x18(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x3eba
movq -0x18(%rbp), %rsi
movq (%rsi), %rdi
addq $0x8, %rsi
callq 0x2190
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5291(%rip), %rsi      # 0x9159
callq 0x21c0
movq -0x18(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x3eea
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x523d(%rip), %rsi      # 0x9122
callq 0x21c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7750
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::warn<char [23]>(char const (&) [23])
void ConsoleLogger::warn(const Args&... args)
{
	if (loglevel > 2) return;
	mtx.lock();
	if (colored) out << warnColor;
	out << "[!] ";
	print(args...);
	if (colored) out << "\033[0m";
	mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, 0x6c(%rax)
jle 0x3f30
jmp 0x3fa7
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x3740
movq -0x18(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x3f5a
movq -0x18(%rbp), %rsi
movq (%rsi), %rdi
addq $0x28, %rsi
callq 0x2190
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x51b5(%rip), %rsi      # 0x911d
callq 0x21c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7790
movq -0x18(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x3f97
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5190(%rip), %rsi      # 0x9122
callq 0x21c0
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::error<char [23]>(char const (&) [23])
void ConsoleLogger::error(const Args&... args)
{
	if (loglevel > 3) return;
	mtx.lock();
	if (colored) out << errorColor;
	out << "[X] ";
	print(args...);
	if (colored) out << "\033[0m";
	mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x3, 0x6c(%rax)
jle 0x3fd0
jmp 0x4047
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x3740
movq -0x18(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x3ffa
movq -0x18(%rbp), %rsi
movq (%rsi), %rdi
addq $0x48, %rsi
callq 0x2190
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5156(%rip), %rsi      # 0x915e
callq 0x21c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7790
movq -0x18(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x4037
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x50f0(%rip), %rsi      # 0x9122
callq 0x21c0
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 111116[P]console/./consolelog.hpp
// Function: void github111116::ConsoleLogger::debug<char [43]>(char const (&) [43])
void ConsoleLogger::debug(const Args&... args)
{
#ifndef NDEBUG
	mtx.lock();
	out << "... ";
	print(args...);
	mtx.unlock();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xe0, %rdi
callq 0x3740
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x50e1(%rip), %rsi      # 0x9163
callq 0x21c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x77d0
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 111116[P]console/./consolelog.hpp
// Function: github111116::ConsoleLogger::time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void ConsoleLogger::time(const std::string& label)
{
	if (starttimes.count(label))
	{
		warn("Timer \"" + label + "\" already exists.");
		return;
	}
	mtx.lock();
	starttimes[label] = std::chrono::system_clock::now();
	mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x70, %rdi
movq -0x10(%rbp), %rsi
callq 0x4cb0
cmpq $0x0, %rax
je 0x453d
movq -0x10(%rbp), %rdx
leaq 0x4c3a(%rip), %rsi      # 0x9103
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4dd0
movq -0x78(%rbp), %rsi
leaq 0x4c2a(%rip), %rdx      # 0x910b
leaq -0x30(%rbp), %rdi
callq 0x4d80
jmp 0x44ec
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4ce0
jmp 0x44fb
leaq -0x30(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x457e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4532
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x4587
movq -0x70(%rbp), %rdi
addq $0xe0, %rdi
callq 0x3740
callq 0x2030
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x70, %rdi
movq -0x10(%rbp), %rsi
callq 0x4ee0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
addq $0xe0, %rdi
callq 0x37b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2310
// File: 111116[P]console/./consolelog.hpp
// Function: github111116::ConsoleLogger::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline long long ConsoleLogger::count(const std::string& label)
{
	mtx.lock();
	int t = ++counts[label];
	if (loglevel <= 0)
		out << "    "+label+": " << t << std::endl;
	mtx.unlock();
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0xe0, %rdi
callq 0x3740
movq -0x70(%rbp), %rdi
addq $0xa8, %rdi
movq -0x10(%rbp), %rsi
callq 0x6810
movq %rax, %rdx
movq -0x70(%rbp), %rax
movq (%rdx), %rcx
addq $0x1, %rcx
movq %rcx, (%rdx)
movl %ecx, -0x14(%rbp)
cmpl $0x0, 0x6c(%rax)
jg 0x4937
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x4795(%rip), %rsi      # 0x9024
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4dd0
movq -0x78(%rbp), %rsi
leaq 0x4891(%rip), %rdx      # 0x9138
leaq -0x38(%rbp), %rdi
callq 0x4d80
jmp 0x48b2
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2190
movq %rax, -0x88(%rbp)
jmp 0x48c8
movq -0x88(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x22f0
movq %rax, -0x90(%rbp)
jmp 0x48e0
movq -0x90(%rbp), %rdi
movq 0x96d2(%rip), %rsi      # 0xdfc0
callq 0x21e0
jmp 0x48f5
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x58(%rbp), %rdi
callq 0x2130
jmp 0x4937
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x492c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x58(%rbp), %rdi
callq 0x2130
jmp 0x4954
movq -0x70(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
movslq -0x14(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2310
nopl (%rax)
// File: 111116[P]console/./consolelog.hpp
// Function: github111116::ConsoleLogger::countReset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline long long ConsoleLogger::countReset(const std::string& label)
{
	if (!counts.count(label))
	{
		mtx.lock();
		warn("Counter \"" + label + "\" doesn't exist.");
		mtx.unlock();
		return -1;
	}
	mtx.lock();
	counts[label] = 0;
	if (loglevel <= 0)
		out << "    "+label+": 0" << std::endl;
	mtx.unlock();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0xa8, %rdi
movq -0x18(%rbp), %rsi
callq 0x75f0
cmpq $0x0, %rax
jne 0x4a54
movq -0xb0(%rbp), %rdi
addq $0xe0, %rdi
callq 0x3740
movq -0x18(%rbp), %rdx
leaq 0x4795(%rip), %rsi      # 0x914b
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4dd0
movq -0xb8(%rbp), %rsi
leaq 0x4753(%rip), %rdx      # 0x9127
leaq -0x38(%rbp), %rdi
callq 0x4d80
jmp 0x49df
movq -0xb0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4ce0
jmp 0x49f1
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x58(%rbp), %rdi
callq 0x2130
movq -0xb0(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
movq $-0x1, -0x8(%rbp)
jmp 0x4b7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4a46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x58(%rbp), %rdi
callq 0x2130
jmp 0x4b8b
movq -0xb0(%rbp), %rdi
addq $0xe0, %rdi
callq 0x3740
movq -0xb0(%rbp), %rdi
addq $0xa8, %rdi
movq -0x18(%rbp), %rsi
callq 0x6810
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movq $0x0, (%rcx)
cmpl $0x0, 0x6c(%rax)
jg 0x4b63
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x456f(%rip), %rsi      # 0x9024
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4dd0
movq -0xc0(%rbp), %rsi
leaq 0x467f(%rip), %rdx      # 0x9155
leaq -0x88(%rbp), %rdi
callq 0x4d80
jmp 0x4ae4
movq -0xc8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2190
movq %rax, -0xd0(%rbp)
jmp 0x4b00
movq -0xd0(%rbp), %rdi
movq 0x94b2(%rip), %rsi      # 0xdfc0
callq 0x21e0
jmp 0x4b15
leaq -0x88(%rbp), %rdi
callq 0x2130
leaq -0xa8(%rbp), %rdi
callq 0x2130
jmp 0x4b63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4b55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2130
leaq -0xa8(%rbp), %rdi
callq 0x2130
jmp 0x4b8b
movq -0xb0(%rbp), %rdi
addq $0xe0, %rdi
callq 0x37b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nop
// File: 111116[P]console/example_advanced.cpp
// Function: std::ostream& std::operator<<<int>(std::ostream&, std::vector<int, std::allocator<int>> const&)
std::ostream& operator<< (std::ostream& os, const std::vector<T>& v)
	{
		os << '[';
		if (!v.empty()) os << v[0];
		for (int i=1; i<v.size(); ++i)
			os << ',' << v[i];
		return os << ']';
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5b, %esi
callq 0x2210
movq -0x10(%rbp), %rdi
callq 0x8300
testb $0x1, %al
jne 0x828b
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8340
movq -0x20(%rbp), %rdi
movl (%rax), %esi
callq 0x22f0
movl $0x1, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8360
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x82e4
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x2210
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8340
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x22f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8292
movq -0x8(%rbp), %rdi
movl $0x5d, %esi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: aalto-speech[P]ftk/src/defs.hh
// Function: find_short_factors(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, unsigned int, bool)
static void find_short_factors(const std::map<std::string, flt_type> &vocab,
                               std::set<std::string> &short_factors,
                               unsigned int min_removal_length,
                               bool utf8)
{
    for (auto it = vocab.cbegin(); it != vocab.end(); ++it) {
        std::vector<unsigned int> char_positions;
        get_character_positions(it->first, char_positions, utf8);
        if (char_positions.size()-1 < min_removal_length)
            short_factors.insert(it->first);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8aa0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8ad0
testb $0x1, %al
jne 0x7bcd
jmp 0x7c71
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x8b00
leaq -0x20(%rbp), %rdi
callq 0x8b20
movq -0x68(%rbp), %rsi
movq %rax, %rdi
movzbl -0x15(%rbp), %edx
andl $0x1, %edx
callq 0x7c90
jmp 0x7bf8
leaq -0x40(%rbp), %rdi
callq 0x8b50
subq $0x1, %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x7c5a
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8b20
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x8b70
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x7c33
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
jmp 0x7c5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8bc0
jmp 0x7c7a
leaq -0x40(%rbp), %rdi
callq 0x8bc0
leaq -0x20(%rbp), %rdi
callq 0x8c20
jmp 0x7baa
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5700
nopw %cs:(%rax,%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: rdmSelectSet(int, int, int)
vector<int> rdmSelectSet(int begin, int end, int n)
{
	int size = end-begin+1;
	// implement Kruth shuffle algorithm
	vector<int> list(size);

	// init list 
	for (int i=begin; i<=end; i++)
		list[i] = i;

	// shuffle
	for (int i=size-1; i>=0; i--)
	{
		int j = rand()%(i+1);
		swap(list[i], list[j]);
	}

	return vector<int>(list.begin(), list.begin()+n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7a50
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7a70
jmp 0x4cde
leaq -0x31(%rbp), %rdi
callq 0x7ae0
movl -0xc(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x4d38
movl -0x48(%rbp), %eax
movl %eax, -0x94(%rbp)
movslq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7b00
movl -0x94(%rbp), %ecx
movl %ecx, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4ced
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x7ae0
jmp 0x4e35
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jl 0x4d93
callq 0x2070
movl -0x4c(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0x50(%rbp)
movslq -0x4c(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7b00
movq %rax, -0xa0(%rbp)
movslq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7b00
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x7b20
movl -0x4c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x4d41
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x7b50
movq -0xb0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x7b50
movq %rax, -0x68(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x7b80
movq %rax, -0x60(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x7a50
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rcx
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x7bc0
jmp 0x4df5
leaq -0x69(%rbp), %rdi
callq 0x7ae0
leaq -0x30(%rbp), %rdi
callq 0x7c40
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x7ae0
leaq -0x30(%rbp), %rdi
callq 0x7c40
movq -0x40(%rbp), %rdi
callq 0x2270
nop
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: dataSet::split_data(std::vector<data_inst, std::allocator<data_inst>>&, std::vector<data_inst, std::allocator<data_inst>>&)
void dataSet::split_data(vector<data_inst> &trainSet, vector<data_inst> &valiSet)
{
	vector<int> rdmPermutation(rdmSelectSet(0,dataSet.size()-1, dataSet.size()));
	int trainSize = TRAINPERCENT * (dataSet.size()/100);
	for (int i=0; i<(int)dataSet.size(); i++)
	{
		if (i<trainSize)
			trainSet.push_back(dataSet.at(rdmPermutation[i]));
		else
			valiSet.push_back(dataSet.at(rdmPermutation[i]));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3f80
movq -0x50(%rbp), %rdi
subq $0x1, %rax
movl %eax, -0x54(%rbp)
callq 0x3f80
movl -0x54(%rbp), %edx
movl %eax, %ecx
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x4c80
movq -0x50(%rbp), %rdi
callq 0x3f80
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
imulq $0x46, %rax, %rax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x50(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
callq 0x3f80
movq %rax, %rcx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jge 0x5681
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x5639
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movslq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7b00
movq -0x50(%rbp), %rdi
movslq (%rax), %rsi
callq 0x7f00
movq %rax, -0x60(%rbp)
jmp 0x5611
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x7d90
jmp 0x5620
jmp 0x5671
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7c40
jmp 0x5693
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movslq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7b00
movq -0x50(%rbp), %rdi
movslq (%rax), %rsi
callq 0x7f00
movq %rax, -0x70(%rbp)
jmp 0x5660
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x7d90
jmp 0x566f
jmp 0x5671
jmp 0x5673
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x55c5
leaq -0x30(%rbp), %rdi
callq 0x7c40
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: node::majClass()
int node::majClass()
{
	if (samplePool.size() == 0)
		return parentMajCls;
	else
	{
		int majCls = -1;
		int max = -1;
		for (int i=0; i<(int)size_of_each_class.size(); i++)
			if (size_of_each_class[i] > max)
			{
				max = size_of_each_class[i];
				majCls = i;
			}

		return majCls;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0x3f80
cmpq $0x0, %rax
jne 0x57be
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5837
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x8, %rdi
callq 0x7f80
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5831
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x7b00
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jle 0x5824
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x7b00
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5826
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57d3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: node::poolPure()
bool node::poolPure()
{
	for (auto size: size_of_each_class)
		if (size == (int)samplePool.size())
			return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7b50
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7fa0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7fd0
testb $0x1, %al
jne 0x5889
jmp 0x58c7
leaq -0x20(%rbp), %rdi
callq 0x8010
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
addq $0x30, %rdi
callq 0x3f80
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x58ba
movb $0x1, -0x1(%rbp)
jmp 0x58cb
jmp 0x58bc
leaq -0x20(%rbp), %rdi
callq 0x8030
jmp 0x5876
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: node::set_size_of_class()
int node::set_size_of_class()
{
	if (samplePool.size() == 0)
	{
//		cout << "set size error: size of samplePool is 0" << endl; //debug
		return -1;
	}
	else
	{
		vector<int> clsSize(samplePool.at(0).num_cls,0);

		// calculate number of member for each class
		for (auto item: samplePool)
			clsSize[item.cls]++;

		size_of_each_class = clsSize;
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x30, %rdi
callq 0x3f80
cmpq $0x0, %rax
jne 0x5915
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5a40
movq -0x88(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7f00
movslq 0x24(%rax), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7a50
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x8050
jmp 0x5968
leaq -0x2d(%rbp), %rdi
callq 0x7ae0
movq -0x88(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x7e00
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x7e30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7e60
testb $0x1, %al
jne 0x59ad
jmp 0x5a1a
leaq -0x50(%rbp), %rdi
callq 0x7ea0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x44d0
jmp 0x59c4
movslq -0x60(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7b00
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x80(%rbp), %rdi
callq 0x3540
leaq -0x50(%rbp), %rdi
callq 0x7ee0
jmp 0x599a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x7ae0
jmp 0x5a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7c40
jmp 0x5a4c
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x80d0
jmp 0x5a30
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7c40
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: decision_tree::destory_tree(node*)
void decision_tree::destory_tree(node* leaf)
{
	if (leaf != NULL)
	{
		destory_tree(leaf->leftChild);
		destory_tree(leaf->rightChild);
		delete leaf;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5b18
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x5ab0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x5ab0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5b16
movq -0x20(%rbp), %rdi
callq 0x87f0
movq -0x20(%rbp), %rdi
movl $0x58, %esi
callq 0x2180
jmp 0x5b18
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: decision_tree::impurity(std::vector<data_inst, std::allocator<data_inst>>)
float decision_tree::impurity(vector<data_inst> sampleSet)
{
	vector<int> sizeClass(sampleSet.at(0).num_cls, 0);

	for (auto sample: sampleSet)
		sizeClass[sample.cls]++;

	// sum of square of probability of each class
	float sum_square_of_p = 0;
	for (auto size: sizeClass)
		sum_square_of_p += pow(((double)size/(double)sampleSet.size()), 2.0);
	
	return 1-sum_square_of_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, %rax
movq -0xc8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x7f00
movslq 0x24(%rax), %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x7a50
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x8050
jmp 0x6993
leaq -0x2d(%rbp), %rdi
callq 0x7ae0
movq -0xc0(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x7e00
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x7e30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7e60
testb $0x1, %al
jne 0x69d4
jmp 0x6a47
leaq -0x50(%rbp), %rdi
callq 0x7ea0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x44d0
jmp 0x69eb
movslq -0x60(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7b00
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x80(%rbp), %rdi
callq 0x3540
leaq -0x50(%rbp), %rdi
callq 0x7ee0
jmp 0x69c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x7ae0
jmp 0x6b71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7c40
jmp 0x6b71
xorps %xmm0, %xmm0
movss %xmm0, -0x84(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
callq 0x7b50
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
callq 0x7fa0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x7fd0
testb $0x1, %al
jne 0x6a9f
jmp 0x6b3f
leaq -0x98(%rbp), %rdi
callq 0x8010
movq -0xc0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xa4(%rbp)
cvtsi2sdl -0xa4(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
callq 0x3f80
movsd -0xd0(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x859d(%rip), %xmm2     # 0xf080
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x85a1(%rip), %xmm2     # 0xf090
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x856e(%rip), %xmm1     # 0xf078
callq 0x2260
movaps %xmm0, %xmm1
movss -0x84(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x84(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x8030
jmp 0x6a83
movss 0x852d(%rip), %xmm0     # 0xf074
subss -0x84(%rbp), %xmm0
movss %xmm0, -0xd4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7c40
movss -0xd4(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2270
nopw (%rax,%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: decision_tree::classify(node*, data_inst)
int decision_tree::classify(node* nodePtr, data_inst valiInst)
{
	if (nodePtr->leftChild == NULL && nodePtr->rightChild == NULL)
		return nodePtr->majClass();
	else
		return classify(nodePtr->traceNextNode(valiInst), valiInst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x6c50
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x6c50
movq -0x18(%rbp), %rdi
callq 0x5790
movl %eax, -0x4(%rbp)
jmp 0x6d08
movq -0x90(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x44d0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x5720
movq -0x90(%rbp), %rsi
movq %rax, -0x98(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x44d0
jmp 0x6c9e
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x6c00
movl %eax, -0xac(%rbp)
jmp 0x6cbd
movl -0xac(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3540
leaq -0x48(%rbp), %rdi
callq 0x3540
jmp 0x6d08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x6cfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3540
leaq -0x48(%rbp), %rdi
callq 0x3540
jmp 0x6d14
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: random_forest::build_forest(std::vector<data_inst, std::allocator<data_inst>>)
void random_forest::build_forest(vector<data_inst> trainSet)
{
	int idx = 1;
	for (vector<decision_tree>::iterator itr = treeSet.begin();
		 	 itr != treeSet.end(); itr++)
	{
		//debug
		cout << "building tree " << idx << "... " << flush;
		itr->build_tree(treeBagging(trainSet));
		cout << "finished." << endl;
		idx++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x1, -0x14(%rbp)
callq 0x88b0
movq %rax, -0x20(%rbp)
movq -0x78(%rbp), %rdi
callq 0x8920
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x88e0
testb $0x1, %al
jne 0x6de2
jmp 0x6ee9
movq 0x101e7(%rip), %rdi     # 0x16fd0
leaq 0x82b0(%rip), %rsi      # 0xf0a0
callq 0x2160
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x8245(%rip), %rsi      # 0xf04f
callq 0x2160
movq %rax, %rdi
movq 0x101bf(%rip), %rsi     # 0x16fd8
callq 0x2190
leaq -0x20(%rbp), %rdi
callq 0x8950
movq -0x80(%rbp), %rsi
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2a60
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6f00
jmp 0x6e58
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5b20
jmp 0x6e6a
leaq -0x40(%rbp), %rdi
callq 0x2b50
leaq -0x58(%rbp), %rdi
callq 0x2b50
movq 0x1014d(%rip), %rdi     # 0x16fd0
leaq 0x8225(%rip), %rsi      # 0xf0af
callq 0x2160
movq %rax, %rdi
movq 0x10127(%rip), %rsi     # 0x16fc0
callq 0x2190
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x8970
movq %rax, -0x70(%rbp)
jmp 0x6dbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x6ede
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2b50
leaq -0x58(%rbp), %rdi
callq 0x2b50
jmp 0x6ef2
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2270
nopl (%rax,%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: random_forest::treeBagging(std::vector<data_inst, std::allocator<data_inst>>)
vector<data_inst> random_forest::treeBagging(vector<data_inst> trainSet)
{
	vector<data_inst> newTrainSet;
	int sample;

	for(int i=0; i<(int)trainSet.size(); i++)
	{
		sample = rand()%(trainSet.size());
		newTrainSet.push_back(trainSet.at(sample));
	}
	return newTrainSet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x28a0
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0x3f80
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x6fb7
callq 0x2070
movq -0x50(%rbp), %rdi
cltq
movq %rax, -0x68(%rbp)
callq 0x3f80
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x68(%rbp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x7f00
movq %rax, -0x60(%rbp)
jmp 0x6f84
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x7d90
jmp 0x6f93
jmp 0x6f95
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6f33
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2b50
jmp 0x6fd4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x6fca
movq -0x48(%rbp), %rdi
callq 0x2b50
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: analyser::analyse(random_forest&, std::vector<data_inst, std::allocator<data_inst>>)
void analyser::analyse(random_forest &forest, vector<data_inst> valiSet)
{
	int clsfyResult;
	for (int i=0; i<(int)valiSet.size(); i++)
	{
		clsfyResult = forest.classify(valiSet.at(i));
		confusionMtrx.at(clsfyResult).at(valiSet.at(i).cls)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x68(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x6c(%rbp)
callq 0x3f80
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7483
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x7f00
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x44d0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x6fe0
movl %eax, -0x70(%rbp)
jmp 0x740e
movl -0x70(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3540
movq -0x60(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x8b10
movq -0x68(%rbp), %rdi
movq %rax, -0x88(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x7f00
movq -0x88(%rbp), %rdi
movslq 0x20(%rax), %rsi
callq 0x85a0
movss 0x7c1e(%rip), %xmm0     # 0xf074
addss (%rax), %xmm0
movss %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x73ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3540
jmp 0x748c
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: analyser::get_precision(int)
float analyser::get_precision(int cls)
{
	// precision = true positive / positive
	float positive = 0;
	float true_positive = confusionMtrx.at(cls).at(cls);

	for (int i=0; i<(int)confusionMtrx.at(cls).size(); i++)
		positive += confusionMtrx.at(cls).at(i);

	return true_positive / positive;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x8b10
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x85a0
movss (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x8b10
movq %rax, %rdi
callq 0x4610
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x753b
movq -0x20(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x8b10
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x85a0
movss (%rax), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x74e4
movss -0x14(%rbp), %xmm0
divss -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 8igMac[P]random-forest/src/decision_tree.cpp
// Function: formatHandler::handle_format[abi:cxx11](char*)
vector<string> formatHandler::handle_format(char* fileName)
{
	ifstream ifs(fileName, ifstream::in);
	string buffer;
	vector<string> formatTb;
	
	// set number of attrubutes 
	// and number of classes(labels)
	ifs >> num_attr >> num_cls >> num_inst;

	// set format table
	while (ifs >> buffer)
		formatTb.push_back(buffer);

	ifs.close();
	return formatTb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x280(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x270(%rbp)
movl $0x8, %edx
callq 0x2280
leaq -0x240(%rbp), %rdi
callq 0x21e0
movq -0x278(%rbp), %rdi
movb $0x0, -0x241(%rbp)
callq 0x28c0
movq -0x270(%rbp), %rdi
movq -0x268(%rbp), %rsi
callq 0x20e0
movq %rax, -0x260(%rbp)
jmp 0x78ca
movq -0x260(%rbp), %rdi
movq -0x268(%rbp), %rsi
addq $0x4, %rsi
callq 0x20e0
movq %rax, -0x288(%rbp)
jmp 0x78ea
movq -0x288(%rbp), %rdi
movq -0x268(%rbp), %rsi
addq $0x8, %rsi
callq 0x20e0
jmp 0x7903
jmp 0x7905
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x21c0
movq %rax, -0x290(%rbp)
jmp 0x7921
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21b0
movb %al, -0x291(%rbp)
jmp 0x793f
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x794b
jmp 0x799a
movq -0x278(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x8b50
jmp 0x7960
jmp 0x7905
movq -0x278(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
callq 0x2910
leaq -0x240(%rbp), %rdi
callq 0x20f0
leaq -0x220(%rbp), %rdi
callq 0x2060
jmp 0x79ec
leaq -0x220(%rbp), %rdi
callq 0x2050
jmp 0x79a8
movb $0x1, -0x241(%rbp)
testb $0x1, -0x241(%rbp)
jne 0x79c4
movq -0x278(%rbp), %rdi
callq 0x2910
leaq -0x240(%rbp), %rdi
callq 0x20f0
leaq -0x220(%rbp), %rdi
callq 0x2060
movq -0x280(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x250(%rbp), %rdi
callq 0x2270
nopl (%rax,%rax)