LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tiancihui[P]bo/./thread/threadPool.cpp
// Function: Thread::threadPool::__deleteIdleThread(int)
void  threadPool::__deleteIdleThread(int num)
	{
		_idleMutex.lock(__FUNCTION__,__LINE__);
		for(int i=0; i < num; i++)
		{
			if(_workIdleVec.size() > 0)
			{
				threadWork *removeThread = _workIdleVec.front();
				std::vector<threadWork *>::iterator pos;
				pos = std::find(_workIdleVec.begin(), _workIdleVec.end(), removeThread);
				if(pos != _workIdleVec.end())
				{
					_workIdleVec.erase(pos);
					_idleNum--;
				}

				std::vector<threadWork *>::iterator posTemp;
				posTemp = find(_workAllVec.begin(), _workAllVec.end(), removeThread);
				if(posTemp != _workAllVec.end())
				{
					_workAllVec.erase(posTemp);
					_allNum--;
				}

			}
		}
		_idleMutex.unlock(__FUNCTION__,__LINE__);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
leaq 0x1358(%rip), %rsi      # 0x40d9
movq %rbx, %rdi
movl $0x50, %edx
callq 0x24d2
testl %ebp, %ebp
jle 0x2e49
movq %rsp, %r15
movq 0x108(%r14), %rdi
movq 0x110(%r14), %rsi
cmpq %rdi, %rsi
je 0x2e41
movq (%rdi), %rax
movq %rax, (%rsp)
movq %r15, %rdx
callq 0x2f7e
movq 0x110(%r14), %rdx
cmpq %rdx, %rax
je 0x2df5
leaq 0x8(%rax), %rsi
cmpq %rdx, %rsi
je 0x2de6
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2210
movq 0x110(%r14), %rdx
addq $-0x8, %rdx
movq %rdx, 0x110(%r14)
decl 0x10(%r14)
movq 0xd8(%r14), %rdi
movq 0xe0(%r14), %rsi
movq %r15, %rdx
callq 0x2f7e
movq 0xe0(%r14), %rdx
cmpq %rdx, %rax
je 0x2e41
leaq 0x8(%rax), %rsi
cmpq %rdx, %rsi
je 0x2e32
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2210
movq 0xe0(%r14), %rdx
addq $-0x8, %rdx
movq %rdx, 0xe0(%r14)
decl 0xc(%r14)
decl %ebp
jne 0x2d99
leaq 0x1289(%rip), %rsi      # 0x40d9
movq %rbx, %rdi
movl $0x68, %edx
callq 0x24d8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x40(%rdi), %r14
leaq 0x1288(%rip), %rsi      # 0x410f
movq %r14, %rdi
movl $0x8a, %edx
callq 0x24d2
movq 0x110(%rbx), %rsi
cmpq 0x118(%rbx), %rsi
je 0x2eb1
movq %r15, (%rsi)
addq $0x8, 0x110(%rbx)
jmp 0x2ec2
leaq 0x108(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x302a
incl 0x10(%rbx)
leaq 0x1243(%rip), %r15      # 0x410f
movq %r14, %rdi
movq %r15, %rsi
movl $0x8d, %edx
callq 0x24d8
leaq 0x18(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x90, %edx
callq 0x24d2
movq 0xf0(%rbx), %rdi
movq 0xf8(%rbx), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2f7e
movq 0xf8(%rbx), %rdx
cmpq %rdx, %rax
je 0x2f3d
leaq 0x8(%rax), %rsi
cmpq %rdx, %rsi
je 0x2f2f
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2210
movq 0xf8(%rbx), %rdx
addq $-0x8, %rdx
movq %rdx, 0xf8(%rbx)
decl 0x14(%rbx)
leaq 0x11cb(%rip), %rsi      # 0x410f
movq %r14, %rdi
movl $0x98, %edx
callq 0x24d8
leaq 0xa0(%rbx), %rdi
callq 0x250e
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x250e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tiancihui[P]bo/./thread/threadWork.cpp
// Function: Thread::threadWork::~threadWork()
threadWork::~threadWork()
	{
		_argv = NULL;
        if(_job != NULL)
		{
		  delete _job ;
		}
		_pool = NULL;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2b9d(%rip), %rax      # 0x5d98
movq %rax, (%rdi)
movq $0x0, 0x28(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x3215
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
leaq 0x80(%rbx), %rdi
callq 0x24fe
leaq 0x58(%rbx), %rdi
callq 0x24c8
leaq 0x30(%rbx), %rdi
callq 0x24c8
movq %rbx, %rdi
popq %rbx
jmp 0x2528
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
leaq 0x80(%rdi), %r15
leaq 0xe5c(%rip), %r12       # 0x40d5
movq %r14, %rdi
movq %r12, %rsi
movl $0x21, %edx
callq 0x24d2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0x329c
movq %r15, %rdi
callq 0x2504
jmp 0x3289
movq 0x28(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0x2640
movq $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rdi
movq %rbx, %rsi
callq 0x2e68
movq %r14, %rdi
movq %r12, %rsi
movl $0x2d, %edx
callq 0x24d8
jmp 0x3279
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %r15
leaq 0xe0(%rdi), %rbx
movq %rbx, %rdi
callq 0x21f0
testl %eax, %eax
jne 0x36d1
leaq 0xa8(%r15), %rdi
movq %r12, %rsi
callq 0x40e0
movq (%rax), %r14
incq %r14
movq %r14, (%rax)
cmpl $0x0, 0x6c(%r15)
jg 0x36b7
movq (%r15), %r15
leaq 0x1a2b(%rip), %rsi      # 0x5020
leaq -0x68(%rbp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x39ca
leaq 0x1b47(%rip), %rsi      # 0x5152
movq %r13, %rdi
callq 0x2290
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x3638
movq %rsi, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x3643
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
callq 0x21b0
movq %rax, %rdi
movl %r14d, %esi
callq 0x2250
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x36a5
callq 0x2160
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36b7
callq 0x2160
movq %rbx, %rdi
callq 0x2120
movslq %r14d, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x20f0
movq %rax, %rbx
jmp 0x36ee
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x36ee
callq 0x2160
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3700
callq 0x2160
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa8(%rdi), %r12
movq %r12, %rdi
callq 0x44fc
movq %rax, %r13
leaq 0xe0(%r14), %rbx
movq %rbx, %rdi
callq 0x21f0
testq %r13, %r13
je 0x37bd
testl %eax, %eax
jne 0x38f1
movq %r12, %rdi
movq %r15, %rsi
callq 0x40e0
movq $0x0, (%rax)
cmpl $0x0, 0x6c(%r14)
jg 0x38d4
movq (%r14), %r14
leaq 0x18ac(%rip), %rsi      # 0x5020
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x39ca
leaq 0x19e5(%rip), %rsi      # 0x516f
movq %r12, %rdi
callq 0x2290
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x3861
movq %rsi, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x386b
testl %eax, %eax
jne 0x38f1
leaq 0x1999(%rip), %rsi      # 0x5165
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x39ca
leaq 0x195f(%rip), %rsi      # 0x5141
movq %r12, %rdi
callq 0x2290
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x380e
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x3815
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x392c
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x3846
callq 0x2160
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3858
callq 0x2160
movq $-0x1, %r14
jmp 0x38d7
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x21b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x38c2
callq 0x2160
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38d4
callq 0x2160
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2120
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x20f0
jmp 0x38fc
jmp 0x3901
movq %rax, %rbx
jmp 0x3912
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x3912
callq 0x2160
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3924
callq 0x2160
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x22(%rbp), %rsi
movb $0x5b, (%rsi)
movl $0x1, %edx
callq 0x21b0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x49f9
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2250
movq (%r14), %rax
movq 0x8(%r14), %rcx
jmp 0x49fc
movq %rax, %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
jb 0x4a45
movl $0x1, %r12d
leaq -0x21(%rbp), %r15
movb $0x2c, -0x21(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21b0
movq (%r14), %rcx
movl (%rcx,%r12,4), %esi
movq %rax, %rdi
callq 0x2250
incq %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x2, %rax
cmpq %r12, %rax
ja 0x4a0f
leaq -0x23(%rbp), %rsi
movb $0x5d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %edx, %eax
subl %esi, %eax
incl %eax
movslq %eax, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x526a
subl %r15d, %r14d
movl %r14d, %r12d
jl 0x2f3c
movq 0x8(%rsp), %rcx
movslq %r15d, %rdx
leaq 0x2(%r12), %rax
andq $-0x2, %rax
movq %r12, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
xorl %edx, %edx
movdqa 0x41e8(%rip), %xmm1     # 0x70b0
movdqa 0x41f0(%rip), %xmm2     # 0x70c0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x2f19
movl %r15d, -0x4(%rcx,%rdx,4)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x2f2f
leal 0x1(%r15), %esi
movl %esi, (%rcx,%rdx,4)
addq $0x2, %rdx
addl $0x2, %r15d
cmpq %rdx, %rax
jne 0x2ed8
testl %r14d, %r14d
js 0x2f6e
incl %r14d
callq 0x2070
cltd
idivl %r14d
movq 0x8(%rsp), %rax
movslq %edx, %rcx
movl (%rax,%r12,4), %edx
movl (%rax,%rcx,4), %esi
movl %esi, (%rax,%r12,4)
movl %edx, (%rax,%rcx,4)
decq %r12
decl %r14d
testl %r14d, %r14d
jg 0x2f44
movq 0x8(%rsp), %rsi
movslq %ebp, %rax
leaq (%rsi,%rax,4), %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x52f6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2f9e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2fc8
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rsi, %r15
shrq $0x3, %rax
imull $0xcccccccd, %eax, %ecx # imm = 0xCCCCCCCD
leal -0x1(%rcx), %edx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x2e60
movq (%r14), %r8
movq 0x8(%r14), %rcx
subq %r8, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r12, %rcx
testl %ecx, %ecx
jle 0x35cc
movq %rcx, %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
shrq $0x2, %rdx
movabsq $0x4600000000, %r13     # imm = 0x4600000000
imulq %rdx, %r13
sarq $0x20, %r13
xorl %ebp, %ebp
movq (%rsp), %rax
movslq (%rax,%rbp,4), %rsi
cmpq %rsi, %rcx
jbe 0x35f1
cmpq %r13, %rbp
movq %rbx, %rdi
cmovlq %r15, %rdi
leaq (%rsi,%rsi,4), %rax
leaq (%r8,%rax,8), %rsi
callq 0x53c4
incq %rbp
movq (%r14), %r8
movq 0x8(%r14), %rcx
subq %r8, %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
movslq %ecx, %rax
cmpq %rax, %rbp
jl 0x358b
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x35e2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3bf4(%rip), %rdi      # 0x71ec
movq %rcx, %rdx
xorl %eax, %eax
callq 0x21d0
jmp 0x3604
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x361d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x384c
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
callq 0x37f6
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x37f6
leaq 0x30(%rbx), %rdi
callq 0x2a6e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3838
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2180
movl $0x58, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x48(%rsi)
jne 0x45d4
cmpq $0x0, 0x50(%r15)
je 0x467e
movl (%r14), %eax
leaq 0x30(%rsp), %r12
movl %eax, -0x8(%r12)
leaq 0x8(%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2dc4
movq 0x20(%r14), %rax
movq %rax, 0x18(%r12)
movslq 0x20(%r15), %rax
movq (%r12), %rcx
movss 0x24(%r15), %xmm0
xorl %edx, %edx
ucomiss (%rcx,%rax,4), %xmm0
setb %dl
movq 0x48(%r15,%rdx,8), %r15
movl (%r14), %eax
leaq 0x8(%rsp), %rdi
movl %eax, -0x8(%rdi)
movq %r13, %rsi
callq 0x2dc4
movq 0x20(%r14), %rax
movq %rsp, %rdx
movq %rax, 0x20(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x45ac
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4657
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x466e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3664
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x46b2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x46b2
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x46c9
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq (%rdi), %r15
movq %rdi, 0x8(%rsp)
cmpq 0x8(%rdi), %r15
je 0x4816
movl $0x1, %ebp
movq 0x588d(%rip), %r12      # 0x9fd8
leaq 0x18(%rsp), %r13
leaq 0x30(%rsp), %rbx
movl $0xe, %edx
movq %r12, %rdi
leaq 0x29a8(%rip), %rsi      # 0x710c
callq 0x2190
movq %r12, %rdi
movl %ebp, %esi
callq 0x2230
movq %rax, %r14
movl $0x4, %edx
movq %rax, %rdi
leaq 0x28e6(%rip), %rsi      # 0x706b
callq 0x2190
movq %r14, %rdi
callq 0x20f0
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x29d4
movq %rbx, %rdi
movq %r13, %rdx
callq 0x484a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x384e
movq %rbx, %rdi
callq 0x2a6e
movq %r13, %rdi
callq 0x2a6e
movl $0x9, %edx
movq %r12, %rdi
leaq 0x2947(%rip), %rsi      # 0x711b
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incl %ebp
addq $0x8, %r15
movq 0x8(%rsp), %rax
cmpq 0x8(%rax), %r15
jne 0x4755
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4837
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2a6e
leaq 0x18(%rsp), %rdi
callq 0x2a6e
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
testl %eax, %eax
jle 0x48d7
movq %rdx, %r14
xorl %r15d, %r15d
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
callq 0x2070
cltq
movq (%r14), %rdi
movq 0x8(%r14), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
xorl %edx, %edx
divq %rcx
movslq %edx, %rsi
cmpq %rsi, %rcx
jbe 0x48e6
leaq (%rsi,%rsi,4), %rax
leaq (%rdi,%rax,8), %rsi
movq %rbx, %rdi
callq 0x53c4
movq 0x8(%r14), %rax
subq (%r14), %rax
incl %r15d
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
cmpl %eax, %r15d
jl 0x4888
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28ff(%rip), %rdi      # 0x71ec
movq %rcx, %rdx
xorl %eax, %eax
callq 0x21d0
jmp 0x48f9
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a6e
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/8igMac[P]random-forest/src/decision_tree.cpp
// Function: random_forest::classify(data_inst)
int random_forest::classify(data_inst valiInst)
{
	// vote
	vector<int> vote(valiInst.num_cls,0);
	for (vector<decision_tree>::iterator itr = treeSet.begin();
			 itr != treeSet.end(); itr++)
		vote.at(itr->classify(valiInst))++;

	// reach consensus among trees
	int majorVote=0;
	for (int i=1; i<(int)vote.size(); i++)
	{
		if (vote[majorVote] < vote[i])
			majorVote = i;
		else if (vote[majorVote] == vote[i])
		{
			// break tie by select random
			if (rand()%2 == 0)
				majorVote = i;
		}
	}

	return majorVote;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x24(%rsi), %rsi
leaq 0x2c(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x5412
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x49bb
leaq 0x38(%rsp), %r12
leaq 0x8(%rbx), %r13
leaq 0x30(%rsp), %rbp
movl (%rbx), %eax
movl %eax, 0x30(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2dc4
movq 0x20(%rbx), %rax
movq %rax, 0x50(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4520
movslq %eax, %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x4a3e
incl (%rax,%rsi,4)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x49b1
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x8, %r15
cmpq 0x8(%r14), %r15
jne 0x4955
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, %rcx
subq %rdi, %rcx
shrq $0x2, %rcx
xorl %ebx, %ebx
cmpl $0x2, %ecx
jl 0x4a1b
xorl %ebx, %ebx
movl $0x1, %r14d
movslq %ebx, %rcx
movl (%rdi,%r14,4), %edx
cmpl %edx, (%rdi,%rcx,4)
jge 0x49ef
movl %r14d, %ebx
jmp 0x4a06
jne 0x4a06
callq 0x2070
testb $0x1, %al
cmovel %r14d, %ebx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
incq %r14
movq %rax, %rcx
subq %rdi, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0x49de
testq %rdi, %rdi
je 0x4a2d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27a7(%rip), %rdi      # 0x71ec
xorl %eax, %eax
callq 0x21d0
movq %rax, %rbx
jmp 0x4a6d
jmp 0x4a53
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4a6d
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4a84
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
testl %edx, %edx
jle 0x4c5b
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %ebp
xorl %r12d, %r12d
cmpq %r12, %rdx
jbe 0x4c6a
leaq (%rcx,%rbp), %r13
addq $-0x18, %r13
movl -0x8(%r13), %eax
movl %eax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2dc4
movq 0x18(%r13), %rax
movq %rax, 0x20(%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0x490c
movl %eax, %r13d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4bd0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movslq %r13d, %rsi
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x4c82
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdi, %rdx
cmpq %r12, %rdx
jbe 0x4c6a
leaq (%rsi,%rsi,2), %r8
movslq (%rcx,%rbp), %rsi
movq (%rax,%r8,8), %rdi
movq 0x8(%rax,%r8,8), %rax
subq %rdi, %rax
sarq $0x2, %rax
cmpq %rsi, %rax
jbe 0x4c76
movss (%rdi,%rsi,4), %xmm0
addss 0x24c5(%rip), %xmm0     # 0x7108
movss %xmm0, (%rdi,%rsi,4)
incq %r12
movslq %edx, %rax
addq $0x28, %rbp
cmpq %rax, %r12
jl 0x4b7d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x257b(%rip), %rdi      # 0x71ec
movq %r12, %rsi
jmp 0x4c89
leaq 0x256f(%rip), %rdi      # 0x71ec
movq %rax, %rdx
jmp 0x4c89
leaq 0x2563(%rip), %rdi      # 0x71ec
xorl %eax, %eax
callq 0x21d0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4caa
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movslq %esi, %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x4d1c
leaq (%rsi,%rsi,2), %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x4d1c
movss (%rax,%rsi,4), %xmm0
testl %edx, %edx
jle 0x4d13
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorps %xmm1, %xmm1
xorl %ecx, %ecx
addss (%rax,%rcx,4), %xmm1
incq %rcx
cmpq %rcx, %rdx
jne 0x4d04
jmp 0x4d16
xorps %xmm1, %xmm1
divss %xmm1, %xmm0
popq %rax
retq
leaq 0x24c9(%rip), %rdi      # 0x71ec
xorl %eax, %eax
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/8igMac[P]random-forest/src/decision_tree.cpp
// Function: analyser::get_recall(int)
float analyser::get_recall(int cls)
{
	// recall = true positive / actual
	// actual = (true_positive + false_negative)
	float actual = 0;
	float true_positive = confusionMtrx.at(cls).at(cls);

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

	return true_positive / actual;
}

// Assembly:
pushq %rax
movslq %esi, %rsi
movq (%rdi), %r8
movq 0x8(%rdi), %rax
subq %r8, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x4dd5
leaq (%rsi,%rsi,2), %rax
movq (%r8,%rax,8), %rcx
movq 0x8(%r8,%rax,8), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rsi, %rax
jbe 0x4dde
movss (%rcx,%rsi,4), %xmm0
testl %eax, %eax
jle 0x4daf
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq $0x8, %r8
xorps %xmm1, %xmm1
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x4db8
movq -0x8(%r8), %r9
movq (%r8), %rcx
subq %r9, %rcx
sarq $0x2, %rcx
cmpq %rsi, %rcx
jbe 0x4dc4
addss (%r9,%rsi,4), %xmm1
incq %rdi
addq $0x18, %r8
cmpq %rdi, %rax
jne 0x4d83
jmp 0x4db2
xorps %xmm1, %xmm1
divss %xmm1, %xmm0
popq %rax
retq
leaq 0x242d(%rip), %rdi      # 0x71ec
movq %rdx, %rsi
jmp 0x4dce
leaq 0x2421(%rip), %rdi      # 0x71ec
movq %rcx, %rdx
xorl %eax, %eax
callq 0x21d0
leaq 0x2410(%rip), %rdi      # 0x71ec
jmp 0x4dce
leaq 0x2407(%rip), %rdi      # 0x71ec
movq %rax, %rdx
jmp 0x4dce
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x2260
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20e0
leaq 0x4(%r14), %rsi
movq %rax, %rdi
callq 0x20e0
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x20e0
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x51ed
movq %rbx, %rdi
movq %r15, %rsi
callq 0x59b0
jmp 0x51c7
leaq 0x20(%rsp), %rdi
callq 0x2050
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x520d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x522b
movq %rax, %r14
movq %rbx, %rdi
callq 0x28ec
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x524c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/mrexodia[P]AsmParser/AsmParser.cpp
// Function: AsmParser::appendToken(AsmParser::Token::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void appendToken(Token::Type type, const std::string & data)
    {
        Token t;
        t.type = type;
        t.data = data;
        mTokens.push_back(t);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movl %esi, -0x18(%r14)
movq %rdx, %rsi
callq 0x10a0
addq $0x40, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x264a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2530
callq 0x1110
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x254a
callq 0x1110
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O3/mrexodia[P]AsmParser/AsmParser.cpp
// Function: AsmParser::getTokenType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Token::Type getTokenType(const std::string & data)
    {
        if(mSegments.count(data))
            return Token::Segment;
        if(mMemsizes.count(data))
            return Token::Memsize;
        if(mRegisters.count(data))
            return Token::Register;
        if(mPrefixes.count(data))
            return Token::Prefix;
        if(data == "ptr")
            return Token::Ptr;
        if(mTokens.empty() || mTokens[mTokens.size() - 1].type == Token::Prefix)
            return Token::Mnemonic;        
        return Token::Unknown;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x100, %rdi            # imm = 0x100
callq 0x2606
movq %rax, %rcx
movl $0x7, %eax
testq %rcx, %rcx
jne 0x25c9
leaq 0xc8(%rbx), %rdi
movq %r14, %rsi
callq 0x2606
movq %rax, %rcx
movl $0x5, %eax
testq %rcx, %rcx
jne 0x25c9
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x2606
movq %rax, %rcx
movl $0x3, %eax
testq %rcx, %rcx
jne 0x25c9
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x2606
movq %rax, %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x25ce
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb40(%rip), %rsi       # 0x3115
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
je 0x25f8
movq 0x48(%rbx), %rcx
cmpq %rcx, 0x40(%rbx)
je 0x25ff
xorl %eax, %eax
cmpl $0x1, -0x28(%rcx)
sete %al
addl %eax, %eax
jmp 0x25c9
movl $0x6, %eax
jmp 0x25c9
movl $0x2, %eax
jmp 0x25c9
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_free_groups()
void _free_groups()
    {
        if (_first_group)
        {
            for (group_type *g = _first_group; g != _last_group; ++g)
                g->destruct(_alloc);
            _free_group_array(_first_group, _last_group);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x17b5
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rax, %r14
je 0x17a7
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1796
callq 0x10d0
movq $0x0, (%r14)
movq 0x8(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r14
jne 0x177e
movq (%rbx), %r14
testq %r14, %r14
je 0x17b5
movq %r14, %rdi
callq 0x10d0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<spp::Two_d_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::bidirectional_iterator_tag>, bool> spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_insert_noresize<std::pair<unsigned int const, unsigned int>>(std::pair<unsigned int const, unsigned int>&)
std::pair<iterator, bool> _insert_noresize(T& obj)
    {
        Position pos = _find_position(get_key(obj));
        bool already_there = (pos._t == pt_full);

        if (!already_there)
        {
            reference ref(_insert_at(obj, pos._idx, pos._t == pt_erased));
            return std::pair<iterator, bool>(_mk_iterator(table.get_iter(pos._idx, &ref)), true);
        }
        return std::pair<iterator,bool>(_mk_iterator(table.get_iter(pos._idx)), false);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x275a
movq %rdx, %r15
cmpl $0x2, %eax
jne 0x1bcf
addq $0x30, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2964
movq %rax, %rcx
movq %rdx, %rax
xorl %edx, %edx
jmp 0x1bf7
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x289c
shrq $0x5, %r15
leaq (%r15,%r15,2), %rcx
shlq $0x3, %rcx
addq 0x30(%r14), %rcx
movb $0x1, %dl
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movb %dl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::clear()
void clear()
    {
        if (!empty() || num_deleted != 0)
        {
            table.clear();
            table = Table(HT_DEFAULT_STARTING_BUCKETS, table.get_allocator());
        }
        settings.reset_thresholds(bucket_count());
        num_deleted = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
orq 0x48(%rdi), %rax
je 0x2250
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x1766
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq $0x20, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x30, %edi
callq 0x10f0
movq %rax, %r14
movq %rax, (%rsp)
leaq 0x18(%rax), %r12
movq $-0x1, 0x18(%rax)
movq %r12, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movw $0x0, 0x10(%rax)
movq %r15, %rdi
callq 0x1766
movups 0x30(%rbx), %xmm0
movq %r14, 0x30(%rbx)
movq %r12, 0x38(%rbx)
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x20, 0x40(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x48(%rbx)
movq %rax, 0x18(%rdi)
callq 0x1766
movq 0x40(%rbx), %rax
testq %rax, %rax
js 0x2263
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x227b
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movss 0x10(%rbx), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
movss 0xda8(%rip), %xmm2      # 0x3040
subss %xmm2, %xmm1
cvttss2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, (%rbx)
mulss 0x14(%rbx), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss %xmm2, %xmm0
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x8(%rbx)
movb $0x0, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x22fb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1766
movq %rbx, %rdi
callq 0x1150
movq %rax, %rdi
callq 0x17bd
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::Two_d_destructive_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::input_iterator_tag, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::advance_past_end()
void advance_past_end()
    {
        // used when col_current points to end()
        while (this->col_current == this->row_current->ne_end())
        {
            this->row_current->clear(_alloc, true);  // This is what differs from non-destructive iterators above

            // end of current row
            // ------------------
            ++this->row_current;                          // go to beginning of next
            if (!this->row_current->is_marked())          // col is irrelevant at end
                this->col_current = this->row_current->ne_begin();
            else
                break;                                    // don't go past row_end
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %rdi
movzbl 0x10(%r14), %eax
leaq (%rdi,%rax,8), %rax
cmpq %rax, 0x8(%rbx)
jne 0x2604
leaq 0x10(%r14), %r15
xorl %ebp, %ebp
movq %r14, %rax
testq %rdi, %rdi
je 0x25d6
callq 0x10d0
movq $0x0, (%r14)
movq (%rbx), %rax
movq $0x0, 0x8(%r14)
movb %bpl, (%r15)
movb %bpl, 0x11(%r14)
leaq 0x18(%rax), %r14
movq %r14, (%rbx)
movq 0x18(%rax), %rdi
cmpq $-0x1, %rdi
je 0x2604
movq %rdi, 0x8(%rbx)
leaq 0x28(%rax), %r15
cmpb $0x0, 0x28(%rax)
je 0x25bf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: void spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_set<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, unsigned char, std::pair<unsigned int const, unsigned int>&)
void _set(allocator_type &alloc, size_type i, size_type offset, Val &val)
    {
        if (!_bmtest(i))
        {
            _set_aux(alloc, offset, val, check_alloc_type());
            _incr_num_items();
            _bmset(i);
        }
        else
            _set_val(&_group[offset], val);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %eax
movl %edx, %ecx
movq %rdi, %rbx
movl 0x8(%rdi), %edx
movl $0x1, %ebp
shll %cl, %ebp
btl %ecx, %edx
jae 0x263f
movq (%rbx), %rcx
movzbl %al, %eax
movl (%r8), %edx
movl %edx, (%rcx,%rax,8)
movl 0x4(%r8), %edx
movl %edx, 0x4(%rcx,%rax,8)
jmp 0x2653
movzbl %al, %edx
movq %rbx, %rdi
movq %r8, %rcx
callq 0x265a
incb 0x10(%rbx)
orl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: void spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_set_aux<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, std::pair<unsigned int const, unsigned int>&, spp::integral_constant<bool, true>)
void _set_aux(allocator_type &alloc, size_type offset, Val &val, realloc_ok_type)
    {
        //static int x=0;  if (++x < 10) printf("x\n"); // check we are getting here

        uint32_t  num_items = _num_items();
        uint32_t  num_alloc = _sizing(num_items);

        if (num_items == num_alloc)
        {
            num_alloc = _sizing(num_items + 1);
            _group = alloc.reallocate(_group, num_alloc);
            _set_num_alloc(num_alloc);
        }

        for (uint32_t i = num_items; i > offset; --i)
            memcpy(_group + i, _group + i-1, sizeof(*_group));

        _init_val((mutable_pointer)(_group + offset), val);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movzbl 0x10(%rdi), %r15d
movl %r15d, %edi
callq 0x26d0
cmpl %r15d, %eax
jne 0x269d
leal 0x1(%r15), %edi
callq 0x26d0
movl %eax, %r12d
movq (%r14), %rdi
movl %eax, %esi
shlq $0x3, %rsi
callq 0x1120
movq %rax, (%r14)
movb %r12b, 0x11(%r14)
movzbl %bpl, %eax
cmpb %al, %r15b
jbe 0x26bc
movl %r15d, %ecx
movq (%r14), %rdx
movq -0x8(%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
decq %rcx
cmpl %eax, %ecx
ja 0x26a9
movq (%r14), %rcx
movq (%rbx), %rdx
movq %rdx, (%rcx,%rax,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_sizing(unsigned int)::alloc_batch_size::alloc_batch_size()
SPP_CXX14_CONSTEXPR alloc_batch_size()
                : data()
            {
                uint8_t group_sz          = SPP_GROUP_SIZE / 4;
                uint8_t group_start_alloc = SPP_GROUP_SIZE / 8; //4;
                uint8_t alloc_sz          = group_start_alloc;
                for (int i=0; i<4; ++i)
                {
                    for (int j=0; j<group_sz; ++j)
                    {
                        if (j && j % group_start_alloc == 0)
                            alloc_sz += group_start_alloc;
                        data[i * group_sz + j] = alloc_sz;
                    }
                    if (group_start_alloc > 2)
                        group_start_alloc /= 2;
                    alloc_sz += group_start_alloc;
                }
            }

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movb $0x4, %al
xorl %edx, %edx
xorl %esi, %esi
movb $0x4, %r8b
leal 0x7(%r8), %ecx
movzbl %r8b, %r9d
xorl %r10d, %r10d
testb %r10b, %cl
movl $0x0, %r11d
cmovel %r9d, %r11d
testq %r10, %r10
cmovel %edx, %r11d
addb %r11b, %al
movb %al, (%rdi,%r10)
incq %r10
cmpq $0x8, %r10
jne 0x271a
cmpb $0x3, %r8b
setae %cl
shrb %cl, %r8b
addb %r8b, %al
incq %rsi
addq $0x8, %rdi
cmpq $0x4, %rsi
jne 0x270f
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<unsigned int const, unsigned int>& spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_insert_at<std::pair<unsigned int const, unsigned int>>(std::pair<unsigned int const, unsigned int>&, unsigned long, bool)
reference _insert_at(T& obj, size_type pos, bool erased)
    {
        if (size() >= max_size())
        {
            throw_exception(std::length_error("insert overflow"));
        }
        if (erased)
        {
            assert(num_deleted);
            --num_deleted;
        }
        return table.set(pos, obj);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movabsq $0x1fffffffffffffff, %rsi # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rsi, 0x48(%rdi)
jae 0x28e0
testb %cl, %cl
je 0x28ca
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x2930
decq %rcx
movq %rcx, 0x28(%rdi)
addq $0x30, %rdi
movq %rdx, %rsi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x29f0
leaq 0x1282(%rip), %rsi      # 0x3b69
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10c0
movl $0x10, %edi
callq 0x1070
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1130
movq 0x36bd(%rip), %rax      # 0x5fd0
addq $0x10, %rax
movq %rax, (%r14)
movq 0x36bf(%rip), %rsi      # 0x5fe0
movq 0x36a0(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x1140
leaq 0x1242(%rip), %rdi      # 0x3b79
leaq 0x78d(%rip), %rsi       # 0x30cb
leaq 0x1240(%rip), %rcx      # 0x3b85
movl $0xc67, %edx            # imm = 0xC67
callq 0x10a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1178
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/mshinfo/mshinfo.cpp
// Function: NumBoundaryEdges(gaps::R3Mesh*)
int NumBoundaryEdges(R3Mesh *mesh)
{
  // Count number of boundary edges
  int count = 0;
  for (int i = 0; i < mesh->NEdges(); i++) {
    R3MeshEdge *edge = mesh->Edge(i);
    R3MeshFace *face0 = mesh->FaceOnEdge(edge, 0);
    R3MeshFace *face1 = mesh->FaceOnEdge(edge, 1);
    if (!face0 || !face1) count++;
  }
  return count;
}

// Assembly:
movslq 0x24(%rdi), %rcx
testq %rcx, %rcx
jle 0xe6b5
movq 0x18(%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %rdi
cmpq $0x0, 0x18(%rdi)
sete %r8b
cmpq $0x0, 0x20(%rdi)
sete %dil
orb %r8b, %dil
movzbl %dil, %edi
addl %edi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0xe68d
retq
xorl %eax, %eax
retq