LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::m_getCurrentEph_R(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double)
list<GLSEPH> RnxEphFileAdapter::m_getCurrentEph_R(string cprn, int mjd, double sod) {
	double dt,dtmin = 1.0;
	list<GLSEPH> list_out;
	list<GLSEPH>::iterator glsItr;
	for (glsItr = this->glsEph.begin(); glsItr != this->glsEph.end(); ++glsItr) {
		if (strstr((*glsItr).cprn, cprn.c_str())) {
			dt = (mjd - (*glsItr).mjd) * 24.0 + (sod - (*glsItr).sod) / 3600.0;
			if (fabs(dt) < dtmin) {
				list_out.push_back(*glsItr);
			}
		}
	}
	return list_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd 0x18ef(%rip), %xmm0     # 0xbbe60
movsd %xmm0, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
callq 0x45160
leaq -0x48(%rbp), %rdi
callq 0x54af0
movq -0x70(%rbp), %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
addq $0xd0, %rdi
callq 0x54b10
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x70(%rbp), %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
addq $0xd0, %rdi
callq 0x54b70
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x54b40
testb $0x1, %al
jne 0xba5dc
jmp 0xba6e4
leaq -0x48(%rbp), %rdi
callq 0x54c70
movq -0x88(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x92b0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x91b0
cmpq $0x0, %rax
je 0xba6d4
movl -0x1c(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x54c70
movq %rax, %rcx
movl -0xa4(%rbp), %eax
subl 0x4(%rcx), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x98(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x54c70
movsd -0xa0(%rbp), %xmm1
movsd -0x98(%rbp), %xmm0
subsd 0x10(%rax), %xmm1
movsd 0x27a2(%rip), %xmm2     # 0xbce10
divsd %xmm2, %xmm1
movsd 0xcf26(%rip), %xmm2     # 0xc75a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movaps 0x2b8d(%rip), %xmm0     # 0xbd220
pand %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xba6d2
leaq -0x48(%rbp), %rdi
callq 0x54c70
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x54c30
jmp 0xba6b9
jmp 0xba6d2
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x456f0
jmp 0xba704
jmp 0xba6d4
jmp 0xba6d6
leaq -0x48(%rbp), %rdi
callq 0x54ee0
jmp 0xba5ab
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0xba6f7
movq -0x80(%rbp), %rdi
callq 0x456f0
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: bestcoder12[P]Sudoku_Game/functions.cpp
// Function: user_gm::Player::timer(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
void Player::timer(std::chrono::steady_clock::time_point start)
{
    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
    std::chrono::duration<double,std::milli> t_diff = end-start;
    time_diff = t_diff.count() / 1000;
    int minute = 15 - (time_diff / 60);
    int seconds = 60 - ((int)time_diff % 60);   
    cout << "\t\t\t\t\t\t\t" << "Time left  " << minute << ":" << seconds << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2130
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x3630
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3680
leaq -0x20(%rbp), %rdi
callq 0x36c0
movq -0x38(%rbp), %rax
movsd 0x25b4(%rip), %xmm1     # 0x5018
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd (%rax), %xmm1
movsd 0x2598(%rip), %xmm0     # 0x5010
divsd %xmm0, %xmm1
movsd 0x2584(%rip), %xmm0     # 0x5008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, -0x2c(%rbp)
cvttsd2si (%rax), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl $0x3c, %eax
subl %edx, %eax
movl %eax, -0x30(%rbp)
movq 0x551c(%rip), %rdi      # 0x7fc8
leaq 0x260b(%rip), %rsi      # 0x50be
callq 0x2100
movq %rax, %rdi
leaq 0x2604(%rip), %rsi      # 0x50c6
callq 0x2100
movq %rax, %rdi
movl -0x2c(%rbp), %esi
callq 0x2190
movq %rax, %rdi
leaq 0x25f6(%rip), %rsi      # 0x50d2
callq 0x2100
movq %rax, %rdi
movl -0x30(%rbp), %esi
callq 0x2190
movq %rax, %rdi
leaq 0x28e8(%rip), %rsi      # 0x53de
callq 0x2100
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::print_board()
void Sudoku::print_board()
{
	for (int i = 0; i < 9; i++)
	{
		cout << "-------------------------------------" << "\n";
		for (int j = 0; j < 9; j++)
		{
			if (board[i][j].get_Int() == -1)
			{
				cout << "|" << "   "; 
				
				/*skips or jumps out of the condition if the row or column lies outside the range*/
				continue;
			}
			cout << "| " << board[i][j].get_Int() << " "; 
		}
		cout << "|" << "\n";
	}
	cout << "-------------------------------------" << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x346e
movq 0x4c5c(%rip), %rdi      # 0x7fc8
leaq 0x1f8f(%rip), %rsi      # 0x5302
callq 0x2100
movq %rax, %rdi
leaq 0x205c(%rip), %rsi      # 0x53de
callq 0x2100
movl $0x0, -0x10(%rbp)
cmpl $0x9, -0x10(%rbp)
jge 0x343e
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x23a0
cmpl $-0x1, %eax
jne 0x33e0
movq 0x4c05(%rip), %rdi      # 0x7fc8
leaq 0x1f5e(%rip), %rsi      # 0x5328
callq 0x2100
movq %rax, %rdi
leaq 0x1f51(%rip), %rsi      # 0x532a
callq 0x2100
jmp 0x3430
movq 0x4be1(%rip), %rdi      # 0x7fc8
leaq 0x1f40(%rip), %rsi      # 0x532e
callq 0x2100
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x23a0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x1f01(%rip), %rsi      # 0x532c
callq 0x2100
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x338e
movq 0x4b83(%rip), %rdi      # 0x7fc8
leaq 0x1edc(%rip), %rsi      # 0x5328
callq 0x2100
movq %rax, %rdi
leaq 0x1f83(%rip), %rsi      # 0x53de
callq 0x2100
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x335b
movq 0x4b53(%rip), %rdi      # 0x7fc8
leaq 0x1e86(%rip), %rsi      # 0x5302
callq 0x2100
movq %rax, %rdi
leaq 0x1f53(%rip), %rsi      # 0x53de
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::chk_win()
int Sudoku::chk_win()
{
	int err_chk = 0;

	for (int i = 0; i < 9; i++)
	{
		for (int j = 0; j < 9; j++)
		{
			if (board[i][j].get_Int() == -1)
			{
				return 0;
			}
		}
	}
	
	#ifdef __linux__
        err_chk = system("clear");
    #elif defined(_WIN32)
        err_chk = system("cls");
    #endif

	if (err_chk != 0)
	{
		cerr << "Error! Unable to clear the screen." << endl;
	}

	cout << "\n\n\n\n\t\t\t\tYOU HAVE WON THE GAME! CONGRATULATIONS!" << endl;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x9, -0x18(%rbp)
jge 0x351c
movl $0x0, -0x1c(%rbp)
cmpl $0x9, -0x1c(%rbp)
jge 0x350f
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x23a0
cmpl $-0x1, %eax
jne 0x3502
movl $0x0, -0x4(%rbp)
jmp 0x357c
jmp 0x3504
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x34cf
jmp 0x3511
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x34c2
leaq 0x1e0e(%rip), %rdi      # 0x5331
callq 0x20b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3553
movq 0x4ab8(%rip), %rdi      # 0x7ff0
leaq 0x1df8(%rip), %rsi      # 0x5337
callq 0x2100
movq %rax, %rdi
movq 0x4a62(%rip), %rsi      # 0x7fb0
callq 0x2110
movq 0x4a6e(%rip), %rdi      # 0x7fc8
leaq 0x1df9(%rip), %rsi      # 0x535a
callq 0x2100
movq %rax, %rdi
movq 0x4a40(%rip), %rsi      # 0x7fb0
callq 0x2110
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: findEmptyPlace(s_brd::cell (*) [9], int&, int&)
bool findEmptyPlace(cell t_board[9][9],int &row, int &col)
{ 
	for (row = 0; row < 9; row++)
	{
		for (col = 0; col < 9; col++)
		{
			if (t_board[row][col].get_Int() == -1) 
			{
				return true;
			}
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x9, (%rax)
jge 0x3e48
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
cmpl $0x9, (%rax)
jge 0x3e39
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x23a0
cmpl $-0x1, %eax
jne 0x3e2a
movb $0x1, -0x1(%rbp)
jmp 0x3e4c
jmp 0x3e2c
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3df1
jmp 0x3e3b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3dde
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::solveSudoku(s_brd::cell (*) [9])
bool Sudoku::solveSudoku(cell t_board[9][9])
{
	int row, col;
   
	/* If true all the cells are filled and the game is complete */
   	if (!findEmptyPlace(t_board,row,col))
	{
		return true;
   	}
  
	for (int num = 1; num <= 9; num++)
	{
		if (safetyInGrid(t_board, num, row, col))
		{
        
			this->board[row][col].set_Val(num,false);
         
			if (solveSudoku(t_board))	
        	{
           		return true;
        	}
         
        	this->board[row][col].set_Val(-1,true);
      	}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3dc0
testb $0x1, %al
jne 0x4046
movb $0x1, -0x1(%rbp)
jmp 0x40e9
movl $0x1, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jg 0x40e5
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x3e60
testb $0x1, %al
jne 0x406f
jmp 0x40d5
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x24(%rbp), %esi
xorl %edx, %edx
callq 0x2370
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4010
testb $0x1, %al
jne 0x40a6
jmp 0x40ac
movb $0x1, -0x1(%rbp)
jmp 0x40e9
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x2370
jmp 0x40d7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x404d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::init_gridPos()
void Sudoku::init_gridPos()
{
	srand(time(0));
	for (int i = 0; i < 81; i++)
	{
		this->gridPos[i] = i;
	}
	std::random_shuffle (this->gridPos, (this->gridPos)+81, genRandNum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x20e0
movl %eax, %edi
callq 0x20f0
movl $0x0, -0xc(%rbp)
cmpl $0x51, -0xc(%rbp)
jge 0x416e
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movslq -0xc(%rbp), %rcx
movl %edx, 0x514(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x414b
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x514, %rdi            # imm = 0x514
addq $0x514, %rsi            # imm = 0x514
addq $0x144, %rsi            # imm = 0x144
leaq -0x91(%rip), %rdx       # 0x4100
callq 0x3590
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::count_Sols(int&)
void Sudoku::count_Sols (int &num)
{
	int row, col;
	if (!findEmptyPlace(this->board, row, col))
	{
		num++;
		return;
	}
	std::default_random_engine defEngine(time(0));
	std::uniform_int_distribution<int> intDistro(1,9);
	int randNum = 0;

	for (int i = 0; i < 9 && num < 2; i++)
	{
		randNum = intDistro(defEngine);
		if (safetyInGrid(this->board,randNum,row,col))
		{
			this->board[row][col].set_Val(randNum,false);
			count_Sols(num);
		}

		this->board[row][col].set_Val(-1,true);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3dc0
testb $0x1, %al
jne 0x41d9
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x42c3
xorl %eax, %eax
movl %eax, %edi
callq 0x20e0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x43e0
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x9, %edx
callq 0x4410
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpl $0x9, -0x30(%rbp)
movb %al, -0x39(%rbp)
jge 0x4227
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4233
jmp 0x42c3
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4440
movq -0x38(%rbp), %rdi
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x3e60
testb $0x1, %al
jne 0x425b
jmp 0x428c
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x2c(%rbp), %esi
xorl %edx, %edx
callq 0x2370
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a0
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x2370
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x420f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: s_brd::Sudoku::cell_remover()
void Sudoku::cell_remover()
{	
	this->init_gridPos();
	for (int i = 0; i < 81 - filled; i++)
	{
		int x = gridPos[i]/9;
		int y = gridPos[i]%9;
		int temp_num = this->board[x][y].get_Int();
		this->board[x][y].set_Val(-1,true);

		int numSols = 0;
		count_Sols(numSols);

		if (numSols != 1)
		{
			this->board[x][y].set_Val(temp_num,false);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4120
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rdx
movl -0xc(%rbp), %eax
movl $0x51, %ecx
subl 0x288(%rdx), %ecx
cmpl %ecx, %eax
jge 0x43cf
movq -0x28(%rbp), %rdi
movslq -0xc(%rbp), %rax
movl 0x514(%rdi,%rax,4), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movslq -0xc(%rbp), %rax
movl 0x514(%rdi,%rax,4), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movslq -0x10(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x23a0
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movslq -0x10(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x2370
movq -0x28(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x41a0
cmpl $0x1, -0x1c(%rbp)
je 0x43bf
movq -0x28(%rbp), %rdi
movslq -0x10(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x18(%rbp), %esi
xorl %edx, %edx
callq 0x2370
jmp 0x43c1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x42f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ninjabear[P]dr-doom/src/main.cpp
// Function: get_mode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Mode get_mode(string& str) {
    if (str == "-h" || str == "--help") {
        return help;
    }

    if (str == "-v" || str == "--version") {
        return version;
    }

    if (str == "memory-cannon") {
        return memory;
    }

    if (str == "fork-bomb") {
        return fork_proc;
    }

    if (str == "halt-catch-fire") {
        return cpu;
    }

    if (str == "too-many-file-handles") {
        return file_handles;
    }

    if (str == "thread-bomb") {
        return thread_b;
    }

    return unknown;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x574f(%rip), %rsi      # 0x8136
callq 0x32b0
testb $0x1, %al
jne 0x2a06
movq -0x10(%rbp), %rdi
leaq 0x56f3(%rip), %rsi      # 0x80ee
callq 0x32b0
testb $0x1, %al
jne 0x2a06
jmp 0x2a12
movl $0x5, -0x4(%rbp)
jmp 0x2aed
movq -0x10(%rbp), %rdi
leaq 0x571c(%rip), %rsi      # 0x8139
callq 0x32b0
testb $0x1, %al
jne 0x2a3c
movq -0x10(%rbp), %rdi
leaq 0x56db(%rip), %rsi      # 0x810c
callq 0x32b0
testb $0x1, %al
jne 0x2a3c
jmp 0x2a48
movl $0x6, -0x4(%rbp)
jmp 0x2aed
movq -0x10(%rbp), %rdi
leaq 0x55fa(%rip), %rsi      # 0x804d
callq 0x32b0
testb $0x1, %al
jne 0x2a5e
jmp 0x2a6a
movl $0x0, -0x4(%rbp)
jmp 0x2aed
movq -0x10(%rbp), %rdi
leaq 0x55ee(%rip), %rsi      # 0x8063
callq 0x32b0
testb $0x1, %al
jne 0x2a80
jmp 0x2a89
movl $0x1, -0x4(%rbp)
jmp 0x2aed
movq -0x10(%rbp), %rdi
leaq 0x55e1(%rip), %rsi      # 0x8075
callq 0x32b0
testb $0x1, %al
jne 0x2a9f
jmp 0x2aa8
movl $0x4, -0x4(%rbp)
jmp 0x2aed
movq -0x10(%rbp), %rdi
leaq 0x55da(%rip), %rsi      # 0x808d
callq 0x32b0
testb $0x1, %al
jne 0x2abe
jmp 0x2ac7
movl $0x3, -0x4(%rbp)
jmp 0x2aed
movq -0x10(%rbp), %rdi
leaq 0x55d9(%rip), %rsi      # 0x80ab
callq 0x32b0
testb $0x1, %al
jne 0x2add
jmp 0x2ae6
movl $0x2, -0x4(%rbp)
jmp 0x2aed
movl $0x7, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ninjabear[P]dr-doom/src/main.cpp
// Function: are_you_sure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool are_you_sure(const string& prompt) {
    cout << prompt << endl;
    cout << endl;
    cout << "Are you sure? [y/N]: ";

    char ret = 0;
    cin.get(ret);

    return ret == 'y' || ret == 'Y';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq 0xa4b9(%rip), %rdi      # 0xcfd0
callq 0x21c0
movq %rax, %rdi
movq 0xa48a(%rip), %rsi      # 0xcfb0
callq 0x2230
movq 0xa49e(%rip), %rdi      # 0xcfd0
movq 0xa477(%rip), %rsi      # 0xcfb0
callq 0x2230
movq 0xa48b(%rip), %rdi      # 0xcfd0
leaq 0x55f0(%rip), %rsi      # 0x813c
callq 0x21f0
movb $0x0, -0x9(%rbp)
movq 0xa484(%rip), %rdi      # 0xcfe0
leaq -0x9(%rbp), %rsi
callq 0x22d0
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x79, %ecx
movb %al, -0xa(%rbp)
je 0x2b80
movsbl -0x9(%rbp), %eax
cmpl $0x59, %eax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ninjabear[P]dr-doom/src/cpu.cpp
// Function: consume_cpu()
void consume_cpu() {
    int max_cores = std::thread::hardware_concurrency();

    std::thread threads[max_cores];

    for (int i=0; i<max_cores; i++) {
        threads[i] = std::thread(consume_thread);
    }

    for (int i=0; i<max_cores; i++) { // this will never complete
        threads[i].join();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
callq 0x22c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x48(%rbp)
movq %rsp, %rcx
movq %rcx, -0x10(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3600
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rdx
shlq $0x3, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3750
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x35de
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3683
leaq 0x11a(%rip), %rsi       # 0x3730
leaq -0x28(%rbp), %rdi
callq 0x3770
jmp 0x3621
movq -0x40(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x3830
leaq -0x28(%rbp), %rdi
callq 0x3870
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3607
movq -0x40(%rbp), %rcx
movq %rdx, %rsi
movq -0x48(%rbp), %rdx
movq %rsi, -0x70(%rbp)
movq %rax, %rsi
movq -0x70(%rbp), %rax
movq %rsi, -0x30(%rbp)
movl %eax, -0x34(%rbp)
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x68(%rbp)
je 0x3723
jmp 0x36fb
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x36b2
movq -0x40(%rbp), %rax
movslq -0x38(%rbp), %rcx
leaq (%rax,%rcx,8), %rdi
callq 0x2360
jmp 0x36a5
jmp 0x36a7
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x368a
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rdx
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x78(%rbp)
je 0x36ef
movq -0x78(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x3870
movq -0x40(%rbp), %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x78(%rbp)
jne 0x36cd
movq -0x10(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x88(%rbp)
callq 0x3870
movq -0x40(%rbp), %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x36fb
jmp 0x3725
movq -0x30(%rbp), %rdi
callq 0x2390
nop
// File: ninjabear[P]dr-doom/src/memory.cpp
// Function: mt_consume_memory()
void mt_consume_memory() {   
    int max_cores = std::thread::hardware_concurrency();

    std::thread threads[max_cores];

    for (int i=0; i<max_cores; i++) {
        threads[i] = std::thread(consume_memory);
    }

    for (int i=0; i<max_cores; i++) { 
        threads[i].join();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
callq 0x22c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x48(%rbp)
movq %rsp, %rcx
movq %rcx, -0x10(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4f10
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rdx
shlq $0x3, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3750
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x4eee
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x4f93
leaq 0x11a(%rip), %rsi       # 0x5040
leaq -0x28(%rbp), %rdi
callq 0x3770
jmp 0x4f31
movq -0x40(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x3830
leaq -0x28(%rbp), %rdi
callq 0x3870
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f17
movq -0x40(%rbp), %rcx
movq %rdx, %rsi
movq -0x48(%rbp), %rdx
movq %rsi, -0x70(%rbp)
movq %rax, %rsi
movq -0x70(%rbp), %rax
movq %rsi, -0x30(%rbp)
movl %eax, -0x34(%rbp)
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x68(%rbp)
je 0x5033
jmp 0x500b
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x4fc2
movq -0x40(%rbp), %rax
movslq -0x38(%rbp), %rcx
leaq (%rax,%rcx,8), %rdi
callq 0x2360
jmp 0x4fb5
jmp 0x4fb7
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4f9a
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rdx
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x78(%rbp)
je 0x4fff
movq -0x78(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x3870
movq -0x40(%rbp), %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x78(%rbp)
jne 0x4fdd
movq -0x10(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x88(%rbp)
callq 0x3870
movq -0x40(%rbp), %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x500b
jmp 0x5035
movq -0x30(%rbp), %rdi
callq 0x2390
nop
// File: ninjabear[P]dr-doom/src/fork.cpp
// Function: fork_bomb()
void fork_bomb() {
    for (;;) {
        fork(); 
        void* ptr = malloc(MEM_WRITE_SIZE); // cajole the kernel into really forking our process
        if (ptr != NULL)
        {
            memset(ptr, 0xFF, MEM_WRITE_SIZE);
            free(ptr);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2060
movl $0x989680, %edi         # imm = 0x989680
callq 0x22b0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e6e
movq -0x8(%rbp), %rdi
movl $0xff, %esi
movl $0x989680, %edx         # imm = 0x989680
callq 0x2110
movq -0x8(%rbp), %rdi
callq 0x2290
jmp 0x5e38
// File: smuething[P]dune-cxx11/04-nullptr.cc
// Function: main
int main()
{
  int* i = nullptr;
  A* a = nullptr;
  assert(i == nullptr);
  assert(a == nullptr);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1168
jmp 0x1187
leaq 0xe95(%rip), %rdi       # 0x2004
leaq 0xe9b(%rip), %rsi       # 0x2011
movl $0x9, %edx
leaq 0xe9d(%rip), %rcx       # 0x201f
callq 0x1030
cmpq $0x0, -0x18(%rbp)
jne 0x1190
jmp 0x11af
leaq 0xe93(%rip), %rdi       # 0x202a
leaq 0xe73(%rip), %rsi       # 0x2011
movl $0xa, %edx
leaq 0xe75(%rip), %rcx       # 0x201f
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: nmmmnu[P]HM3/net/test/test_redisprotocol.cc
// Function: main
int main(){
	net::protocol::RedisProtocol p;

	test(p, "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n");

	test(p, "*2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");

	test(p, "*92\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "$2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "*2\r\n*3\r\nGET\r\n$4\r\ncity\r\n");

#if 0
	using Status = net::protocol::RedisProtocol::Status;

	const char *data = "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n";

	for(int i = 0; i < 2500000; ++i){
		const auto &status = p(data);

		if (status == Status::BUFFER_NOT_READ)
			std::cout << "problem" << '\n';
	}
#endif
}

// Assembly:
subq $0x38, %rsp
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1350
movq 0x8(%rsp), %rdi
leaq 0x1d45(%rip), %rsi      # 0x3004
callq 0x13a0
jmp 0x12c6
leaq 0x1d5a(%rip), %rsi      # 0x3027
leaq 0x20(%rsp), %rdi
callq 0x13a0
jmp 0x12d9
leaq 0x1d5f(%rip), %rsi      # 0x303f
leaq 0x20(%rsp), %rdi
callq 0x13a0
jmp 0x12ec
leaq 0x1d65(%rip), %rsi      # 0x3058
leaq 0x20(%rsp), %rdi
callq 0x13a0
jmp 0x12ff
leaq 0x1d6a(%rip), %rsi      # 0x3070
leaq 0x20(%rsp), %rdi
callq 0x13a0
jmp 0x1312
leaq 0x20(%rsp), %rdi
callq 0x1470
xorl %eax, %eax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1470
movq 0x18(%rsp), %rdi
callq 0x1110
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]HM3/net/test/test_redisprotocol.cc
// Function: void test<net::protocol::RedisProtocol>(net::protocol::RedisProtocol&, char const*)
void test(PROTOCOL &p, const char *data){
	using Status = typename PROTOCOL::Status;

	const Status status = p(data);

	std::cout	<< "Result status: " << test_status(status) << '\n'
			<< '\n'
	;

	if (status == Status::OK)
		p.print();

	std::cout	<< "---(eof)---" << '\n'
			<< '\n'
	;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1ca0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1ea0
movl %eax, 0x24(%rsp)
movq 0x3bf9(%rip), %rdi      # 0x4fd8
leaq 0x1cb2(%rip), %rsi      # 0x3098
callq 0x10a0
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %edi
callq 0x1cf0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x10a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x10d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x10d0
cmpl $0x0, 0x24(%rsp)
jne 0x1431
movq 0x30(%rsp), %rdi
callq 0x1e10
movq 0x3ba0(%rip), %rdi      # 0x4fd8
leaq 0x1c69(%rip), %rsi      # 0x30a8
callq 0x10a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x10d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x10d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: slafi[P]EventSystem/EventSystem/src/event.cpp
// Function: Events::Event::raise_event(Events::EventArgs*)
void Event::raise_event(EventArgs* args) {
		vector<unique_ptr<EventHandler>>::iterator func = this->_subscribed_handlers.begin();
		for (; func != this->_subscribed_handlers.end(); ++func) {
			if (*func != nullptr && (*func)->_id != 0) {
				(*func)->set_event_args(args);
				(*(*func))((*func)->get_event_args());
#if DEBUG_ENABLED
				std::cout << "Notifying event handler #: " << (*func)->_id << std::endl;
#endif
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5b80
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5bf0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5bb0
testb $0x1, %al
jne 0x5894
jmp 0x592d
leaq -0x18(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5c20
testb $0x1, %al
jne 0x58af
jmp 0x591d
leaq -0x18(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
callq 0x5c70
cmpl $0x0, 0x28(%rax)
je 0x591d
leaq -0x18(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
callq 0x5c70
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x70a0
leaq -0x18(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
callq 0x5c90
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
callq 0x5c70
movq %rax, %rdi
callq 0x6f40
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x6f10
jmp 0x591f
leaq -0x18(%rbp), %rdi
callq 0x5cc0
jmp 0x5871
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: slafi[P]EventSystem/EventSystem/src/event.cpp
// Function: Events::Event::remove_handler(Events::EventHandler const&)
void Event::remove_handler(const EventHandler &handler) {
		vector<unique_ptr<EventHandler>>::iterator to_remove = this->_subscribed_handlers.begin();
		for (; to_remove != this->_subscribed_handlers.end(); ++to_remove) {
			if (*(*to_remove) == handler) {
#if DEBUG_ENABLED
				std::cout << "Removing event handler #: " << (*to_remove)->_id << std::endl;
#endif
				this->_subscribed_handlers.erase(to_remove);
				break;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5b80
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5bf0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5bb0
testb $0x1, %al
jne 0x5a21
jmp 0x5a71
leaq -0x18(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
callq 0x5c90
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7040
testb $0x1, %al
jne 0x5a44
jmp 0x5a64
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5df0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5d80
movq %rax, -0x30(%rbp)
jmp 0x5a71
jmp 0x5a66
leaq -0x18(%rbp), %rdi
callq 0x5cc0
jmp 0x5a01
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: slafi[P]EventSystem/EventSystem/src/event_handler.cpp
// Function: Events::EventHandler::operator=(Events::EventHandler const&)
void EventHandler::operator=(const EventHandler &callback_func) {
		if (this->_callback_func == nullptr) {
			this->_callback_func = callback_func;
			this->_id = ++EventHandler::_witness_counter;
		}
		else {
			// Throw an exception to complain!
#if DEBUG_ENABLED
			std::cerr << "You cannot assign the event handler function again." << std::endl;
#endif
			throw new EventHandlerException("You cannot assign the event handler function again.");
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x7100
testb $0x1, %al
jne 0x6f87
jmp 0x6fac
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7130
movq -0x28(%rbp), %rax
movl 0x6222(%rip), %ecx      # 0xd1c0
addl $0x1, %ecx
movl %ecx, 0x6219(%rip)      # 0xd1c0
movl %ecx, 0x28(%rax)
jmp 0x702a
movl $0x8, %edi
callq 0x20d0
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x21e0
movq %rax, -0x30(%rbp)
jmp 0x6fca
movq -0x30(%rbp), %rdi
leaq 0x127b(%rip), %rsi      # 0x8250
callq 0x78a0
jmp 0x6fdc
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
leaq 0x5d42(%rip), %rsi      # 0xcd30
xorl %eax, %eax
movl %eax, %edx
callq 0x22d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x701f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x21f0
movq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x7030
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: slafi[P]EventSystem/EventSystem/src/event_args.cpp
// Function: Events::EventArgs::EventArgs()
EventArgs::EventArgs()
	{
		set_event_type(0);
		set_args(nullptr);

		// Assign timestamp automatically
		set_timestamp(format_timestamp());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2290
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x7720
jmp 0x76ae
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7740
jmp 0x76bd
leaq -0x38(%rbp), %rdi
callq 0x7970
jmp 0x76c8
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7760
jmp 0x76d7
leaq -0x38(%rbp), %rdi
callq 0x2100
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x7709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2100
movq -0x48(%rbp), %rdi
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: slafi[P]EventSystem/EventSystem/src/event_args.cpp
// Function: Events::EventArgs::EventArgs(int, std::map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
EventArgs::EventArgs(int event_type, std::map<int, string>* args)
	{
		set_event_type(event_type);
		set_args(args);
		
		// Assign timestamp automatically
		set_timestamp(format_timestamp());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x10, %rdi
movq %rdi, -0x58(%rbp)
callq 0x2290
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7720
jmp 0x77c6
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7740
jmp 0x77d5
leaq -0x48(%rbp), %rdi
callq 0x7970
jmp 0x77e0
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7760
jmp 0x77ef
leaq -0x48(%rbp), %rdi
callq 0x2100
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x7821
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2100
movq -0x58(%rbp), %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: slafi[P]EventSystem/EventSystem/src/utils.cpp
// Function: Events::format_timestamp[abi:cxx11]()
std::string format_timestamp()
	{
		time_t rawtime;
		struct tm * timeInfo;
		char buffer[80];

		time(&rawtime);
		timeInfo = localtime(&rawtime);

		strftime(buffer, sizeof(buffer), "%d-%m-%Y %H:%M:%S", timeInfo);
		std::string str(buffer);

		return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x21c0
movq -0xa8(%rbp), %rdi
callq 0x2150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x903(%rip), %rdx       # 0x82be
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x50, %esi
callq 0x2180
movb $0x0, -0x71(%rbp)
leaq -0x72(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2300
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x35f0
jmp 0x7a00
leaq -0x72(%rbp), %rdi
callq 0x2230
movb $0x1, -0x71(%rbp)
testb $0x1, -0x71(%rbp)
jne 0x7a3b
jmp 0x7a2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x72(%rbp), %rdi
callq 0x2230
jmp 0x7a4b
movq -0xa0(%rbp), %rdi
callq 0x2100
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
nop
// File: XuhuiSun95[P]Ticket-Booking-Service/client/ClientSocket.cpp
// Function: ClientSocket::Init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&)
void ClientSocket::Init(const std::string &ipaddress, const int &port) {

    if((mSockfd = socket(AF_INET, SOCK_STREAM, 0))<0) {
        std::cout << "Socket creation error" << std::endl;
        return;
    }
    memset(&mAddress, '0', sizeof(mAddress));

    mAddress.sin_family = AF_INET;
    mAddress.sin_port = htons(port);

    if(inet_pton(AF_INET, ipaddress.c_str(), &mAddress.sin_addr)<=0) {
        std::cout << "Invalid address/ Address not supported" << std::endl;
        return;
    }

    if(connect(mSockfd, (struct sockaddr *)&mAddress, sizeof(mAddress))<0) {
        std::cout << "Connection Failed" << std::endl;
        return;
    }

    mValid = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
movq -0x20(%rbp), %rcx
movl %eax, 0x4(%rcx)
cmpl $0x0, %eax
jge 0x25c0
movq 0x6a30(%rip), %rdi      # 0x8fd0
leaq 0x3a5d(%rip), %rsi      # 0x6004
callq 0x21d0
movq %rax, %rdi
movq 0x69fa(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x268a
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x2110
movq -0x20(%rbp), %rax
movw $0x2, 0xc(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movzwl %ax, %edi
callq 0x2040
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0xe(%rax)
movq -0x10(%rbp), %rdi
callq 0x20d0
movq -0x20(%rbp), %rdx
movq %rax, %rsi
addq $0xc, %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x2300
cmpl $0x0, %eax
jg 0x2645
movq 0x69a8(%rip), %rdi      # 0x8fd0
leaq 0x39eb(%rip), %rsi      # 0x601a
callq 0x21d0
movq %rax, %rdi
movq 0x6972(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x268a
movq -0x20(%rbp), %rsi
movl 0x4(%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x2180
cmpl $0x0, %eax
jge 0x2683
movq 0x696a(%rip), %rdi      # 0x8fd0
leaq 0x39d4(%rip), %rsi      # 0x6041
callq 0x21d0
movq %rax, %rdi
movq 0x6934(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x268a
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: XuhuiSun95[P]Ticket-Booking-Service/client/ClientSocket.cpp
// Function: ClientSocket::RequestTicket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ClientSocket::RequestTicket(const std::string &message) {

    //  Delay 5 second to simulate the time for message passing
    std::cout << "Request send" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    send(mSockfd, message.c_str(), message.length(), 0);

    mValread = read(mSockfd, buffer, 1024);
    std::cout << buffer << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x6901(%rip), %rdi      # 0x8fd0
leaq 0x397d(%rip), %rsi      # 0x6053
callq 0x21d0
movq %rax, %rdi
movq 0x68cb(%rip), %rsi      # 0x8fb0
callq 0x21f0
movl $0x5, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x2840
leaq -0x18(%rbp), %rdi
callq 0x2790
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2280
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x20f0
movq -0x28(%rbp), %rsi
movl 0x4(%rsi), %edi
addq $0x1c, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2270
movq -0x28(%rbp), %rsi
movl %eax, 0x8(%rsi)
addq $0x1c, %rsi
movq 0x6871(%rip), %rdi      # 0x8fd0
callq 0x21d0
movq %rax, %rdi
movq 0x6842(%rip), %rsi      # 0x8fb0
callq 0x21f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/client/UserInterface.cpp
// Function: UserInterface::UserInterface()
UserInterface::UserInterface() {

    std::cout << "==================================================" << std::endl;
    std::cout << "||"
              << std::setw(30) << std::right << "User Interface" 
              << std::setw(18) << std::right << "||" << std::endl;
    std::cout << "==================================================" << std::endl;

    mQuit = false;
    mServers = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3720
movq 0x64a5(%rip), %rdi      # 0x8fd0
leaq 0x353e(%rip), %rsi      # 0x6070
callq 0x21d0
movq %rax, -0x28(%rbp)
jmp 0x2b3d
movq -0x28(%rbp), %rdi
movq 0x6468(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x2b4f
movq 0x647a(%rip), %rdi      # 0x8fd0
leaq 0x3546(%rip), %rsi      # 0x60a3
callq 0x21d0
movq %rax, -0x40(%rbp)
jmp 0x2b68
movl $0x1e, %edi
callq 0x3740
movl %eax, -0x44(%rbp)
jmp 0x2b77
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2210
movq %rax, -0x50(%rbp)
jmp 0x2b8f
movq -0x50(%rbp), %rdi
leaq 0xbc6(%rip), %rsi       # 0x3760
callq 0x2090
movq %rax, -0x58(%rbp)
jmp 0x2ba5
movq -0x58(%rbp), %rdi
leaq 0x34f6(%rip), %rsi      # 0x60a6
callq 0x21d0
movq %rax, -0x60(%rbp)
jmp 0x2bbb
movl $0x12, %edi
callq 0x3740
movl %eax, -0x64(%rbp)
jmp 0x2bca
movq -0x60(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2210
movq %rax, -0x70(%rbp)
jmp 0x2be2
movq -0x70(%rbp), %rdi
leaq 0xb73(%rip), %rsi       # 0x3760
callq 0x2090
movq %rax, -0x78(%rbp)
jmp 0x2bf8
movq -0x78(%rbp), %rdi
leaq 0x34a0(%rip), %rsi      # 0x60a3
callq 0x21d0
movq %rax, -0x80(%rbp)
jmp 0x2c0e
movq -0x80(%rbp), %rdi
movq 0x6397(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x2c20
movq 0x63a9(%rip), %rdi      # 0x8fd0
leaq 0x3442(%rip), %rsi      # 0x6070
callq 0x21d0
movq %rax, -0x88(%rbp)
jmp 0x2c3c
movq -0x88(%rbp), %rdi
movq 0x6366(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x2c51
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3790
movq -0x10(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/client/UserInterface.cpp
// Function: UserInterface::Run()
void UserInterface::Run() {

    int opt = -1;

    while(!mQuit) {

        while(mServers<1)
            Init();

        OptionMessage();
        std::cin >> opt;
        if(!std::cin.good()) {

            std::cout << "Unknow option! Please enter again." << std::endl;
            std::cin.clear();
            std::cin.ignore(INT_MAX, '\n');
            continue;
        }

        switch(opt) {
            case 1:
                BuyTickets();
                break;
            case 2:
                mQuit = true;
                break;
            default:
                std::cout << "Unknow option! Please enter again." << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movb (%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2cdc
jmp 0x2dd5
jmp 0x2cde
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jge 0x2cf3
movq -0x18(%rbp), %rdi
callq 0x2de0
jmp 0x2cde
movq -0x18(%rbp), %rdi
callq 0x3210
movq 0x62dd(%rip), %rdi      # 0x8fe0
leaq -0xc(%rbp), %rsi
callq 0x2140
movq 0x62cd(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x62c3(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x22c0
testb $0x1, %al
jne 0x2d83
movq 0x629f(%rip), %rdi      # 0x8fd0
leaq 0x337d(%rip), %rsi      # 0x60b5
callq 0x21d0
movq %rax, %rdi
movq 0x6269(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x628d(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x6283(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x22b0
movq 0x6271(%rip), %rdi      # 0x8fe0
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl $0xa, %edx
callq 0x2160
jmp 0x2ccb
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x2d9a
jmp 0x2d90
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x2da5
jmp 0x2dae
movq -0x18(%rbp), %rdi
callq 0x3290
jmp 0x2dd0
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x2dd0
movq 0x621b(%rip), %rdi      # 0x8fd0
leaq 0x32f9(%rip), %rsi      # 0x60b5
callq 0x21d0
movq %rax, %rdi
movq 0x61e5(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x2ccb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/client/UserInterface.cpp
// Function: UserInterface::OptionMessage()
void UserInterface::OptionMessage() {

    std::cout << std::endl;
    std::cout << "1. Purchase Tickets" << std::endl;
    std::cout << "2. Quit" << std::endl;
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5dad(%rip), %rdi      # 0x8fd0
movq 0x5d86(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5d9a(%rip), %rdi      # 0x8fd0
leaq 0x2f38(%rip), %rsi      # 0x6175
callq 0x21d0
movq %rax, %rdi
movq 0x5d64(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5d78(%rip), %rdi      # 0x8fd0
leaq 0x2f2a(%rip), %rsi      # 0x6189
callq 0x21d0
movq %rax, %rdi
movq 0x5d42(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5d56(%rip), %rdi      # 0x8fd0
movq 0x5d2f(%rip), %rsi      # 0x8fb0
callq 0x21f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/client/main.cpp
// Function: main
int main(int argc, char* argv[]) {

    UserInterface* user = new UserInterface();

    user->Run();

    delete user;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x2b00
jmp 0x5331
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2cb0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5362
movq -0x38(%rbp), %rdi
callq 0x2c90
movq -0x38(%rbp), %rdi
callq 0x21c0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21c0
movq -0x20(%rbp), %rdi
callq 0x22e0